events.cpp

#include <gtest/gtest.h>

#include <mtx.hpp>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

namespace ns = mtx::events;

TEST(Events, Redaction)
{
    json data = R"({
	  "unsigned": {
            "age": 146
	  },
          "content": {
              "reason": "No reason"
          },
          "event_id": "$143273582443PhrSn:localhost",
          "origin_server_ts": 1432735824653,
          "room_id": "!jEsUZKDJdhlrceRyVU:localhost",
          "redacts": "$1521361675759563UDexf:matrix.org",
          "sender": "@example:localhost",
          "type": "m.room.redaction"
        })"_json;

    ns::RedactionEvent<ns::msg::Redaction> event =
      data.get<ns::RedactionEvent<ns::msg::Redaction>>();

    EXPECT_EQ(event.type, ns::EventType::RoomRedaction);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:localhost");
    EXPECT_EQ(event.room_id, "!jEsUZKDJdhlrceRyVU:localhost");
    EXPECT_EQ(event.sender, "@example:localhost");
    EXPECT_EQ(event.origin_server_ts, 1432735824653L);
    EXPECT_EQ(event.unsigned_data.age, 146);
    EXPECT_EQ(event.redacts, "$1521361675759563UDexf:matrix.org");

    EXPECT_EQ(event.content.reason, "No reason");
}

TEST(Events, Redacted)
{
    json data = R"({
	  "unsigned": {
            "age": 146
	  },
          "content": {
          },
          "event_id": "$143273582443PhrSn:localhost",
          "origin_server_ts": 1432735824653,
          "room_id": "!jEsUZKDJdhlrceRyVU:localhost",
          "redacts": "$1521361675759563UDexf:matrix.org",
          "sender": "@example:localhost",
          "type": "m.room.redaction"
        })"_json;

    mtx::events::collections::TimelineEvent event =
      data.get<mtx::events::collections::TimelineEvent>();

    ASSERT_TRUE(std::holds_alternative<ns::RedactionEvent<ns::msg::Redaction>>(event.data));

    json data2 = R"({
		"content": {
			"membership": "join"
		},
		"origin_server_ts": 1595256121167,
		"sender": "@redacted_user_1:example.com",
		"state_key": "@redacted_user_1:example.com",
		"type": "m.room.member",
		"unsigned": {
			"redacted_by": "$redacted_id_1",
			"redacted_because": {
				"content": {},
				"origin_server_ts": 1595261803914,
				"redacts": "$redacted_id_2",
				"sender": "@redacted_user_2:example.com",
				"type": "m.room.redaction",
				"unsigned": {
					"age": 23764322
				},
				"event_id": "$redacted_id_1"
			}
		},
		"event_id": "$redacted_id_2"
	})"_json;

    event = data2.get<mtx::events::collections::TimelineEvent>();
    ASSERT_TRUE(std::holds_alternative<ns::StateEvent<ns::msg::Redacted>>(event.data));
    ASSERT_TRUE(std::get<ns::StateEvent<ns::msg::Redacted>>(event.data)
                  .unsigned_data.redacted_because.has_value());
    ASSERT_EQ(std::get<ns::StateEvent<ns::msg::Redacted>>(event.data)
                .unsigned_data.redacted_because->sender,
              "@redacted_user_2:example.com");
}

TEST(Events, Conversions)
{
    EXPECT_EQ("m.room.aliases", ns::to_string(ns::EventType::RoomAliases));
    EXPECT_EQ("m.room.avatar", ns::to_string(ns::EventType::RoomAvatar));
    EXPECT_EQ("m.room.canonical_alias", ns::to_string(ns::EventType::RoomCanonicalAlias));
    EXPECT_EQ("m.room.create", ns::to_string(ns::EventType::RoomCreate));
    EXPECT_EQ("m.room.guest_access", ns::to_string(ns::EventType::RoomGuestAccess));
    EXPECT_EQ("m.room.history_visibility", ns::to_string(ns::EventType::RoomHistoryVisibility));
    EXPECT_EQ("m.room.join_rules", ns::to_string(ns::EventType::RoomJoinRules));
    EXPECT_EQ("m.room.member", ns::to_string(ns::EventType::RoomMember));
    EXPECT_EQ("m.room.message", ns::to_string(ns::EventType::RoomMessage));
    EXPECT_EQ("m.room.name", ns::to_string(ns::EventType::RoomName));
    EXPECT_EQ("m.room.power_levels", ns::to_string(ns::EventType::RoomPowerLevels));
    EXPECT_EQ("m.room.topic", ns::to_string(ns::EventType::RoomTopic));
    EXPECT_EQ("m.room.tombstone", ns::to_string(ns::EventType::RoomTombstone));
    EXPECT_EQ("m.room.redaction", ns::to_string(ns::EventType::RoomRedaction));
    EXPECT_EQ("m.room.pinned_events", ns::to_string(ns::EventType::RoomPinnedEvents));
    EXPECT_EQ("m.policy.rule.user", ns::to_string(ns::EventType::PolicyRuleUser));
    EXPECT_EQ("m.policy.rule.room", ns::to_string(ns::EventType::PolicyRuleRoom));
    EXPECT_EQ("m.policy.rule.server", ns::to_string(ns::EventType::PolicyRuleServer));
    EXPECT_EQ("m.space.child", ns::to_string(ns::EventType::SpaceChild));
    EXPECT_EQ("m.space.parent", ns::to_string(ns::EventType::SpaceParent));
    EXPECT_EQ("m.tag", ns::to_string(ns::EventType::Tag));
}

TEST(StateEvents, Aliases)
{
    json data = R"({
	  "unsigned": {
	    "age": 242352,
	    "transaction_id": "txnid"
	  },
	  "content": {
	    "aliases": [
	      "#somewhere:localhost",
	      "#another:localhost"
	    ]
	  },
	  "event_id": "$WLGTSEFSEF:localhost",
	  "origin_server_ts": 1431961217939,
          "room_id": "!Cuyf34gef24t:localhost",
	  "sender": "@example:localhost",
	  "state_key": "localhost",
	  "type": "m.room.aliases"
	})"_json;

    ns::StateEvent<ns::state::Aliases> aliases = data.get<ns::StateEvent<ns::state::Aliases>>();

    EXPECT_EQ(aliases.type, ns::EventType::RoomAliases);
    EXPECT_EQ(aliases.event_id, "$WLGTSEFSEF:localhost");
    EXPECT_EQ(aliases.room_id, "!Cuyf34gef24t:localhost");
    EXPECT_EQ(aliases.sender, "@example:localhost");
    EXPECT_EQ(aliases.unsigned_data.age, 242352);
    EXPECT_EQ(aliases.unsigned_data.transaction_id, "txnid");
    EXPECT_EQ(aliases.origin_server_ts, 1431961217939L);
    EXPECT_EQ(aliases.state_key, "localhost");
    EXPECT_EQ(aliases.content.aliases.size(), 2);
    EXPECT_EQ(aliases.content.aliases[0], "#somewhere:localhost");
    EXPECT_EQ(aliases.content.aliases[1], "#another:localhost");
}

TEST(StateEvents, Avatar)
{
    json data = R"({
          "origin_server_ts": 1506762071625,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067620711415511reUFC:matrix.org",
          "age": 3717700323,
          "unsigned": {
            "age": 3717700323
          },
          "state_key": "",
          "content": {
            "url": "mxc://matrix.org/EPKcIsAPzREMrvZIjrIuJnEl"
          },
          "room_id": "!VaMCVKSVcyPtXbcMXh:matrix.org",
          "user_id": "@mujx:matrix.org",
          "type": "m.room.avatar"
        })"_json;

    ns::StateEvent<ns::state::Avatar> event = data.get<ns::StateEvent<ns::state::Avatar>>();

    EXPECT_EQ(event.type, ns::EventType::RoomAvatar);
    EXPECT_EQ(event.event_id, "$15067620711415511reUFC:matrix.org");
    EXPECT_EQ(event.room_id, "!VaMCVKSVcyPtXbcMXh:matrix.org");
    EXPECT_EQ(event.sender, "@mujx:matrix.org");
    EXPECT_EQ(event.unsigned_data.age, 3717700323);
    EXPECT_EQ(event.origin_server_ts, 1506762071625L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.url, "mxc://matrix.org/EPKcIsAPzREMrvZIjrIuJnEl");
}

TEST(StateEvents, CanonicalAlias)
{
    json data = R"({
    "content": {
        "alias": "#somewhere:localhost",
        "alt_aliases": [
            "#somewhere:example.org",
            "#myroom:example.com"
        ]
    },
    "event_id": "$143273582443PhrSn:example.org",
    "origin_server_ts": 1432735824653,
    "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
    "sender": "@example:example.org",
    "state_key": "",
    "type": "m.room.canonical_alias",
    "unsigned": {
        "age": 1234
    }
})"_json;

    ns::StateEvent<ns::state::CanonicalAlias> event =
      data.get<ns::StateEvent<ns::state::CanonicalAlias>>();

    EXPECT_EQ(event.type, ns::EventType::RoomCanonicalAlias);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:example.org");
    EXPECT_EQ(event.room_id, "!jEsUZKDJdhlrceRyVU:example.org");
    EXPECT_EQ(event.sender, "@example:example.org");
    EXPECT_EQ(event.unsigned_data.age, 1234);
    EXPECT_EQ(event.origin_server_ts, 1432735824653L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.alias, "#somewhere:localhost");
    ASSERT_EQ(event.content.alt_aliases.size(), 2);
    EXPECT_EQ(event.content.alt_aliases.at(0), "#somewhere:example.org");
    EXPECT_EQ(event.content.alt_aliases.at(1), "#myroom:example.com");
}

TEST(StateEvents, Create)
{
    json data = R"({
          "origin_server_ts": 1506761923948,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619231414398jhvQC:matrix.org",
          "unsigned": {
            "age": 3715756343
          },
          "state_key": "",
          "content": {
            "creator": "@mujx:matrix.org"
          },
          "type": "m.room.create"
        })"_json;

    ns::StateEvent<ns::state::Create> event = data.get<ns::StateEvent<ns::state::Create>>();

    EXPECT_EQ(event.type, ns::EventType::RoomCreate);
    EXPECT_EQ(event.event_id, "$15067619231414398jhvQC:matrix.org");
    EXPECT_EQ(event.sender, "@mujx:matrix.org");
    EXPECT_EQ(event.unsigned_data.age, 3715756343L);
    EXPECT_EQ(event.origin_server_ts, 1506761923948L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.creator, "@mujx:matrix.org");

    json example_from_spec = R"({
            "content": {
                "creator": "@example:example.org",
                "m.federate": true,
                "predecessor": {
                    "event_id": "$something:example.org",
                    "room_id": "!oldroom:example.org"
                },
                "room_version": "1"
            },
            "event_id": "$143273582443PhrSn:example.org",
            "origin_server_ts": 1432735824653,
            "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
            "sender": "@example:example.org",
            "state_key": "",
            "type": "m.room.create",
            "unsigned": {
                "age": 1234
            }
        })"_json;

    event = example_from_spec.get<ns::StateEvent<ns::state::Create>>();

    EXPECT_EQ(event.type, ns::EventType::RoomCreate);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:example.org");
    EXPECT_EQ(event.sender, "@example:example.org");
    EXPECT_EQ(event.unsigned_data.age, 1234);
    EXPECT_EQ(event.origin_server_ts, 1432735824653L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.creator, "@example:example.org");
    EXPECT_EQ(event.content.federate, true);
    EXPECT_EQ(event.content.room_version, "1");
    EXPECT_EQ(event.content.predecessor->room_id, "!oldroom:example.org");
    EXPECT_EQ(event.content.predecessor->event_id, "$something:example.org");
}

TEST(StateEvents, CreateWithType)
{
    json data = R"({
          "origin_server_ts": 1506761923948,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619231414398jhvQC:matrix.org",
          "unsigned": {
            "age": 3715756343
          },
          "state_key": "",
          "content": {
            "creator": "@mujx:matrix.org",
            "type": "m.space"
          },
          "type": "m.room.create"
        })"_json;

    ns::StateEvent<ns::state::Create> event = data.get<ns::StateEvent<ns::state::Create>>();

    EXPECT_EQ(event.type, ns::EventType::RoomCreate);
    EXPECT_EQ(event.event_id, "$15067619231414398jhvQC:matrix.org");
    EXPECT_EQ(event.sender, "@mujx:matrix.org");
    EXPECT_EQ(event.unsigned_data.age, 3715756343L);
    EXPECT_EQ(event.origin_server_ts, 1506761923948L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.creator, "@mujx:matrix.org");
    EXPECT_TRUE(event.content.type.has_value());
    EXPECT_EQ(event.content.type.value(), ns::state::room_type::space);

    json example_from_spec = R"({
  "content": {
    "creator": "@deepbluev7:neko.dev",
    "room_version": "6",
    "type": "m.space"
  },
  "origin_server_ts": 1623788764437,
  "sender": "@deepbluev7:neko.dev",
  "state_key": "",
  "type": "m.room.create",
  "unsigned": {
    "age": 2241800
  },
  "event_id": "$VXf-Ze1j8D3KQ95b66sB7cNp1LzCqOHOJ8nk2iHtZvE",
  "room_id": "!KLPDfgYGHhdZWLbUwD:neko.dev"
})"_json;

    event = example_from_spec.get<ns::StateEvent<ns::state::Create>>();

    EXPECT_TRUE(event.content.type.has_value());
    EXPECT_EQ(event.content.type.value(), ns::state::room_type::space);

    json room_v10 = R"(
{
  "content": {
    "creator": "@test:neko.dev",
    "predecessor": {
      "event_id": "$hpB30pm_PDHq9dcz7zJR6gwnEFRPxzea7J8bxVuuSTg",
      "room_id": "!isYaZDvAOnwGmoNKgD:neko.dev"
    },
    "room_version": "10"
  },
  "origin_server_ts": 1670903493618,
  "sender": "@test:neko.dev",
  "state_key": "",
  "type": "m.room.create",
  "unsigned": {
    "age": 118
  },
  "event_id": "$2NH68IAcuHuAwsy1WEyLqAnOH_iAVjyUu2GP5IksnYc",
  "room_id": "!FhwxBVrewHNqikGaXN:neko.dev"
}
    )"_json;

    event = room_v10.get<ns::StateEvent<ns::state::Create>>();

    EXPECT_EQ(event.content.room_version, "10");
}

TEST(StateEvents, GuestAccess)
{
    json data = R"({
          "origin_server_ts": 1506761923948,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619231414398jhvQC:matrix.org",
          "unsigned": {
            "age": 3715756343
          },
          "state_key": "",
          "content": {
            "guest_access": "can_join"
          },
          "type": "m.room.guest_access"
        })"_json;

    ns::StateEvent<ns::state::GuestAccess> event =
      data.get<ns::StateEvent<ns::state::GuestAccess>>();

    EXPECT_EQ(event.type, ns::EventType::RoomGuestAccess);
    EXPECT_EQ(event.event_id, "$15067619231414398jhvQC:matrix.org");
    EXPECT_EQ(event.sender, "@mujx:matrix.org");
    EXPECT_EQ(event.unsigned_data.age, 3715756343L);
    EXPECT_EQ(event.origin_server_ts, 1506761923948L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.guest_access, mtx::events::state::AccessState::CanJoin);
}

TEST(StateEvents, HistoryVisibility)
{
    json data = R"({
	  "origin_server_ts": 1510473133072,
	  "sender": "@nheko_test:matrix.org",
	  "event_id": "$15104731332646268uOFJp:matrix.org",
	  "unsigned": {
	    "age": 140
	  },
	  "state_key": "",
  	  "content": {
	    "history_visibility": "shared"
	  },
	  "type": "m.room.history_visibility",
	  "room_id": "!lfoDRlNFWlvOnvkBwQ:matrix.org"
	})"_json;

    ns::StateEvent<ns::state::HistoryVisibility> event =
      data.get<ns::StateEvent<ns::state::HistoryVisibility>>();

    EXPECT_EQ(event.type, ns::EventType::RoomHistoryVisibility);
    EXPECT_EQ(event.event_id, "$15104731332646268uOFJp:matrix.org");
    EXPECT_EQ(event.room_id, "!lfoDRlNFWlvOnvkBwQ:matrix.org");
    EXPECT_EQ(event.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1510473133072L);
    EXPECT_EQ(event.unsigned_data.age, 140);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.history_visibility, ns::state::Visibility::Shared);

    json data2 = R"({
          "origin_server_ts": 1510476778190,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15104767782674661tXoeB:matrix.org",
          "unsigned": {
            "prev_content": {
              "history_visibility": "shared"
            },
            "prev_sender": "@nheko_test:matrix.org",
            "replaces_state": "$15104731332646268uOFJp:matrix.org",
            "age": 48
          },
          "state_key": "",
          "content": {
            "history_visibility": "invited"
          },
          "type": "m.room.history_visibility",
          "room_id": "!lfoDRlNFWlvOnvkBwQ:matrix.org"
        })"_json;

    ns::StateEvent<ns::state::HistoryVisibility> event2 =
      data2.get<ns::StateEvent<ns::state::HistoryVisibility>>();

    EXPECT_EQ(event2.type, ns::EventType::RoomHistoryVisibility);
    EXPECT_EQ(event2.event_id, "$15104767782674661tXoeB:matrix.org");
    EXPECT_EQ(event2.room_id, "!lfoDRlNFWlvOnvkBwQ:matrix.org");
    EXPECT_EQ(event2.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event2.origin_server_ts, 1510476778190L);
    EXPECT_EQ(event2.unsigned_data.age, 48);
    EXPECT_EQ(event2.unsigned_data.replaces_state, "$15104731332646268uOFJp:matrix.org");
    EXPECT_EQ(event2.state_key, "");
    EXPECT_EQ(event2.content.history_visibility, ns::state::Visibility::Invited);
}

TEST(StateEvents, JoinRules)
{
    json data = R"({
          "origin_server_ts": 1506761924018,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619241414401ASocy:matrix.org",
          "unsigned": {
            "age": 3715756273
	  },
          "state_key": "",
          "content": {
            "join_rule": "invite"
	  },
          "type": "m.room.join_rules"
        })"_json;

    ns::StateEvent<ns::state::JoinRules> event = data.get<ns::StateEvent<ns::state::JoinRules>>();

    EXPECT_EQ(event.type, ns::EventType::RoomJoinRules);
    EXPECT_EQ(event.event_id, "$15067619241414401ASocy:matrix.org");
    EXPECT_EQ(event.sender, "@mujx:matrix.org");
    EXPECT_EQ(event.unsigned_data.age, 3715756273);
    EXPECT_EQ(event.origin_server_ts, 1506761924018L);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.join_rule, ns::state::JoinRule::Invite);

    EXPECT_EQ(data, json(event));

    data = R"({
          "origin_server_ts": 1506761924018,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619241414401ASocy:matrix.org",
          "unsigned": {
            "age": 3715756273
	  },
          "state_key": "",
          "content": {
            "join_rule": "public"
	  },
          "type": "m.room.join_rules"
        })"_json;

    EXPECT_EQ(data, json(ns::StateEvent<ns::state::JoinRules>(data)));

    data = R"({
          "origin_server_ts": 1506761924018,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619241414401ASocy:matrix.org",
          "unsigned": {
            "age": 3715756273
	  },
          "state_key": "",
          "content": {
            "join_rule": "knock"
	  },
          "type": "m.room.join_rules"
        })"_json;

    EXPECT_EQ(data, json(ns::StateEvent<ns::state::JoinRules>(data)));

    data = R"({
          "origin_server_ts": 1506761924018,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619241414401ASocy:matrix.org",
          "unsigned": {
            "age": 3715756273
	  },
          "state_key": "",
          "content": {
            "join_rule": "private"
	  },
          "type": "m.room.join_rules"
        })"_json;

    EXPECT_EQ(data, json(ns::StateEvent<ns::state::JoinRules>(data)));

    data = R"({
          "type": "m.room.join_rules",
          "state_key": "",
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619241414401ASocy:matrix.org",
          "origin_server_ts": 1506761924018,
          "content": {
              "join_rule": "restricted",
              "allow": [
                  {
                      "type": "m.room_membership",
                      "room_id": "!mods:example.org"
                  },
                  {
                      "type": "m.room_membership",
                      "room_id": "!users:example.org"
                  }
              ]
          }
      })"_json;

    ns::StateEvent<ns::state::JoinRules> event2 = data.get<ns::StateEvent<ns::state::JoinRules>>();
    ASSERT_EQ(event2.content.allow.size(), 2);
    ASSERT_EQ(event2.content.allow[0].type, mtx::events::state::JoinAllowanceType::RoomMembership);
    ASSERT_EQ(event2.content.allow[0].room_id, "!mods:example.org");
    ASSERT_EQ(event2.content.allow[1].type, mtx::events::state::JoinAllowanceType::RoomMembership);
    ASSERT_EQ(event2.content.allow[1].room_id, "!users:example.org");
}

TEST(StateEvents, Member)
{
    json data = R"({
          "origin_server_ts": 1510473132947,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15104731322646264oUPqj:matrix.org",
          "unsigned": {
            "age": 72
          },
          "state_key": "@nheko_test:matrix.org",
          "content": {
            "membership": "join",
            "avatar_url": "mxc://matrix.org/JKiSOBDDxCHxmaLAgoQwSAHa",
            "displayname": "NhekoTest"
          },
          "membership": "join",
          "type": "m.room.member",
          "room_id": "!lfoDRlNFWlvOnvkBwQ:matrix.org"
	})"_json;

    ns::StateEvent<ns::state::Member> event = data.get<ns::StateEvent<ns::state::Member>>();

    EXPECT_EQ(event.type, ns::EventType::RoomMember);
    EXPECT_EQ(event.event_id, "$15104731322646264oUPqj:matrix.org");
    EXPECT_EQ(event.room_id, "!lfoDRlNFWlvOnvkBwQ:matrix.org");
    EXPECT_EQ(event.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1510473132947L);
    EXPECT_EQ(event.unsigned_data.age, 72);
    EXPECT_EQ(event.state_key, "@nheko_test:matrix.org");
    EXPECT_EQ(event.content.membership, ns::state::Membership::Join);
    EXPECT_EQ(event.content.display_name, "NhekoTest");
    EXPECT_EQ(event.content.avatar_url, "mxc://matrix.org/JKiSOBDDxCHxmaLAgoQwSAHa");

    json data2 = R"({
          "prev_content": {
            "membership": "join",
            "avatar_url": "mxc://matrix.org/IvqcnGakfvwwKeZxbJWhblFp",
            "displayname": "NhekoTest"
          },
          "origin_server_ts": 1509214100884,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15092141005099019aHvYG:matrix.org",
          "age": 1259000688,
          "unsigned": {
            "prev_content": {
              "membership": "join",
              "avatar_url": "mxc://matrix.org/IvqcnGakfvwwKeZxbJWhblFp",
              "displayname": "NhekoTest"
            },
            "prev_sender": "@nheko_test:matrix.org",
            "replaces_state": "$15092124385075888YpYOh:matrix.org",
            "age": 1259000688
          },
          "state_key": "@nheko_test:matrix.org",
          "content": {
            "membership": "join",
            "avatar_url": "mxc://matrix.org/JKiSOBDDxCHxmaLAgoQwSAHa",
            "displayname": "NhekoTest"
          },
          "membership": "join",
          "room_id": "!VaMCVKSVcyPtXbcMXh:matrix.org",
          "user_id": "@nheko_test:matrix.org",
          "replaces_state": "$15092124385075888YpYOh:matrix.org",
          "type": "m.room.member"
        })"_json;

    ns::StateEvent<ns::state::Member> event2 = data2.get<ns::StateEvent<ns::state::Member>>();

    EXPECT_EQ(event2.type, ns::EventType::RoomMember);
    EXPECT_EQ(event2.event_id, "$15092141005099019aHvYG:matrix.org");
    EXPECT_EQ(event2.room_id, "!VaMCVKSVcyPtXbcMXh:matrix.org");
    EXPECT_EQ(event2.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event2.origin_server_ts, 1509214100884L);
    EXPECT_EQ(event2.unsigned_data.replaces_state, "$15092124385075888YpYOh:matrix.org");
    EXPECT_EQ(event2.unsigned_data.age, 1259000688);
    EXPECT_EQ(event2.unsigned_data.age, 1259000688);
    EXPECT_EQ(event2.state_key, "@nheko_test:matrix.org");
    EXPECT_EQ(event2.content.membership, ns::state::Membership::Join);
    EXPECT_EQ(event2.content.display_name, "NhekoTest");
    EXPECT_EQ(event2.content.avatar_url, "mxc://matrix.org/JKiSOBDDxCHxmaLAgoQwSAHa");
}

TEST(StateEvents, Name)
{
    json data = R"({
          "origin_server_ts": 1510473133142,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15104731332646270uaKBS:matrix.org",
          "unsigned": {
            "age": 70
          },
          "state_key": "",
          "content": {
            "name": "Random name"
          },
          "type": "m.room.name",
          "room_id": "!lfoDRlNFWlvOnvkBwQ:matrix.org"
        })"_json;

    ns::StateEvent<ns::state::Name> event = data.get<ns::StateEvent<ns::state::Name>>();

    EXPECT_EQ(event.type, ns::EventType::RoomName);
    EXPECT_EQ(event.event_id, "$15104731332646270uaKBS:matrix.org");
    EXPECT_EQ(event.room_id, "!lfoDRlNFWlvOnvkBwQ:matrix.org");
    EXPECT_EQ(event.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1510473133142L);
    EXPECT_EQ(event.unsigned_data.age, 70);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.name, "Random name");
}

TEST(StateEvents, PinnedEvents)
{
    json data = R"({
	  "unsigned": {
            "age": 242352
	  },
          "content": {
            "pinned": [
              "$one:localhost",
              "$two:localhost",
              "$three:localhost"
            ]
          },
          "event_id": "$WLGTSEFSEF:localhost",
          "origin_server_ts": 1431961217939,
          "sender": "@example:localhost",
          "state_key": "",
          "type": "m.room.pinned_events"
        })"_json;

    ns::StateEvent<ns::state::PinnedEvents> event =
      data.get<ns::StateEvent<ns::state::PinnedEvents>>();

    EXPECT_EQ(event.type, ns::EventType::RoomPinnedEvents);
    EXPECT_EQ(event.event_id, "$WLGTSEFSEF:localhost");
    EXPECT_EQ(event.sender, "@example:localhost");
    EXPECT_EQ(event.origin_server_ts, 1431961217939L);
    EXPECT_EQ(event.unsigned_data.age, 242352);
    EXPECT_EQ(event.state_key, "");

    EXPECT_EQ(event.content.pinned.size(), 3);
    EXPECT_EQ(event.content.pinned[0], "$one:localhost");
    EXPECT_EQ(event.content.pinned[1], "$two:localhost");
    EXPECT_EQ(event.content.pinned[2], "$three:localhost");
}

TEST(StateEvents, PowerLevels)
{
    json data = R"({
          "origin_server_ts": 1506761923995,
          "sender": "@mujx:matrix.org",
          "event_id": "$15067619231414400iQDgf:matrix.org",
          "unsigned": {
            "age": 3715756296
	  },
          "state_key": "",
          "content": {
            "events_default": 0,
            "invite": 0,
            "state_default": 50,
            "redact": 50,
            "ban": 50,
            "users_default": 0,
            "kick": 50,
            "events": {
              "m.room.avatar": 29,
              "m.room.name": 50,
              "m.room.canonical_alias":	50,
              "m.room.history_visibility": 120,
              "m.room.power_levels": 109
	    },
            "users": {
              "@mujx:matrix.org": 30
	    }
	  },
          "type": "m.room.power_levels"
	})"_json;

    ns::StateEvent<ns::state::PowerLevels> event =
      data.get<ns::StateEvent<ns::state::PowerLevels>>();

    EXPECT_EQ(event.type, ns::EventType::RoomPowerLevels);
    EXPECT_EQ(event.event_id, "$15067619231414400iQDgf:matrix.org");
    EXPECT_EQ(event.sender, "@mujx:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1506761923995);
    EXPECT_EQ(event.unsigned_data.age, 3715756296);
    EXPECT_EQ(event.state_key, "");

    EXPECT_EQ(event.content.kick, 50);
    EXPECT_EQ(event.content.ban, 50);
    EXPECT_EQ(event.content.invite, 0);
    EXPECT_EQ(event.content.redact, 50);
    EXPECT_EQ(event.content.events_default, 0);
    EXPECT_EQ(event.content.users_default, 0);
    EXPECT_EQ(event.content.state_default, 50);

    EXPECT_EQ(event.content.events.size(), 5);
    EXPECT_EQ(event.content.events["m.room.name"], 50);
    EXPECT_EQ(event.content.events["m.room.avatar"], 29);
    EXPECT_EQ(event.content.events["m.room.canonical_alias"], 50);
    EXPECT_EQ(event.content.events["m.room.history_visibility"], 120);
    EXPECT_EQ(event.content.events["m.room.power_levels"], 109);

    EXPECT_EQ(event.content.users.size(), 1);
    EXPECT_EQ(event.content.users["@mujx:matrix.org"], 30);

    EXPECT_EQ(event.content.event_level("m.room.name"), 50);
    EXPECT_EQ(event.content.event_level("m.room.avatar"), 29);
    EXPECT_EQ(event.content.event_level("m.room.canonical_alias"), 50);
    EXPECT_EQ(event.content.event_level("m.room.history_visibility"), 120);
    EXPECT_EQ(event.content.event_level("m.room.power_levels"), 109);
    EXPECT_EQ(event.content.event_level("m.custom.event"), event.content.events_default);

    EXPECT_EQ(event.content.user_level("@mujx:matrix.org"), 30);
    EXPECT_EQ(event.content.user_level("@not:matrix.org"), event.content.users_default);
}

TEST(StateEvents, Tombstone)
{
    json data = R"({
            "content": {
                "body": "This room has been replaced",
                "replacement_room": "!newroom:example.org"
            },
            "event_id": "$143273582443PhrSn:example.org",
            "origin_server_ts": 1432735824653,
            "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
            "sender": "@example:example.org",
            "state_key": "",
            "type": "m.room.tombstone",
            "unsigned": {
                "age": 1234
            }
        })"_json;

    ns::StateEvent<ns::state::Tombstone> event = data.get<ns::StateEvent<ns::state::Tombstone>>();

    EXPECT_EQ(event.type, ns::EventType::RoomTombstone);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:example.org");
    EXPECT_EQ(event.room_id, "!jEsUZKDJdhlrceRyVU:example.org");
    EXPECT_EQ(event.sender, "@example:example.org");
    EXPECT_EQ(event.origin_server_ts, 1432735824653);
    EXPECT_EQ(event.unsigned_data.age, 1234);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.body, "This room has been replaced");
    EXPECT_EQ(event.content.replacement_room, "!newroom:example.org");
}

TEST(StateEvents, Topic)
{
    json data = R"({
          "origin_server_ts": 1510476064445,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15104760642668662QICBu:matrix.org",
          "unsigned": {
            "age": 37
          },
          "state_key": "",
          "content": {
            "topic": "Test topic"
          },
          "type": "m.room.topic",
          "room_id": "!lfoDRlNFWlvOnvkBwQ:matrix.org"
        })"_json;

    ns::StateEvent<ns::state::Topic> event = data.get<ns::StateEvent<ns::state::Topic>>();

    EXPECT_EQ(event.type, ns::EventType::RoomTopic);
    EXPECT_EQ(event.event_id, "$15104760642668662QICBu:matrix.org");
    EXPECT_EQ(event.room_id, "!lfoDRlNFWlvOnvkBwQ:matrix.org");
    EXPECT_EQ(event.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1510476064445);
    EXPECT_EQ(event.unsigned_data.age, 37);
    EXPECT_EQ(event.state_key, "");
    EXPECT_EQ(event.content.topic, "Test topic");
}

TEST(StateEvents, PolicyRuleUser)
{
    json data = R"(
{
    "content": {
        "entity": "@alice*:example.org",
        "reason": "undesirable behaviour",
        "recommendation": "m.ban"
    },
    "event_id": "$143273582443PhrSn:example.org",
    "origin_server_ts": 1432735824653,
    "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
    "sender": "@example:example.org",
    "state_key": "rule:@alice*:example.org",
    "type": "m.policy.rule.user",
    "unsigned": {
        "age": 1234
    }
}
        )"_json;

    auto event = data.get<ns::StateEvent<ns::state::policy_rule::UserRule>>();

    EXPECT_EQ(event.type, ns::EventType::PolicyRuleUser);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:example.org");
    EXPECT_EQ(event.content.entity, "@alice*:example.org");
    EXPECT_EQ(event.content.reason, "undesirable behaviour");
    EXPECT_EQ(event.content.recommendation, ns::state::policy_rule::recommendation::ban);

    data  = R"(
{
    "content": null,
    "event_id": "$143273582443PhrSn:example.org",
    "origin_server_ts": 1432735824653,
    "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
    "sender": "@example:example.org",
    "state_key": "rule:@alice*:example.org",
    "type": "m.policy.rule.user",
    "unsigned": {
        "age": 1234
    }
}
        )"_json;
    event = data.get<ns::StateEvent<ns::state::policy_rule::UserRule>>();
    EXPECT_EQ(event.type, ns::EventType::PolicyRuleUser);
}

TEST(StateEvents, PolicyRuleRoom)
{
    json data = R"(
{
    "content": {
        "entity": "#*:example.org",
        "reason": "undesirable content",
        "recommendation": "m.ban"
    },
    "event_id": "$143273582443PhrSn:example.org",
    "origin_server_ts": 1432735824653,
    "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
    "sender": "@example:example.org",
    "state_key": "rule:@alice*:example.org",
    "type": "m.policy.rule.room",
    "unsigned": {
        "age": 1234
    }
}
        )"_json;

    auto event = data.get<ns::StateEvent<ns::state::policy_rule::RoomRule>>();

    EXPECT_EQ(event.type, ns::EventType::PolicyRuleRoom);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:example.org");
    EXPECT_EQ(event.content.entity, "#*:example.org");
    EXPECT_EQ(event.content.reason, "undesirable content");
    EXPECT_EQ(event.content.recommendation, ns::state::policy_rule::recommendation::ban);
}

TEST(StateEvents, PolicyRuleServer)
{
    json data = R"(
{
    "content": {
        "entity": "*.example.org",
        "reason": "undesirable engagement",
        "recommendation": "m.ban"
    },
    "event_id": "$143273582443PhrSn:example.org",
    "origin_server_ts": 1432735824653,
    "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
    "sender": "@example:example.org",
    "state_key": "rule:@alice*:example.org",
    "type": "m.policy.rule.server",
    "unsigned": {
        "age": 1234
    }
}
        )"_json;

    auto event = data.get<ns::StateEvent<ns::state::policy_rule::ServerRule>>();

    EXPECT_EQ(event.type, ns::EventType::PolicyRuleServer);
    EXPECT_EQ(event.event_id, "$143273582443PhrSn:example.org");
    EXPECT_EQ(event.content.entity, "*.example.org");
    EXPECT_EQ(event.content.reason, "undesirable engagement");
    EXPECT_EQ(event.content.recommendation, ns::state::policy_rule::recommendation::ban);
}

TEST(StateEvents, SpaceChild)
{
    json data = R"({
          "origin_server_ts": 1510476064445,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15104760642668662QICBu:matrix.org",
      "type": "m.space.child",
      "state_key": "!abcd:example.com",
      "content": {
          "via": ["example.com", "test.org"]
      }
}
        )"_json;

    ns::StateEvent<ns::state::space::Child> event =
      data.get<ns::StateEvent<ns::state::space::Child>>();

    EXPECT_EQ(event.type, ns::EventType::SpaceChild);
    EXPECT_EQ(event.event_id, "$15104760642668662QICBu:matrix.org");
    EXPECT_EQ(event.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1510476064445);
    EXPECT_EQ(event.state_key, "!abcd:example.com");
    ASSERT_TRUE(event.content.via.has_value());
    std::vector<std::string> via{"example.com", "test.org"};
    EXPECT_EQ(event.content.via, via);
    EXPECT_FALSE(event.content.order.has_value());

    data = R"({
          "origin_server_ts": 1510476064445,
          "sender": "@nheko_test:matrix.org",
          "event_id": "$15104760642668662QICBu:matrix.org",
        "type": "m.space.child",
        "state_key": "!efgh:example.com",
        "content": {
        "via": ["example.com"],
        "order": "abcd"
    }
}
        )"_json;

    event = data.get<ns::StateEvent<ns::state::space::Child>>();

    EXPECT_EQ(event.type, ns::EventType::SpaceChild);
    EXPECT_EQ(event.event_id, "$15104760642668662QICBu:matrix.org");
    EXPECT_EQ(event.sender, "@nheko_test:matrix.org");
    EXPECT_EQ(event.origin_server_ts, 1510476064445);
    EXPECT_EQ(event.state_key, "!efgh:example.com");
    ASSERT_TRUE(event.content.via.has_value());
    std::vector<std::string> via2{"example.com"};
    EXPECT_EQ(event.content.via, via2);
    ASSERT_TRUE(event.content.order.has_value());
    ASSERT_EQ(event.content.order, "abcd");

    data = R"({
          "origin_server_ts": 1510476064445,