fix: refresh stale room state

This commit is contained in:
Erwan Leboucher committed 2026-08-13 14:18:18 +02:00
1 parent d5fc38cfca
commit 633b2f6f2a
6 files changed
+136 -4

No files matched your search

+28
View File
@@ -0,0 +1,28 @@
import { renderHook } from '@testing-library/react';
import { EventEmitter } from 'events';
import { describe, expect, it } from 'vitest';
import type { MatrixClient, MatrixEvent } from '$types/matrix-sdk';
import { MatrixClientProvider } from './useMatrixClient';
import { useAccountData } from './useAccountData';
describe('useAccountData', () => {
it('clears the previous event when the event type changes', () => {
const mx = Object.assign(new EventEmitter(), {
getAccountData: (eventType: string) =>
eventType === 'm.example.one' ? ({ getType: () => eventType } as MatrixEvent) : undefined,
}) as unknown as MatrixClient;
const wrapper = ({ children }: { children: React.ReactNode }) => (
<MatrixClientProvider value={mx}>{children}</MatrixClientProvider>
);
const { result, rerender } = renderHook(({ eventType }) => useAccountData(eventType), {
initialProps: { eventType: 'm.example.one' },
wrapper,
});
expect(result.current?.getType()).toBe('m.example.one');
rerender({ eventType: 'm.example.two' });
expect(result.current).toBeUndefined();
});
});
+5 -1
View File
@@ -1,4 +1,4 @@
import { useState, useCallback } from 'react';
import { useState, useCallback, useEffect } from 'react';
import type { AccountDataEvents } from '$types/matrix-sdk';
import { useMatrixClient } from './useMatrixClient';
import { useAccountDataCallback } from './useAccountDataCallback';
@@ -7,6 +7,10 @@ export function useAccountData(eventType: string) {
const mx = useMatrixClient();
const [event, setEvent] = useState(() => mx.getAccountData(eventType as keyof AccountDataEvents));
useEffect(() => {
setEvent(mx.getAccountData(eventType as keyof AccountDataEvents));
}, [mx, eventType]);
useAccountDataCallback(
mx,
useCallback(
+48
View File
@@ -0,0 +1,48 @@
import { renderHook } from '@testing-library/react';
import { EventEmitter } from 'events';
import { describe, expect, it } from 'vitest';
import { KnownMembership } from '$types/matrix-sdk';
import type { Room, RoomMember } from '$types/matrix-sdk';
import { useMembership } from './useMembership';
describe('useMembership', () => {
it('uses a member that arrives after the profile opens', () => {
let member: RoomMember | undefined;
const memberEvents = new EventEmitter();
const room = {
roomId: '!room:example.org',
getMember: () => member,
} as unknown as Room;
const { result, rerender } = renderHook(() => useMembership(room, '@alice:example.org'));
expect(result.current).toBe(KnownMembership.Leave);
member = Object.assign(memberEvents, { membership: KnownMembership.Join }) as RoomMember;
rerender();
expect(result.current).toBe(KnownMembership.Join);
});
it('does not retain membership when switching users', () => {
const memberEvents = new EventEmitter();
const members = new Map<string, RoomMember>([
[
'@alice:example.org',
Object.assign(memberEvents, { membership: KnownMembership.Join }) as RoomMember,
],
]);
const room = {
roomId: '!room:example.org',
getMember: (userId: string) => members.get(userId),
} as unknown as Room;
const { result, rerender } = renderHook(({ userId }) => useMembership(room, userId), {
initialProps: { userId: '@alice:example.org' },
});
expect(result.current).toBe(KnownMembership.Join);
rerender({ userId: '@bob:example.org' });
expect(result.current).toBe(KnownMembership.Leave);
});
});
+6 -2
View File
@@ -1,4 +1,4 @@
import { useCallback, useState } from 'react';
import { useCallback, useEffect, useState } from 'react';
import type { Membership, Room, RoomMemberEventHandlerMap } from '$types/matrix-sdk';
import { RoomMemberEvent, KnownMembership } from '$types/matrix-sdk';
import { useMatrixEvent } from '$hooks/useMatrixEvent';
@@ -10,6 +10,10 @@ export const useMembership = (room: Room, userId: string): Membership => {
() => member?.membership ?? KnownMembership.Leave
);
useEffect(() => {
setMembership(member?.membership ?? KnownMembership.Leave);
}, [room, userId, member?.membership]);
const handleMembershipChange: RoomMemberEventHandlerMap[RoomMemberEvent.Membership] = useCallback(
(event, m) => {
if (event.getRoomId() === room.roomId && m.userId === userId) {
@@ -21,5 +25,5 @@ export const useMembership = (room: Room, userId: string): Membership => {
useMatrixEvent(member, RoomMemberEvent.Membership, handleMembershipChange);
return membership;
return member?.membership ?? membership;
};
+46
View File
@@ -0,0 +1,46 @@
import { act, renderHook } from '@testing-library/react';
import { EventEmitter } from 'events';
import { describe, expect, it } from 'vitest';
import { EventType, RoomStateEvent } from '$types/matrix-sdk';
import type { MatrixClient, MatrixEvent, Room } from '$types/matrix-sdk';
import { MatrixClientProvider } from './useMatrixClient';
import { useRoomsPowerLevels } from './usePowerLevels';
describe('useRoomsPowerLevels', () => {
it('re-derives permissions when a room create event arrives', () => {
const client = new EventEmitter();
let powerLevelsEvent: MatrixEvent | undefined;
const room = {
roomId: '!space:example.org',
getLiveTimeline: () => ({
getState: () => ({
getStateEvents: (type: string) =>
type === EventType.RoomPowerLevels ? powerLevelsEvent : undefined,
}),
}),
} as unknown as Room;
const wrapper = ({ children }: { children: React.ReactNode }) => (
<MatrixClientProvider value={client as unknown as MatrixClient}>
{children}
</MatrixClientProvider>
);
const rooms = [room];
const { result } = renderHook(() => useRoomsPowerLevels(rooms), { wrapper });
expect(result.current.get(room.roomId)?.users_default).toBe(0);
powerLevelsEvent = {
getContent: () => ({ users_default: 75 }),
} as unknown as MatrixEvent;
const createEvent = {
getRoomId: () => room.roomId,
getType: () => EventType.RoomCreate,
getStateKey: () => '',
} as unknown as MatrixEvent;
act(() => {
client.emit(RoomStateEvent.Events, createEvent);
});
expect(result.current.get(room.roomId)?.users_default).toBe(75);
});
});
+3 -1
View File
@@ -116,7 +116,9 @@ export const useRoomsPowerLevels = (rooms: Room[]): Map<string, IPowerLevels> =>
const roomId = event.getRoomId();
if (
roomId &&
event.getType() === (EventType.RoomPowerLevels as string) &&
[EventType.RoomPowerLevels as string, EventType.RoomCreate as string].includes(
event.getType()
) &&
event.getStateKey() === '' &&
rooms.some((r) => r.roomId === roomId)
) {