imterah/element-portable
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Introduce Membership type

Browse source
This commit is contained in:
Stanislav Demydiuk 2024-03-11 17:16:53 +00:00 • committed by Andy Balaam
parent 3c6fd58628
commit da99bad7b9
115 changed files with 582 additions and 526 deletions
Download patch file Download diff file Expand all files Collapse all files

24
test/stores/MemberListStore-test.ts
View file

@ -55,7 +55,7 @@ describe("MemberListStore", () => {
type: EventType.RoomMember,
state_key: alice,
content: {
membership: "join",
membership: Membership.Join,
},
sender: alice,
room_id: roomId,
@ -77,8 +77,8 @@ describe("MemberListStore", () => {
});
it("loads members in a room", async () => {
addMember(room, bob, "invite");
addMember(room, charlie, "leave");
addMember(room, bob, Membership.Invite);
addMember(room, charlie, Membership.Leave);
const { invited, joined } = await store.loadMemberList(roomId);
expect(invited).toEqual([room.getMember(bob)]);
@ -92,8 +92,8 @@ describe("MemberListStore", () => {
});
it("sorts by power level", async () => {
addMember(room, bob, "join");
addMember(room, charlie, "join");
addMember(room, bob, Membership.Join);
addMember(room, charlie, Membership.Join);
setPowerLevels(room, {
users: {
[alice]: 100,
@ -109,8 +109,8 @@ describe("MemberListStore", () => {
it("sorts by name if power level is equal", async () => {
const doris = "@doris:bar";
addMember(room, bob, "join");
addMember(room, charlie, "join");
addMember(room, bob, Membership.Join);
addMember(room, charlie, Membership.Join);
setPowerLevels(room, {
users_default: 10,
});
@ -120,7 +120,7 @@ describe("MemberListStore", () => {
expect(joined).toEqual([room.getMember(alice), room.getMember(bob), room.getMember(charlie)]);
// Ensure it sorts by display name if they are set
addMember(room, doris, "join", "AAAAA");
addMember(room, doris, Membership.Join, "AAAAA");
({ invited, joined } = await store.loadMemberList(roomId));
expect(invited).toEqual([]);
expect(joined).toEqual([
@ -134,15 +134,15 @@ describe("MemberListStore", () => {
it("filters based on a search query", async () => {
const mice = "@mice:bar";
const zorro = "@zorro:bar";
addMember(room, bob, "join");
addMember(room, mice, "join");
addMember(room, bob, Membership.Join);
addMember(room, mice, Membership.Join);
let { invited, joined } = await store.loadMemberList(roomId, "ice");
expect(invited).toEqual([]);
expect(joined).toEqual([room.getMember(alice), room.getMember(mice)]);
// Ensure it filters by display name if they are set
addMember(room, zorro, "join", "ice ice baby");
addMember(room, zorro, Membership.Join, "ice ice baby");
({ invited, joined } = await store.loadMemberList(roomId, "ice"));
expect(invited).toEqual([]);
expect(joined).toEqual([room.getMember(alice), room.getMember(zorro), room.getMember(mice)]);
@ -180,7 +180,7 @@ describe("MemberListStore", () => {
type: EventType.RoomMember,
state_key: bob,
content: {
membership: "join",
membership: Membership.Join,
displayname: "Bob",
},
sender: bob,

2
test/stores/OwnBeaconStore-test.ts
View file

@ -556,7 +556,7 @@ describe("OwnBeaconStore", () => {
it("destroys and removes beacons when current user leaves room", async () => {
// alice leaves room1
const membershipEvent = makeMembershipEvent(room1Id, aliceId, "leave");
const membershipEvent = makeMembershipEvent(room1Id, aliceId, Membership.Leave);
const member = new RoomMember(room1Id, aliceId);
member.setMembershipEvent(membershipEvent);

72
test/stores/SpaceStore-test.ts
View file

@ -57,13 +57,13 @@ const fav2 = "!fav2:server";
const fav3 = "!fav3:server";
const dm1 = "!dm1:server";
const dm1Partner = new RoomMember(dm1, "@dm1Partner:server");
dm1Partner.membership = "join";
dm1Partner.membership = Membership.Join;
const dm2 = "!dm2:server";
const dm2Partner = new RoomMember(dm2, "@dm2Partner:server");
dm2Partner.membership = "join";
dm2Partner.membership = Membership.Join;
const dm3 = "!dm3:server";
const dm3Partner = new RoomMember(dm3, "@dm3Partner:server");
dm3Partner.membership = "join";
dm3Partner.membership = Membership.Join;
const orphan1 = "!orphan1:server";
const orphan2 = "!orphan2:server";
const invite1 = "!invite1:server";
@ -289,7 +289,7 @@ describe("SpaceStore", () => {
});
it("invite to a subspace is only shown at the top level", async () => {
mkSpace(invite1).getMyMembership.mockReturnValue("invite");
mkSpace(invite1).getMyMembership.mockReturnValue(Membership.Invite);
mkSpace(space1, [invite1]);
await run();
@ -335,20 +335,20 @@ describe("SpaceStore", () => {
});
[invite1, invite2].forEach((roomId) => {
mocked(client.getRoom(roomId)!).getMyMembership.mockReturnValue("invite");
mocked(client.getRoom(roomId)).getMyMembership.mockReturnValue(Membership.Invite);
});
// have dmPartner1 be in space1 with you
const mySpace1Member = new RoomMember(space1, testUserId);
mySpace1Member.membership = "join";
(rooms.find((r) => r.roomId === space1)!.getMembers as jest.Mock).mockReturnValue([
mySpace1Member.membership = Membership.Join;
(rooms.find((r) => r.roomId === space1).getMembers as jest.Mock).mockReturnValue([
mySpace1Member,
dm1Partner,
]);
// have dmPartner2 be in space2 with you
const mySpace2Member = new RoomMember(space2, testUserId);
mySpace2Member.membership = "join";
(rooms.find((r) => r.roomId === space2)!.getMembers as jest.Mock).mockReturnValue([
mySpace2Member.membership = Membership.Join;
(rooms.find((r) => r.roomId === space2).getMembers as jest.Mock).mockReturnValue([
mySpace2Member,
dm2Partner,
]);
@ -683,16 +683,16 @@ describe("SpaceStore", () => {
it("should add new DM Invites to the People Space Notification State", async () => {
mkRoom(dm1);
mocked(client.getRoom(dm1)!).getMyMembership.mockReturnValue("join");
mocked(client.getRoom(dm1)!).getMyMembership.mockReturnValue(Membership.Join);
mocked(client).getRoom.mockImplementation((roomId) => rooms.find((room) => room.roomId === roomId) || null);
await run();
mkRoom(dm2);
const cliDm2 = client.getRoom(dm2)!;
mocked(cliDm2).getMyMembership.mockReturnValue("invite");
mocked(cliDm2).getMyMembership.mockReturnValue(Membership.Invite);
mocked(client).getRoom.mockImplementation((roomId) => rooms.find((room) => room.roomId === roomId) || null);
client.emit(RoomEvent.MyMembership, cliDm2, "invite");
client.emit(RoomEvent.MyMembership, cliDm2, Membership.Invite);
[dm1, dm2].forEach((d) => {
expect(
@ -721,9 +721,9 @@ describe("SpaceStore", () => {
await run();
expect(store.spacePanelSpaces).toStrictEqual([space]);
space.getMyMembership.mockReturnValue("leave");
space.getMyMembership.mockReturnValue(Membership.Leave);
const prom = testUtils.emitPromise(store, UPDATE_TOP_LEVEL_SPACES);
client.emit(RoomEvent.MyMembership, space, "leave", "join");
client.emit(RoomEvent.MyMembership, space, Membership.Leave, Membership.Join);
await prom;
expect(store.spacePanelSpaces).toStrictEqual([]);
});
@ -733,7 +733,7 @@ describe("SpaceStore", () => {
expect(store.spacePanelSpaces).toStrictEqual([]);
expect(store.invitedSpaces).toStrictEqual([]);
const space = mkSpace(space1);
space.getMyMembership.mockReturnValue("invite");
space.getMyMembership.mockReturnValue(Membership.Invite);
const prom = testUtils.emitPromise(store, UPDATE_INVITED_SPACES);
client.emit(ClientEvent.Room, space);
await prom;
@ -743,14 +743,14 @@ describe("SpaceStore", () => {
it("updates state when space invite is accepted", async () => {
const space = mkSpace(space1);
space.getMyMembership.mockReturnValue("invite");
space.getMyMembership.mockReturnValue(Membership.Invite);
await run();
expect(store.spacePanelSpaces).toStrictEqual([]);
expect(store.invitedSpaces).toStrictEqual([space]);
space.getMyMembership.mockReturnValue("join");
space.getMyMembership.mockReturnValue(Membership.Join);
const prom = testUtils.emitPromise(store, UPDATE_TOP_LEVEL_SPACES);
client.emit(RoomEvent.MyMembership, space, "join", "invite");
client.emit(RoomEvent.MyMembership, space, Membership.Join, Membership.Invite);
await prom;
expect(store.spacePanelSpaces).toStrictEqual([space]);
expect(store.invitedSpaces).toStrictEqual([]);
@ -758,14 +758,14 @@ describe("SpaceStore", () => {
it("updates state when space invite is rejected", async () => {
const space = mkSpace(space1);
space.getMyMembership.mockReturnValue("invite");
space.getMyMembership.mockReturnValue(Membership.Invite);
await run();
expect(store.spacePanelSpaces).toStrictEqual([]);
expect(store.invitedSpaces).toStrictEqual([space]);
space.getMyMembership.mockReturnValue("leave");
space.getMyMembership.mockReturnValue(Membership.Leave);
const prom = testUtils.emitPromise(store, UPDATE_INVITED_SPACES);
client.emit(RoomEvent.MyMembership, space, "leave", "invite");
client.emit(RoomEvent.MyMembership, space, Membership.Leave, Membership.Invite);
await prom;
expect(store.spacePanelSpaces).toStrictEqual([]);
expect(store.invitedSpaces).toStrictEqual([]);
@ -783,7 +783,7 @@ describe("SpaceStore", () => {
expect(store.isRoomInSpace(MetaSpace.Home, invite1)).toBeFalsy();
const invite = mkRoom(invite1);
invite.getMyMembership.mockReturnValue("invite");
invite.getMyMembership.mockReturnValue(Membership.Invite);
const prom = testUtils.emitPromise(store, space1);
client.emit(ClientEvent.Room, space);
await prom;
@ -845,7 +845,7 @@ describe("SpaceStore", () => {
room: spaceId,
user: client.getUserId()!,
skey: user.userId,
content: { membership: "join" },
content: { membership: Membership.Join },
ts: Date.now(),
});
const spaceRoom = client.getRoom(spaceId)!;
@ -926,7 +926,7 @@ describe("SpaceStore", () => {
beforeEach(async () => {
mkRoom(room1); // not a space
mkSpace(space1, [mkSpace(space2).roomId]);
mkSpace(space3).getMyMembership.mockReturnValue("invite");
mkSpace(space3).getMyMembership.mockReturnValue(Membership.Invite);
await run();
store.setActiveSpace(MetaSpace.Home);
expect(store.activeSpace).toBe(MetaSpace.Home);
@ -986,7 +986,7 @@ describe("SpaceStore", () => {
const event = mkEvent({
event: true,
type: EventType.RoomMember,
content: { membership: "join" },
content: { membership: Membership.Join },
skey: dm1Partner.userId,
user: dm1Partner.userId,
room: space1,
@ -994,7 +994,7 @@ describe("SpaceStore", () => {
space.getMember.mockImplementation((userId) => {
if (userId === dm1Partner.userId) {
const member = new RoomMember(space1, dm1Partner.userId);
member.membership = "join";
member.membership = Membership.Join;
return member;
}
return null;
@ -1249,15 +1249,15 @@ describe("SpaceStore", () => {
// receive invite to space
const rootSpace = mkSpace(space1, [room1, room2, space2]);
rootSpace.getMyMembership.mockReturnValue("invite");
rootSpace.getMyMembership.mockReturnValue(Membership.Invite);
client.emit(ClientEvent.Room, rootSpace);
jest.runOnlyPendingTimers();
expect(SpaceStore.instance.invitedSpaces).toStrictEqual([rootSpace]);
expect(SpaceStore.instance.spacePanelSpaces).toStrictEqual([]);
// accept invite to space
rootSpace.getMyMembership.mockReturnValue("join");
client.emit(RoomEvent.MyMembership, rootSpace, "join", "invite");
rootSpace.getMyMembership.mockReturnValue(Membership.Join);
client.emit(RoomEvent.MyMembership, rootSpace, Membership.Join, Membership.Invite);
jest.runOnlyPendingTimers();
expect(SpaceStore.instance.invitedSpaces).toStrictEqual([]);
expect(SpaceStore.instance.spacePanelSpaces).toStrictEqual([rootSpace]);
@ -1265,7 +1265,7 @@ describe("SpaceStore", () => {
// join room in space
expect(SpaceStore.instance.isRoomInSpace(space1, room1)).toBeFalsy();
const rootSpaceRoom1 = mkRoom(room1);
rootSpaceRoom1.getMyMembership.mockReturnValue("join");
rootSpaceRoom1.getMyMembership.mockReturnValue(Membership.Join);
client.emit(ClientEvent.Room, rootSpaceRoom1);
jest.runOnlyPendingTimers();
expect(SpaceStore.instance.invitedSpaces).toStrictEqual([]);
@ -1279,7 +1279,7 @@ describe("SpaceStore", () => {
// receive room invite
expect(SpaceStore.instance.isRoomInSpace(space1, room2)).toBeFalsy();
const rootSpaceRoom2 = mkRoom(room2);
rootSpaceRoom2.getMyMembership.mockReturnValue("invite");
rootSpaceRoom2.getMyMembership.mockReturnValue(Membership.Invite);
client.emit(ClientEvent.Room, rootSpaceRoom2);
jest.runOnlyPendingTimers();
expect(SpaceStore.instance.invitedSpaces).toStrictEqual([]);
@ -1292,9 +1292,9 @@ describe("SpaceStore", () => {
// start DM in space
const myRootSpaceMember = new RoomMember(space1, testUserId);
myRootSpaceMember.membership = "join";
myRootSpaceMember.membership = Membership.Join;
const rootSpaceFriend = new RoomMember(space1, dm1Partner.userId);
rootSpaceFriend.membership = "join";
rootSpaceFriend.membership = Membership.Join;
rootSpace.getMembers.mockReturnValue([myRootSpaceMember, rootSpaceFriend]);
rootSpace.getMember.mockImplementation((userId) => {
switch (userId) {
@ -1310,7 +1310,7 @@ describe("SpaceStore", () => {
event: true,
type: EventType.RoomMember,
content: {
membership: "join",
membership: Membership.Join,
},
skey: dm1Partner.userId,
user: dm1Partner.userId,
@ -1320,7 +1320,7 @@ describe("SpaceStore", () => {
jest.runOnlyPendingTimers();
expect(SpaceStore.instance.getSpaceFilteredUserIds(space1)!.has(dm1Partner.userId)).toBeTruthy();
const dm1Room = mkRoom(dm1);
dm1Room.getMyMembership.mockReturnValue("join");
dm1Room.getMyMembership.mockReturnValue(Membership.Join);
client.emit(ClientEvent.Room, dm1Room);
jest.runOnlyPendingTimers();
expect(SpaceStore.instance.invitedSpaces).toStrictEqual([]);
@ -1333,7 +1333,7 @@ describe("SpaceStore", () => {
// join subspace
const subspace = mkSpace(space2);
subspace.getMyMembership.mockReturnValue("join");
subspace.getMyMembership.mockReturnValue(Membership.Join);
const prom = testUtils.emitPromise(SpaceStore.instance, space1);
client.emit(ClientEvent.Room, subspace);
jest.runOnlyPendingTimers();

10
test/stores/notifications/RoomNotificationState-test.ts
View file

@ -119,7 +119,7 @@ describe("RoomNotificationState", () => {
muteRoom(room);
setUnreads(room, 1234, 0);
room.updateMyMembership("join"); // emit
room.updateMyMembership(Membership.Join); // emit
expect(roomNotifState.level).toBe(NotificationLevel.None);
expect(roomNotifState.symbol).toBe(null);
@ -129,7 +129,7 @@ describe("RoomNotificationState", () => {
it("suggests a red ! if the user has been invited to a room", () => {
const roomNotifState = new RoomNotificationState(room, false);
room.updateMyMembership("invite"); // emit
room.updateMyMembership(Membership.Invite); // emit
expect(roomNotifState.level).toBe(NotificationLevel.Highlight);
expect(roomNotifState.symbol).toBe("!");
@ -140,7 +140,7 @@ describe("RoomNotificationState", () => {
const roomNotifState = new RoomNotificationState(room, false);
setUnreads(room, 4321, 0);
room.updateMyMembership("join"); // emit
room.updateMyMembership(Membership.Join); // emit
expect(roomNotifState.level).toBe(NotificationLevel.Notification);
expect(roomNotifState.symbol).toBe(null);
@ -151,7 +151,7 @@ describe("RoomNotificationState", () => {
const roomNotifState = new RoomNotificationState(room, false);
setUnreads(room, 0, 69);
room.updateMyMembership("join"); // emit
room.updateMyMembership(Membership.Join); // emit
expect(roomNotifState.level).toBe(NotificationLevel.Highlight);
expect(roomNotifState.symbol).toBe(null);
@ -171,7 +171,7 @@ describe("RoomNotificationState", () => {
);
addThread(room);
room.updateMyMembership("join"); // emit
room.updateMyMembership(Membership.Join); // emit
expect(roomNotifState.level).toBe(NotificationLevel.Activity);
expect(roomNotifState.symbol).toBe(null);

18
test/stores/room-list/RoomListStore-test.ts
View file

@ -123,8 +123,8 @@ describe("RoomListStore", () => {
// When we tell it we joined a new room that has an old room as
// predecessor in the create event
const payload = {
oldMembership: "invite",
membership: "join",
oldMembership: Membership.Invite,
membership: Membership.Join,
room: roomWithCreatePredecessor,
};
store.onDispatchMyMembership(payload);
@ -142,8 +142,8 @@ describe("RoomListStore", () => {
// When we tell it we joined a new room with no predecessor
const payload = {
oldMembership: "invite",
membership: "join",
oldMembership: Membership.Invite,
membership: Membership.Join,
room: roomNoPredecessor,
};
store.onDispatchMyMembership(payload);
@ -159,9 +159,9 @@ describe("RoomListStore", () => {
const room1 = new Room("!r1:e.com", client, userId, { pendingEventOrdering: PendingEventOrdering.Detached });
const room2 = new Room("!r2:e.com", client, userId, { pendingEventOrdering: PendingEventOrdering.Detached });
const room3 = new Room("!r3:e.com", client, userId, { pendingEventOrdering: PendingEventOrdering.Detached });
room1.updateMyMembership("join");
room2.updateMyMembership("join");
room3.updateMyMembership("join");
room1.updateMyMembership(Membership.Join);
room2.updateMyMembership(Membership.Join);
room3.updateMyMembership(Membership.Join);
DMRoomMap.makeShared(client);
const { store } = createStore();
client.getVisibleRooms = jest.fn().mockReturnValue([room1, room2, room3]);
@ -259,8 +259,8 @@ describe("RoomListStore", () => {
// When we tell it we joined a new room that has an old room as
// predecessor in the create event
const payload = {
oldMembership: "invite",
membership: "join",
oldMembership: Membership.Invite,
membership: Membership.Join,
room: roomWithPredecessorEvent,
};
store.onDispatchMyMembership(payload);

2
test/stores/room-list/algorithms/Algorithm-test.ts
View file

@ -82,7 +82,7 @@ describe("Algorithm", () => {
client.reEmitter.reEmit(room, [RoomStateEvent.Events]);
client.reEmitter.reEmit(roomWithCall, [RoomStateEvent.Events]);
for (const room of client.getRooms()) jest.spyOn(room, "getMyMembership").mockReturnValue("join");
for (const room of client.getRooms()) jest.spyOn(room, "getMyMembership").mockReturnValue(Membership.Join);
algorithm.setKnownRooms(client.getRooms());
setupAsyncStoreWithClient(CallStore.instance, client);

16
test/stores/room-list/algorithms/RecentAlgorithm-test.ts
View file

@ -53,7 +53,7 @@ describe("RecentAlgorithm", () => {
event: true,
});
room.getMyMembership = () => "join";
room.getMyMembership = () => Membership.Join;
room.addLiveEvents([event1]);
expect(algorithm.getLastTs(room, "@jane:matrix.org")).toBe(5);
@ -74,7 +74,7 @@ describe("RecentAlgorithm", () => {
it("works when not a member", () => {
const room = mkRoom(cli, "!new:example.org");
room.getMyMembership.mockReturnValue(EffectiveMembership.Invite);
room.getMyMembership.mockReturnValue(Membership.Invite);
expect(algorithm.getLastTs(room, "@john:matrix.org")).toBe(Number.MAX_SAFE_INTEGER);
});
});
@ -84,8 +84,8 @@ describe("RecentAlgorithm", () => {
const room1 = new Room("room1", cli, "@bob:matrix.org");
const room2 = new Room("room2", cli, "@bob:matrix.org");
room1.getMyMembership = () => "join";
room2.getMyMembership = () => "join";
room1.getMyMembership = () => Membership.Join;
room2.getMyMembership = () => Membership.Join;
const evt = mkMessage({
room: room1.roomId,
@ -112,8 +112,8 @@ describe("RecentAlgorithm", () => {
const room1 = new Room("room1", cli, "@bob:matrix.org");
const room2 = new Room("room2", cli, "@bob:matrix.org");
room1.getMyMembership = () => "join";
room2.getMyMembership = () => "join";
room1.getMyMembership = () => Membership.Join;
room2.getMyMembership = () => Membership.Join;
const evt = mkMessage({
room: room1.roomId,
@ -142,8 +142,8 @@ describe("RecentAlgorithm", () => {
const room1 = new Room("room1", cli, "@bob:matrix.org");
const room2 = new Room("room2", cli, "@bob:matrix.org");
room1.getMyMembership = () => "join";
room2.getMyMembership = () => "join";
room1.getMyMembership = () => Membership.Join;
room2.getMyMembership = () => Membership.Join;
const { rootEvent, events: events1 } = mkThread({
room: room1,