fix: resolve PR #529 quality check failures

This commit is contained in:
Evie Gauthier committed 2026-03-27 23:52:45 -04:00
1 parent f9c725e0ab
commit 6ccb85f96b
4 files changed
+121 -183

No files matched your search

@@ -20,10 +20,7 @@ const linkStyles = { color: color.Success.Main };
// Inner cache keyed by URL only (not ts) — the same URL shows the same preview
// regardless of which message referenced it. Promises are evicted after settling
// so a later render can retry after network recovery.
const previewRequestCache = new WeakMap<
any,
Map<string, Promise<IPreviewUrlResponse>>
>();
const previewRequestCache = new WeakMap<any, Map<string, Promise<IPreviewUrlResponse>>>();
const getClientCache = (mx: any): Map<string, Promise<IPreviewUrlResponse>> => {
let clientCache = previewRequestCache.get(mx);
@@ -1,172 +0,0 @@
// Tests for useTimelineSync: focus on room-change timeline reset behavior
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { renderHook, act } from '@testing-library/react';
import { useTimelineSync } from './useTimelineSync';
import { getInitialTimeline } from '$utils/timeline';
// Mock the dependencies
vi.mock('$hooks/useAlive', () => ({
useAlive: () => () => true,
}));
vi.mock('$utils/notifications', () => ({
markAsRead: vi.fn(),
}));
vi.mock('$utils/room', () => ({
decryptAllTimelineEvent: vi.fn(),
}));
vi.mock('$utils/timeline', () => ({
getInitialTimeline: vi.fn(),
getEmptyTimeline: vi.fn(),
getLinkedTimelines: vi.fn(() => []),
getTimelinesEventsCount: vi.fn(() => 0),
getEventIdAbsoluteIndex: vi.fn(),
getLiveTimeline: vi.fn(),
getRoomUnreadInfo: vi.fn(),
PAGINATION_LIMIT: 30,
}));
vi.mock('$types/matrix-sdk', () => ({
Direction: { Backward: 0, Forward: 1 },
}));
vi.mock('@sentry/react', () => ({
startSpan: vi.fn((config, fn) => fn()),
metrics: {
distribution: vi.fn(),
},
}));
// Create mock room and client
const createMockRoom = (roomId: string) => ({
roomId,
getUnfilteredTimelineSet: vi.fn(() => ({
getTimelineForEvent: vi.fn(() => null),
})),
});
const createMockClient = () => ({
getUserId: vi.fn(() => '@user:example.com'),
});
describe('useTimelineSync', () => {
beforeEach(() => {
vi.clearAllMocks();
});
it('resets timeline state when room.roomId changes and eventId is not set', () => {
const room1 = createMockRoom('!room1:example.com');
const room2 = createMockRoom('!room2:example.com');
const mx = createMockClient();
const mockTimeline = { linkedTimelines: [] };
const getInitialTimelineMock = vi.mocked(getInitialTimeline);
getInitialTimelineMock.mockReturnValue(mockTimeline);
// Render with first room
const { rerender } = renderHook(
({ room, eventId }) =>
useTimelineSync({
mx,
room,
eventId,
}),
{
initialProps: {
room: room1,
eventId: undefined,
},
}
);
// Verify initial timeline was set
expect(getInitialTimelineMock).toHaveBeenCalledWith(room1);
// Clear the mock to track new calls
getInitialTimelineMock.mockClear();
// Change to room2
act(() => {
rerender({ room: room2, eventId: undefined });
});
// Should reset timeline for the new room
expect(getInitialTimelineMock).toHaveBeenCalledWith(room2);
});
it('does not reset timeline when eventId is set during room change', () => {
const room1 = createMockRoom('!room1:example.com');
const room2 = createMockRoom('!room2:example.com');
const mx = createMockClient();
const mockTimeline = { linkedTimelines: [] };
const getInitialTimelineMock = vi.mocked(getInitialTimeline);
getInitialTimelineMock.mockReturnValue(mockTimeline);
// Render with first room
const { rerender } = renderHook(
({ room, eventId }) =>
useTimelineSync({
mx,
room,
eventId,
}),
{
initialProps: {
room: room1,
eventId: undefined,
},
}
);
// Clear the mock to track new calls during room change
getInitialTimelineMock.mockClear();
// Change to room2 WITH eventId set (should NOT reset)
act(() => {
rerender({ room: room2, eventId: '$event123' });
});
// Should NOT reset timeline when eventId is set
expect(getInitialTimelineMock).not.toHaveBeenCalledWith(room2);
});
it('does not reset timeline when room.roomId stays the same', () => {
const room = createMockRoom('!room1:example.com');
const mx = createMockClient();
const mockTimeline = { linkedTimelines: [] };
const getInitialTimelineMock = vi.mocked(getInitialTimeline);
getInitialTimelineMock.mockReturnValue(mockTimeline);
// Render hook
const { rerender } = renderHook(
({ room, eventId }) =>
useTimelineSync({
mx,
room,
eventId,
}),
{
initialProps: {
room,
eventId: undefined,
},
}
);
// Clear the mock to track new calls
getInitialTimelineMock.mockClear();
// Rerender with same room (different prop but same roomId)
const sameRoom = createMockRoom(room.roomId);
act(() => {
rerender({ room: sameRoom, eventId: undefined });
});
// Should NOT reset timeline since roomId is the same
expect(getInitialTimelineMock).not.toHaveBeenCalledWith(sameRoom);
});
});
+115 -3
View File
@@ -40,12 +40,18 @@ function createTimeline(events: unknown[] = [{}]): FakeTimeline {
};
}
function createRoom(events: unknown[] = [{}]): {
function createRoom(
roomId = '!room:test',
events: unknown[] = [{}]
): {
room: FakeRoom;
timelineSet: FakeTimelineSet;
events: unknown[];
} {
const timeline = createTimeline(events);
const timeline = {
...createTimeline(events),
getRoomId: () => roomId,
};
const timelineSet = new EventEmitter() as FakeTimelineSet;
timelineSet.getLiveTimeline = () => timeline;
timelineSet.getTimelineForEvent = () => undefined;
@@ -55,7 +61,7 @@ function createRoom(events: unknown[] = [{}]): {
on: roomEmitter.on.bind(roomEmitter),
removeListener: roomEmitter.removeListener.bind(roomEmitter),
emit: roomEmitter.emit.bind(roomEmitter),
roomId: '!room:test',
roomId,
getUnfilteredTimelineSet: () => timelineSet as never,
getEventReadUpTo: () => null,
getThread: () => null,
@@ -125,4 +131,110 @@ describe('useTimelineSync', () => {
expect(scrollToBottom).toHaveBeenCalledWith('instant');
});
it('resets timeline state when room.roomId changes and eventId is not set', async () => {
const roomOne = createRoom('!room:one');
const roomTwo = createRoom('!room:two');
const scrollToBottom = vi.fn();
const { result, rerender } = renderHook(
({ room, eventId }) =>
useTimelineSync({
room,
mx: { getUserId: () => '@alice:test' } as never,
eventId,
isAtBottom: false,
isAtBottomRef: { current: false },
scrollToBottom,
unreadInfo: undefined,
setUnreadInfo: vi.fn(),
hideReadsRef: { current: false },
readUptoEventIdRef: { current: undefined },
}),
{
initialProps: {
room: roomOne.room as Room,
eventId: undefined as string | undefined,
},
}
);
expect(result.current.timeline.linkedTimelines[0]).toBe(roomOne.timelineSet.getLiveTimeline());
await act(async () => {
rerender({ room: roomTwo.room as Room, eventId: undefined });
await Promise.resolve();
});
expect(result.current.timeline.linkedTimelines[0]).toBe(roomTwo.timelineSet.getLiveTimeline());
});
it('does not reset timeline when eventId is set during a room change', async () => {
const roomOne = createRoom('!room:one');
const roomTwo = createRoom('!room:two');
const scrollToBottom = vi.fn();
const { result, rerender } = renderHook(
({ room, eventId }) =>
useTimelineSync({
room,
mx: { getUserId: () => '@alice:test' } as never,
eventId,
isAtBottom: false,
isAtBottomRef: { current: false },
scrollToBottom,
unreadInfo: undefined,
setUnreadInfo: vi.fn(),
hideReadsRef: { current: false },
readUptoEventIdRef: { current: undefined },
}),
{
initialProps: {
room: roomOne.room as Room,
eventId: undefined as string | undefined,
},
}
);
await act(async () => {
rerender({ room: roomTwo.room as Room, eventId: '$event:one' });
await Promise.resolve();
});
expect(result.current.timeline.linkedTimelines[0]).toBe(roomOne.timelineSet.getLiveTimeline());
});
it('does not reset timeline when the roomId stays the same', async () => {
const roomOne = createRoom('!room:one');
const sameRoomId = createRoom('!room:one');
const scrollToBottom = vi.fn();
const { result, rerender } = renderHook(
({ room }) =>
useTimelineSync({
room,
mx: { getUserId: () => '@alice:test' } as never,
eventId: undefined,
isAtBottom: false,
isAtBottomRef: { current: false },
scrollToBottom,
unreadInfo: undefined,
setUnreadInfo: vi.fn(),
hideReadsRef: { current: false },
readUptoEventIdRef: { current: undefined },
}),
{
initialProps: {
room: roomOne.room as Room,
},
}
);
await act(async () => {
rerender({ room: sameRoomId.room as Room });
await Promise.resolve();
});
expect(result.current.timeline.linkedTimelines[0]).toBe(roomOne.timelineSet.getLiveTimeline());
});
});
+5 -4
View File
@@ -192,12 +192,13 @@ const useTimelinePagination = (
const fetched = countAfter - countBefore;
if (fetched > 0 && fetched < 5) {
const checkTimeline = backwards ? freshLTimelines[0] : freshLTimelines[freshLTimelines.length - 1];
const checkTimeline = backwards
? freshLTimelines[0]
: freshLTimelines[freshLTimelines.length - 1];
const checkDirection = backwards ? Direction.Backward : Direction.Forward;
const stillHasToken =
typeof getLinkedTimelines(checkTimeline)[0]?.getPaginationToken(
checkDirection
) === 'string';
typeof getLinkedTimelines(checkTimeline)[0]?.getPaginationToken(checkDirection) ===
'string';
if (stillHasToken) {
// Release lock so inner paginate can claim it, then mark continuing
// so the finally block below does NOT reset it after inner claims.