room-test.cpp
No OneTemporary
Actions

Size

9 KB

Referenced Files

None

Subscribers

None

room-test.cpp
View Options

	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>

	#include <catch2/catch_all.hpp>

	#include <lager/event_loop/boost_asio.hpp>
	#include <boost/asio.hpp>

	#include <sdk.hpp>
	#include <cprjobhandler.hpp>
	#include <lagerstoreeventemitter.hpp>
	#include <asio-promise-handler.hpp>

	#include "client-test-util.hpp"

	using namespace Kazv;

	TEST_CASE("Result of Room::toEventLoop() should not vary with the original cursor", "[client][room]")
	{
	auto io = boost::asio::io_context{};
	auto jh = Kazv::CprJobHandler{io.get_executor()};
	auto ee = Kazv::LagerStoreEventEmitter(lager::with_boost_asio_event_loop{io.get_executor()});

	auto roomWithId = [](std::string roomId) {
	auto r = RoomModel{};
	r.roomId = roomId;
	return r;
	};

	auto initModel = Kazv::SdkModel{};
	initModel.client.roomList.rooms = std::move(initModel.client.roomList.rooms)
	.set("!foo:example.org", roomWithId("!foo:example.org"))
	.set("!bar:example.org", roomWithId("!bar:example.org"));
	auto sdk = Kazv::makeSdk(
	initModel,
	jh,
	ee,
	Kazv::AsioPromiseHandler{io.get_executor()},
	zug::identity
	);

	auto ctx = sdk.context();

	auto client = sdk.client();

	auto roomId = lager::make_state(std::string("!foo:example.org"), lager::automatic_tag{});

	auto room = client.roomByCursor(roomId);

	using namespace Kazv::CursorOp;

	REQUIRE(+room.roomId() == "!foo:example.org");

	auto roomInEventLoop = room.toEventLoop();

	REQUIRE(+roomInEventLoop.roomId() == "!foo:example.org");

	roomId.set("!bar:example.org");

	REQUIRE(+room.roomId() == "!bar:example.org");
	REQUIRE(+roomInEventLoop.roomId() == "!foo:example.org");
	}

	static const std::string exampleRoomId = "!example:example.org";

	static auto exampleRoomWithoutNameEvent()
	{
	RoomModel model;
	model.roomId = "!example:example.org";
	model.stateEvents = model.stateEvents
	.set(
	{"m.room.member", "@foo:example.org"},
	Event(R"(
	{
	"content": {
	"displayname": "foo's name",
	"membership": "join"
	},
	"event_id": "some id2",
	"room_id": "!example:example.org",
	"type": "m.room.member",
	"state_key": "@foo:example.org"
	})"_json))
	.set(
	{"m.room.member", "@bar:example.org"},
	Event(R"(
	{
	"content": {
	"displayname": "bar's name",
	"membership": "join"
	},
	"event_id": "some id3",
	"room_id": "!example:example.org",
	"type": "m.room.member",
	"state_key": "@bar:example.org"
	})"_json));
	model.heroIds = {"@foo:example.org", "@bar:example.org"};
	return model;
	}

	static auto roomNameEvent = Event(R"(
	{
	"content": {
	"name": "some name"
	},
	"event_id": "some id",
	"room_id": "!example:example.org",
	"type": "m.room.name",
	"state_key": ""
	})"_json);

	static auto exampleRoomWithNameEvent()
	{
	auto model = exampleRoomWithoutNameEvent();
	model.stateEvents = model.stateEvents
	.set({"m.room.name", ""}, roomNameEvent);
	return model;
	};

	static auto sdkWith(RoomModel room)
	{
	SdkModel model;
	model.client.roomList.rooms = model.client.roomList.rooms.set(room.roomId, room);
	return model;
	}

	static auto makeRoomWithDumbContext(RoomModel room)
	{
	auto cursor = lager::make_constant(sdkWith(room));
	auto nameCursor = lager::make_constant(room.roomId);
	return Room(cursor, nameCursor, dumbContext());
	}

	TEST_CASE("Room::nameOpt()", "[client][room][getter]")
	{
	WHEN("the room has a name") {
	auto room = makeRoomWithDumbContext(exampleRoomWithNameEvent());
	THEN("it should give out the name") {
	auto val = room.nameOpt().make().get();
	REQUIRE(val.has_value());
	REQUIRE(val.value() == "some name");
	}
	}

	WHEN("the room has no name") {
	auto room = makeRoomWithDumbContext(exampleRoomWithoutNameEvent());
	THEN("it should give out nullopt") {
	auto val = room.nameOpt().make().get();
	REQUIRE(!val.has_value());
	}
	}
	}

	TEST_CASE("Room::heroMemberEvents()", "[client][room][getter]")
	{
	auto room = makeRoomWithDumbContext(exampleRoomWithNameEvent());
	THEN("it should give out the events") {
	auto val = room.heroMemberEvents().make().get();
	REQUIRE(val.size() == 2);
	REQUIRE(std::any_of(val.begin(), val.end(),
	[](const auto &v) {
	return v.id() == "some id2";
	}));
	REQUIRE(std::any_of(val.begin(), val.end(),
	[](const auto &v) {
	return v.id() == "some id3";
	}));
	}
	}

	TEST_CASE("Room::heroDisplayNames()", "[client][room][getter]")
	{
	auto room = makeRoomWithDumbContext(exampleRoomWithNameEvent());
	THEN("it should give out the names") {
	auto val = room.heroDisplayNames().make().get();
	REQUIRE(val.size() == 2);
	REQUIRE(std::any_of(val.begin(), val.end(),
	[](const auto &v) {
	return v == "foo's name";
	}));
	REQUIRE(std::any_of(val.begin(), val.end(),
	[](const auto &v) {
	return v == "bar's name";
	}));
	}
	}

	TEST_CASE("Room::encrypted()", "[client][room][getter]")
	{
	auto roomModel = exampleRoomWithNameEvent();
	WHEN("the room is encrypted") {
	roomModel.encrypted = true;
	auto room = makeRoomWithDumbContext(roomModel);
	THEN("it should give out true") {
	auto val = room.encrypted().make().get();
	REQUIRE(val);
	}
	}

	WHEN("the room is not encrypted") {
	roomModel.encrypted = false;
	auto room = makeRoomWithDumbContext(roomModel);
	THEN("it should give out false") {
	auto val = room.encrypted().make().get();
	REQUIRE(!val);
	}
	}
	}

	TEST_CASE("Room::avatarMxcUri()", "[client][room][getter]")
	{
	// https://spec.matrix.org/v1.7/client-server-api/#mroomavatar
	Event avatarEvent = R"({
	"content": {
	"info": {
	"h": 398,
	"mimetype": "image/jpeg",
	"size": 31037,
	"w": 394
	},
	"url": "mxc://example.org/JWEIFJgwEIhweiWJE"
	},
	"event_id": "$143273582443PhrSn:example.org",
	"origin_server_ts": 1432735824653,
	"room_id": "!jEsUZKDJdhlrceRyVU:example.org",
	"sender": "@example:example.org",
	"state_key": "",
	"type": "m.room.avatar",
	"unsigned": {
	"age": 1234
	}
	})"_json;

	auto roomModel = exampleRoomWithoutNameEvent();
	roomModel.stateEvents = roomModel.stateEvents.set(KeyOfState{"m.room.avatar", ""}, avatarEvent);

	auto room = makeRoomWithDumbContext(roomModel);
	REQUIRE(room.avatarMxcUri().make().get() == "mxc://example.org/JWEIFJgwEIhweiWJE");
	}

	TEST_CASE("Room::typingMemberEvents()", "[client][room][getter][ephemeral]")
	{
	auto roomModel = exampleRoomWithoutNameEvent();
	auto typingJson = R"({
	"content": {
	"user_ids": ["@foo:example.org", "@bar:example.org"]
	},
	"type": "m.typing"
	})"_json;
	roomModel.ephemeral = roomModel.ephemeral.set("m.typing", Event{typingJson});

	auto room = makeRoomWithDumbContext(roomModel);
	REQUIRE(room.typingMemberEvents().make().get() == EventList{
	room.memberEventFor("@foo:example.org").make().get(),
	room.memberEventFor("@bar:example.org").make().get(),
	});
	}

	TEST_CASE("Room::message()", "[client][room][getter][timeline]")
	{
	auto roomModel = exampleRoomWithoutNameEvent();
	auto messageEvent = Event(R"({
	"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
	}
	})"_json);
	roomModel.messages = roomModel.messages.set(messageEvent.id(), messageEvent);

	auto room = makeRoomWithDumbContext(roomModel);
	REQUIRE(room.message(lager::make_constant(messageEvent.id())).make().get() == messageEvent);
	}

	TEST_CASE("Room::name(), Room::nameOpt()", "[client][room][getter][state]")
	{
	auto roomModel = exampleRoomWithoutNameEvent();
	WHEN("membership is invite and invite state contains name event")
	{
	roomModel.membership = RoomMembership::Invite;
	roomModel.inviteState = roomModel.inviteState.set({"m.room.name", ""}, roomNameEvent);
	auto room = makeRoomWithDumbContext(roomModel);
	THEN("it should give that name")
	{
	auto expectedName = roomNameEvent.content().get()["name"].template get<std::string>();
	REQUIRE(room.nameOpt().make().get().value() == expectedName);
	REQUIRE(room.name().make().get() == expectedName);
	}
	}

	WHEN("membership is not invite and invite state contains the name event")
	{
	roomModel.membership = RoomMembership::Join;
	roomModel.inviteState = roomModel.inviteState.set({"m.room.name", ""}, roomNameEvent);
	auto room = makeRoomWithDumbContext(roomModel);
	THEN("it should ignore that name")
	{
	REQUIRE(!room.nameOpt().make().get().has_value());
	REQUIRE(room.name().make().get() == "<no name>");
	}
	}
	}

File Metadata

Mime Type: text/x-c
Expires: Thu, Oct 2, 2:41 AM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 486981
Default Alt Text: room-test.cpp (9 KB)

room-test.cppNo OneTemporaryActions

room-test.cppView Options

File Metadata

Event Timeline

room-test.cpp
No OneTemporary
Actions

room-test.cpp
View Options