No OneTemporary
Actions

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/actions/sync.cpp b/src/client/actions/sync.cpp
	index 60b7ee7..04e1ff0 100644
	--- a/src/client/actions/sync.cpp
	+++ b/src/client/actions/sync.cpp
	@@ -1,380 +1,380 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2024 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <lager/util.hpp>
	#include <zug/transducer/map.hpp>
	#include <zug/transducer/cat.hpp>
	#include <zug/transducer/filter.hpp>
	#include <zug/sequence.hpp>

	#include <jobinterface.hpp>
	#include <debug.hpp>

	#include "cursorutil.hpp"

	#include "sync.hpp"

	#include "encryption.hpp"
	#include "status-utils.hpp"

	namespace Kazv
	{
	// Atomicity guaranteed: if the sync action is created
	// before an action that reasonably changes Client
	// (e.g. roll back to an earlier state, obtain other
	// events), but executed
	// after that action, the sync will still give continuous
	// data about the events. (Sync will not "skip" events)
	// This is because this function takes the sync token
	// from the ClientModel model it is passed.
	ClientResult updateClient(ClientModel m, SyncAction)
	{
	kzo.client.dbg() << "Start syncing with token " <<
	(m.syncToken ? m.syncToken.value() : "<null>") << std::endl;

	bool isInitialSync = ! m.syncToken;

	m.syncing = true;

	std::string filter = m.syncToken ? m.incrementalSyncFilterId : m.initialSyncFilterId;
	m.addJob(m.job<SyncJob>()
	.make(filter,
	m.syncToken,
	std::nullopt, // fullState
	std::nullopt, // setPresence
	// Let initial sync return immediately
	isInitialSync ? 0 : m.syncTimeoutMs
	)
	.withData(json{{"is", isInitialSync ? "initial" : "incremental"}}));
	return { m, lager::noop };
	}


	static KazvEventList loadRoomsFromSyncInPlace(ClientModel &m, SyncJob::Rooms rooms)
	{
	auto l = std::move(m.roomList);
	auto eventsToEmit = KazvEventList{}.transient();

	auto pushRules = PushRulesDesc(m.accountData["m.push_rules"]);

	auto updateRoomImpl =
	[&l](auto id, auto a) {
	l = RoomListModel::update(
	std::move(l),
	UpdateRoomAction{std::move(id), std::move(a)});
	};
	auto updateSingleRoom =
	[&, updateRoomImpl](const auto &id, const auto &room, auto membership) {
	if (!l.has(id) \|\| l[id].membership != membership) {
	eventsToEmit.push_back(RoomMembershipChanged{membership, id});
	}
	updateRoomImpl(id, ChangeMembershipAction{membership});

	auto timelineEvents =
	intoImmer(
	EventList{},
	zug::map([=](Event e) {
	return Event::fromSync(e, id);
	}),
	room.timeline.events);
	eventsToEmit.append(
	intoImmer(
	KazvEventList{},
	zug::map([=](Event e) -> KazvEvent {
	return ReceivingRoomTimelineEvent{std::move(e), id};
	}),
	timelineEvents).transient());
	updateRoomImpl(id, AddToTimelineAction{timelineEvents,
	room.timeline.prevBatch,
	room.timeline.limited,
	std::nullopt // we do not have a gapEventId
	});
	if (room.state) {
	eventsToEmit.append(
	intoImmer(
	KazvEventList{},
	zug::map([=](Event e) -> KazvEvent {
	return ReceivingRoomStateEvent{std::move(e), id};
	}),
	room.state.value().events).transient());
	updateRoomImpl(id, AddStateEventsAction{room.state.value().events});
	}

	// Process state events in timeline, which should have arrived later
	// than those in room.state .
	updateRoomImpl(id, AddStateEventsAction{
	intoImmer(EventList{},
	zug::filter([=](Event e) {
	return e.isState();
	}),
	timelineEvents)});

	if (room.accountData) {
	eventsToEmit.append(
	intoImmer(
	KazvEventList{},
	zug::map([=](Event e) -> KazvEvent {
	return ReceivingRoomAccountDataEvent{std::move(e), id};
	}),
	- room.state.value().events).transient());
	+ room.accountData.value().events).transient());
	updateRoomImpl(id, AddAccountDataAction{room.accountData.value().events});
	}
	};

	auto updateRoomSummary =
	[=](const auto &id, const auto &room) {
	if (!room.summary.has_value()) {
	return;
	}
	if (!room.summary->mHeroes.empty()) {
	auto newHeroes = room.summary->mHeroes;
	updateRoomImpl(id, SetHeroIdsAction{immer::flex_vector<std::string>(newHeroes.begin(), newHeroes.end())});
	}
	if (room.summary->mJoinedMemberCount.has_value()) {
	updateRoomImpl(id, UpdateJoinedMemberCountAction{static_cast<std::size_t>(room.summary->mJoinedMemberCount.value())});
	}
	if (room.summary->mInvitedMemberCount.has_value()) {
	updateRoomImpl(id, UpdateInvitedMemberCountAction{static_cast<std::size_t>(room.summary->mInvitedMemberCount.value())});
	}
	};

	auto updateRoomNotifications = [=, &l](const auto &id, const auto &room) {
	auto oldRoom = m.roomList.rooms[id];
	const auto &newRoom = l.rooms[id];
	updateRoomImpl(id, AddLocalNotificationsAction{
	room.timeline.events,
	pushRules,
	m.userId,
	});

	if (oldRoom.readReceipts[m.userId].eventId
	!= newRoom.readReceipts[m.userId].eventId) {
	updateRoomImpl(id, RemoveReadLocalNotificationsAction{m.userId});
	}
	};

	auto updateJoinedRoom =
	[=](const auto &id, const auto &room) {
	updateSingleRoom(id, room, RoomMembership::Join);
	if (room.ephemeral) {
	updateRoomImpl(id, AddEphemeralAction{room.ephemeral.value().events});
	}
	updateRoomNotifications(id, room);
	updateRoomSummary(id, room);
	};

	auto updateInvitedRoom =
	[=](const auto &id, const auto &room) {
	updateRoomImpl(id, ChangeMembershipAction{RoomMembership::Invite});
	if (room.inviteState) {
	updateRoomImpl(id, ChangeInviteStateAction{room.inviteState.value().events});
	}
	};

	auto updateLeftRoom =
	[=](const auto &id, const auto &room) {
	updateSingleRoom(id, room, RoomMembership::Leave);
	};

	for (const auto &[id, room]: rooms.join) {
	updateJoinedRoom(id, room);
	}

	// TODO update info for invited rooms
	for (const auto &[id, room]: rooms.invite) {
	updateInvitedRoom(id, room);
	}

	for (const auto &[id, room]: rooms.leave) {
	updateLeftRoom(id, room);
	}

	m.roomList = std::move(l);
	return eventsToEmit.persistent();
	}

	static KazvEventList loadPresenceFromSyncInPlace(ClientModel &m, EventList presence)
	{
	auto eventsToEmit = intoImmer(
	KazvEventList{},
	zug::map([](Event e) { return ReceivingPresenceEvent{e}; }),
	presence);
	m.presence = merge(std::move(m.presence), presence, keyOfPresence);
	return eventsToEmit;
	}

	static KazvEventList loadAccountDataFromSyncInPlace(ClientModel &m, EventList accountData)
	{
	auto eventsToEmit = intoImmer(
	KazvEventList{},
	zug::map([](Event e) { return ReceivingPresenceEvent{e}; }),
	accountData);
	m.accountData = merge(std::move(m.accountData), accountData, keyOfAccountData);
	return eventsToEmit;
	}

	static KazvEventList loadToDeviceFromSyncInPlace(ClientModel &m, JsonWrap toDevice)
	{
	if (toDevice.get().contains("events")) {
	auto events = toDevice.get()["events"];
	auto msgs = intoImmer(
	EventList{},
	zug::map([](const json &j) { return Event(j); }),
	events);

	m.toDevice = std::move(m.toDevice) + msgs;

	return intoImmer(
	KazvEventList{},
	zug::map([](Event e) { return ReceivingToDeviceMessage{e}; }),
	msgs);
	}
	return {};
	}

	ClientResult processResponse(ClientModel m, SyncResponse r)
	{
	if (! r.success()) {
	m.addTrigger(SyncFailed{});
	kzo.client.dbg() << "Sync failed" << std::endl;
	kzo.client.dbg() << r.statusCode << std::endl;
	if (isBodyJson(r.body)) {
	auto j = r.jsonBody();
	kzo.client.dbg() << "Json says: " << j.get().dump() << std::endl;
	} else {
	kzo.client.dbg() << "Response body: "
	<< std::get<BaseJob::BytesBody>(r.body) << std::endl;
	}
	return { std::move(m), failWithResponse(r) };
	}

	kzo.client.dbg() << "Sync successful" << std::endl;

	auto rooms = r.rooms();
	auto accountData = r.accountData();
	auto presence = r.presence();
	// load the info that has been sync'd

	m.syncToken = r.nextBatch();

	// Load account data first because it contains push rules
	// which can affect the processing of rooms
	if (accountData) {
	m.addTriggers(loadAccountDataFromSyncInPlace(m, std::move(accountData.value().events)));
	}

	if (rooms) {
	m.addTriggers(loadRoomsFromSyncInPlace(m, std::move(rooms.value())));
	}

	if (presence) {
	m.addTriggers(loadPresenceFromSyncInPlace(m, std::move(presence.value().events)));
	}

	m.addTriggers(loadToDeviceFromSyncInPlace(m, r.toDevice()));

	auto is = r.dataStr("is");
	auto isInitialSync = is == "initial";

	if (m.crypto) {
	kzo.client.dbg() << "E2EE is on. Processing device lists and one-time key counts." << std::endl;

	// process deviceLists
	if (isInitialSync) {
	auto encryptedUsers =
	zug::sequence(
	zug::map([](auto n) { return n.second; })
	\| zug::filter([](auto room) { return room.encrypted; })
	\| zug::map([](auto room) { return room.joinedMemberIds(); })
	\| zug::cat,
	// no need to use distinct here as the map will overwrite
	m.roomList.rooms);

	m.deviceLists.track(std::move(encryptedUsers));

	} else {
	auto l = r.deviceLists().get();
	if (l.contains("changed")) {
	const auto &changed = l.at("changed");
	m.deviceLists.track(changed);
	}

	if (l.contains("left")) {
	const auto &left = l.at("left");
	m.deviceLists.untrack(left);
	}
	}

	// deviceOneTimeKeysCount
	m.withCrypto([&](auto &c) { c.setUploadedOneTimeKeysCount(r.deviceOneTimeKeysCount()); });

	auto model = tryDecryptEvents(std::move(m));
	m = std::move(model);
	}

	m.addTrigger(SyncSuccessful{r.nextBatch()});

	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, SetShouldSyncAction a)
	{
	m.shouldSync = a.shouldSync;
	return { std::move(m), lager::noop };
	}

	ClientResult updateClient(ClientModel m, PostInitialFiltersAction)
	{
	if (m.syncing) {
	return { std::move(m), lager::noop };
	}

	Filter initialSyncFilter;
	initialSyncFilter.room.timeline.limit = 1;
	initialSyncFilter.room.state.lazyLoadMembers = true;
	auto firstJob = m.job<DefineFilterJob>()
	.make(m.userId, initialSyncFilter)
	.withData(json{{"is", "initialSyncFilter"}})
	.withQueue("post-filter", CancelFutureIfFailed);

	m.addJob(firstJob);
	Filter incrementalSyncFilter;
	incrementalSyncFilter.room.timeline.limit = 20;
	incrementalSyncFilter.room.state.lazyLoadMembers = true;
	m.addJob(m.job<DefineFilterJob>()
	.make(m.userId, incrementalSyncFilter)
	.withData(json{{"is", "incrementalSyncFilter"}})
	.withQueue("post-filter", CancelFutureIfFailed));

	m.syncing = true;

	return { std::move(m), lager::noop };
	}

	ClientResult processResponse(ClientModel m, DefineFilterResponse r)
	{
	auto is = r.dataStr("is");
	if (! r.success()) {
	m.syncing = false;
	kzo.client.dbg() << "posting filter failed: " << r.errorCode() << r.errorMessage() << std::endl;
	m.addTrigger(PostInitialFiltersFailed{r.errorCode(), r.errorMessage()});
	return { std::move(m), lager::noop };
	}

	kzo.client.dbg() << "filter " << is << " is posted" << std::endl;

	if (is == "incrementalSyncFilter") {
	m.incrementalSyncFilterId = r.filterId();
	m.addTrigger(PostInitialFiltersSuccessful{});
	} else {
	m.initialSyncFilterId = r.filterId();
	}

	return { std::move(m), lager::noop };
	}
	}
	diff --git a/src/tests/client/sync-test.cpp b/src/tests/client/sync-test.cpp
	index 13b7869..f03c982 100644
	--- a/src/tests/client/sync-test.cpp
	+++ b/src/tests/client/sync-test.cpp
	@@ -1,626 +1,654 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>


	#include <catch2/catch_all.hpp>

	#include <boost/asio.hpp>

	#include <zug/into_vector.hpp>

	#include <asio-promise-handler.hpp>
	#include <cursorutil.hpp>
	#include <sdk-model.hpp>
	#include <client/client.hpp>
	#include <client/actions/sync.hpp>
	#include "client-test-util.hpp"
	#include "factory.hpp"

	using namespace Kazv::Factory;

	// The example response is adapted from https://matrix.org/docs/spec/client_server/latest
	static json syncResponseJson = R"({
	"next_batch": "s72595_4483_1934",
	"presence": {
	"events": [
	{
	"content": {
	"avatar_url": "mxc://localhost:wefuiwegh8742w",
	"last_active_ago": 2478593,
	"presence": "online",
	"currently_active": false,
	"status_msg": "Making cupcakes"
	},
	"type": "m.presence",
	"sender": "@example:localhost"
	}
	]
	},
	"account_data": {
	"events": [
	{
	"type": "org.example.custom.config",
	"content": {
	"custom_config_key": "custom_config_value"
	}
	}
	]
	},
	"rooms": {
	"join": {
	"!726s6s6q:example.com": {
	"summary": {
	"m.heroes": [
	"@alice:example.com",
	"@bob:example.com"
	],
	"m.joined_member_count": 2,
	"m.invited_member_count": 1
	},
	"state": {
	"events": [
	{
	"content": {
	"membership": "join",
	"avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
	"displayname": "Alice Margatroid"
	},
	"type": "m.room.member",
	"event_id": "$143273582443PhrSn:example.org",
	"room_id": "!726s6s6q:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824653,
	"unsigned": {
	"age": 1234
	},
	"state_key": "@alice:example.org"
	}
	]
	},
	"timeline": {
	"events": [
	{
	"content": {
	"membership": "join",
	"avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
	"displayname": "Alice Margatroid"
	},
	"type": "m.room.member",
	"event_id": "$143273582443PhrSn:example.org",
	"room_id": "!726s6s6q:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824653,
	"unsigned": {
	"age": 1234
	},
	"state_key": "@alice:example.org"
	},
	{
	"content": {
	"body": "This is an example text message",
	"msgtype": "m.text",
	"format": "org.matrix.custom.html",
	"formatted_body": "<b>This is an example text message</b>"
	},
	"type": "m.room.message",
	"event_id": "$anothermessageevent:example.org",
	"room_id": "!726s6s6q:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824653,
	"unsigned": {
	"age": 1234
	}
	}
	],
	"limited": true,
	"prev_batch": "t34-23535_0_0"
	},
	"ephemeral": {
	"events": [
	{
	"content": {
	"user_ids": [
	"@alice:matrix.org",
	"@bob:example.com"
	]
	},
	"type": "m.typing",
	"room_id": "!jEsUZKDJdhlrceRyVU:example.org"
	}
	]
	},
	"account_data": {
	"events": [
	{
	"content": {
	"tags": {
	"u.work": {
	"order": 0.9
	}
	}
	},
	"type": "m.tag"
	},
	{
	"type": "org.example.custom.room.config",
	"content": {
	"custom_config_key": "custom_config_value"
	}
	},
	{
	"type": "m.fully_read",
	"content": {
	"event_id": "$anothermessageevent:example.org"
	}
	}
	]
	}
	}
	},
	"invite": {
	"!696r7674:example.com": {
	"invite_state": {
	"events": [
	{
	"sender": "@alice:example.com",
	"type": "m.room.name",
	"state_key": "",
	"content": {
	"name": "My Room Name"
	}
	},
	{
	"sender": "@alice:example.com",
	"type": "m.room.member",
	"state_key": "@bob:example.com",
	"content": {
	"membership": "invite"
	}
	}
	]
	}
	}
	},
	"leave": {}
	},
	"to_device": {
	"events": [
	{
	"sender": "@alice:example.com",
	"type": "m.new_device",
	"content": {
	"device_id": "XYZABCDE",
	"rooms": ["!726s6s6q:example.com"]
	}
	}
	]
	}
	})"_json;

	static json stateInTimelineResponseJson = R"({
	"next_batch": "some-example-value",
	"rooms": {
	"join": {
	"!exampleroomid:example.com": {
	"timeline": {
	"events": [
	{
	"content": { "example": "foo" },
	"state_key": "",
	"event_id": "$example:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824653,
	"unsigned": { "age": 1234 },
	"type": "moe.kazv.mxc.custom.state.type"
	}
	],
	"limited": false
	}
	}
	}
	}
	})"_json;

	static json txnIdResponseJson = R"({
	"next_batch": "some-example-value",
	"rooms": {
	"join": {
	"!exampleroomid:example.com": {
	"timeline": {
	"events": [
	{
	"content": { "example": "foo" },
	"event_id": "$example:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824653,
	"unsigned": { "age": 1234, "transaction_id": "some-example-txnid" },
	"type": "m.room.message"
	}
	],
	"limited": false
	}
	}
	}
	}
	})"_json;

	static auto addNotificationsJson = R"({
	"next_batch": "some-example-value",
	"account_data": {
	"events": [
	{
	"type": "m.push_rules",
	"content": {
	"global": {
	"override": [{
	"rule_id": "moe.kazv.mxc.catch_all",
	"default": true,
	"enabled": true,
	"conditions": [],
	"actions": ["notify"]
	}]
	}
	}
	}
	]
	},
	"rooms": {
	"join": {
	"!exampleroomid:example.com": {
	"timeline": {
	"events": [
	{
	"content": { "example": "foo" },
	"event_id": "$example:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824653,
	"type": "m.room.message"
	},
	{
	"content": { "example": "foo2" },
	"event_id": "$example2:example.com",
	"sender": "@example:example.org",
	"origin_server_ts": 1432735824953,
	"type": "m.room.message"
	}
	],
	"limited": false
	}
	}
	}
	}
	})"_json;

	static auto receiptJson = R"({
	"type": "m.receipt",
	"content": {
	"$example:example.com": {
	"m.read": {
	"@bob:example.com": {
	"ts": 1432735824653
	}
	}
	}
	}
	})"_json;

	static auto addAndRemoveNotificationsJson = [](auto a, auto r) {
	a["rooms"]["join"]["!exampleroomid:example.com"]["ephemeral"] = {
	{"events", {
	r,
	}}
	};
	return a;
	}(addNotificationsJson, receiptJson);

	static auto removeNotificationsJson = [](auto r) {
	auto j = R"({
	"next_batch": "some-example-value",
	"rooms": {
	"join": {
	"!exampleroomid:example.com": {
	"timeline": {
	"events": [],
	"limited": false
	}
	}
	}
	}
	})"_json;
	j["rooms"]["join"]["!exampleroomid:example.com"]["ephemeral"] = {
	{"events", {
	r,
	}}
	};
	return j;
	}(receiptJson);

	TEST_CASE("use sync response to update client model", "[client][sync]")
	{
	using namespace Kazv::CursorOp;

	boost::asio::io_context io;
	AsioPromiseHandler ph{io.get_executor()};

	auto store = createTestClientStore(ph);

	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(syncResponseJson)
	\| withResponseDataKV("is", "initial")
	);

	auto client = Client(store.reader().map([](auto c) { return SdkModel{c}; }), store,
	std::nullopt);

	store.dispatch(ProcessResponseAction{resp});

	io.run();

	auto rooms = +client.rooms();

	std::string roomId = "!726s6s6q:example.com";

	SECTION("rooms should be added") {
	REQUIRE(rooms.find(roomId));
	}

	auto r = client.room(roomId);

	SECTION("room members should be updated") {
	auto members = +r.members();

	auto hasAlice = zug::into_vector(
	zug::filter([](auto id) { return id == "@alice:example.org"; }),
	members)
	.size() > 0;

	REQUIRE(hasAlice);
	}

	SECTION("heroes should be updated") {
	auto heroIds = +r.heroIds();

	REQUIRE(heroIds == immer::flex_vector<std::string>{"@alice:example.com", "@bob:example.com"});
	}

	SECTION("joined and invited member counts should be updated") {
	REQUIRE(r.joinedMemberCount().get() == 2);
	REQUIRE(r.invitedMemberCount().get() == 1);
	}

	SECTION("ephemeral events should be updated") {
	auto users = +r.typingUsers();

	REQUIRE((users == immer::flex_vector<std::string>{
	"@alice:matrix.org",
	"@bob:example.com"
	}));
	}

	auto eventId = "$anothermessageevent:example.org"s;

	SECTION("timeline should be updated") {
	auto timeline = +r.timelineEvents();

	auto filtered = zug::into_vector(
	zug::filter([=](auto event) { return event.id() == eventId; }),
	timeline);

	auto hasEvent = filtered.size() > 0;
	REQUIRE(hasEvent);

	auto onlyOneEvent = filtered.size() == 1;
	REQUIRE(onlyOneEvent);

	auto ev = filtered[0];

	auto eventHasRoomId = ev.originalJson().get().contains("room_id"s);
	REQUIRE(eventHasRoomId);

	auto gaps = +r.timelineGaps();
	// first event in the batch, correspond to its prevBatch
	REQUIRE(gaps.at("$143273582443PhrSn:example.org") == "t34-23535_0_0");
	}

	SECTION("fully read marker should be updated") {
	auto readMarker = +r.readMarker();

	REQUIRE(readMarker == eventId);
	}

	SECTION("toDevice should be updated") {
	auto toDevice = +client.toDevice();

	REQUIRE(toDevice.size() == 1);
	REQUIRE(toDevice[0].sender() == "@alice:example.com");
	}
	+
	+ SECTION("emits account data changes") {
	+ auto nextTriggers = store.reader().get().nextTriggers;
	+ auto triggerContains = [=](auto p) {
	+ return std::any_of(
	+ nextTriggers.begin(),
	+ nextTriggers.end(),
	+ [=](const KazvEvent &t) {
	+ if (!std::holds_alternative<ReceivingRoomAccountDataEvent>(t)) {
	+ return false;
	+ }
	+ auto e = std::get<ReceivingRoomAccountDataEvent>(t);
	+ return p(e);
	+ });
	+ };
	+
	+ REQUIRE(triggerContains([](const auto &e) {
	+ return e.event.type() == "m.tag" && e.roomId == "!726s6s6q:example.com";
	+ }));
	+
	+ REQUIRE(triggerContains([](const auto &e) {
	+ return e.event.type() == "m.fully_read" && e.roomId == "!726s6s6q:example.com";
	+ }));
	+
	+ REQUIRE(triggerContains([](const auto &e) {
	+ return e.event.type() == "org.example.custom.room.config" && e.roomId == "!726s6s6q:example.com";
	+ }));
	+ }
	}

	TEST_CASE("Sync should record state events in timeline", "[client][sync]")
	{
	using namespace Kazv::CursorOp;

	boost::asio::io_context io;
	AsioPromiseHandler ph{io.get_executor()};

	auto store = createTestClientStore(ph);

	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(stateInTimelineResponseJson)
	\| withResponseDataKV("is", "initial")
	);

	auto client = Client(store.reader().map([](auto c) { return SdkModel{c}; }), store,
	std::nullopt);

	store.dispatch(ProcessResponseAction{resp});

	io.run();

	auto r = client.room("!exampleroomid:example.com");

	auto stateOpt = +r.stateOpt(KeyOfState{"moe.kazv.mxc.custom.state.type", ""});

	REQUIRE(stateOpt.has_value());
	REQUIRE(stateOpt.value().content().get().at("example") == "foo");
	}

	TEST_CASE("Sync should remove already sent local echo", "[client][sync]")
	{
	using namespace Kazv::CursorOp;

	boost::asio::io_context io;
	AsioPromiseHandler ph{io.get_executor()};

	ClientModel m = makeClient(
	withRoom(makeRoom(
	withRoomId("!exampleroomid:example.com")
	\| withAttr(&RoomModel::localEchoes, {
	{"some-example-txnid", json{
	{"type", "m.room.message"},
	{"content", {{"example", "foo"}}}
	}},
	{"some-other-txnid", json{
	{"type", "m.room.message"},
	{"content", {{"example", "foo"}}}
	}},
	})
	))
	);

	auto store = createTestClientStoreFrom(m, ph);

	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(txnIdResponseJson)
	\| withResponseDataKV("is", "initial")
	);

	auto client = Client(store.reader().map([](auto c) { return SdkModel{c}; }), store,
	std::nullopt);

	store.dispatch(ProcessResponseAction{resp});

	io.run();

	auto r = client.room("!exampleroomid:example.com");

	auto localEchoes = +r.localEchoes();
	REQUIRE(localEchoes.size() == 1);
	REQUIRE(localEchoes[0].txnId == "some-other-txnid");
	}

	TEST_CASE("updating local notifications", "[client][sync]")
	{
	ClientModel m = makeClient(
	withRoom(makeRoom(
	withRoomId("!exampleroomid:example.com"))));

	WHEN("the receipt for the current user did not change") {
	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(addNotificationsJson)
	\| withResponseDataKV("is", "incremental")
	);
	auto [next, _] = processResponse(m, SyncResponse{resp});

	auto room = next.roomList.rooms.at("!exampleroomid:example.com");
	REQUIRE(room.unreadNotificationEventIds
	== immer::flex_vector<std::string>{
	"$example:example.com",
	"$example2:example.com"
	});

	THEN("it changed later") {
	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(removeNotificationsJson)
	\| withResponseDataKV("is", "incremental")
	);
	auto [nextNext, _] = processResponse(next, SyncResponse{resp});

	auto room = nextNext.roomList.rooms.at("!exampleroomid:example.com");
	REQUIRE(room.unreadNotificationEventIds
	== immer::flex_vector<std::string>{
	"$example2:example.com"
	});
	}
	}

	WHEN("the receipt for the current user changed") {
	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(addAndRemoveNotificationsJson)
	\| withResponseDataKV("is", "incremental")
	);
	auto [next, _] = processResponse(m, SyncResponse{resp});

	auto room = next.roomList.rooms.at("!exampleroomid:example.com");
	REQUIRE(room.unreadNotificationEventIds
	== immer::flex_vector<std::string>{
	"$example2:example.com"
	});
	}
	}

	TEST_CASE("it does not add a gap when the limited field in the timeline is not present (conduwuit)", "[client][sync]")
	{
	auto body = R"({
	"device_one_time_keys_count": {
	"signed_curve25519": 721
	},
	"device_unused_fallback_key_types": null,
	"next_batch": "some",
	"rooms": {
	"join": {
	"!foo:example.com": {
	"ephemeral": {
	"events": []
	},
	"timeline": {
	"events": [
	{
	"content": {
	},
	"event_id": "$1",
	"origin_server_ts": 1723379000000,
	"sender": "@foo:example.com",
	"type": "m.room.message",
	"unsigned": {
	"age": 1,
	"transaction_id": "xxxxxx"
	}
	}
	],
	"prev_batch": "prev-batch"
	},
	"unread_notifications": {
	"highlight_count": 0,
	"notification_count": 0
	}
	}
	}
	}
	})"_json;
	auto resp = makeResponse(
	"Sync",
	withResponseJsonBody(body)
	\| withResponseDataKV("is", "incremental")
	);

	ClientModel m = makeClient(
	withRoom(makeRoom(
	withRoomId("!foo:example.com"))));

	auto [next, _] = processResponse(m, SyncResponse{resp});
	auto room = next.roomList.rooms.at("!foo:example.com");
	REQUIRE(room.timelineGaps.size() == 0);
	REQUIRE(room.messages.count("$1") != 0);
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 1:17 AM (17 h, 8 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768590
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions