Absorb the matrix-react-sdk repository (#28192)

Co-authored-by: github-merge-queue <118344674+github-merge-queue@users.noreply.github.com>
Co-authored-by: github-merge-queue <github-merge-queue@users.noreply.github.com>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Florian Duros <florian.duros@ormaz.fr>
Co-authored-by: Kim Brose <kim.brose@nordeck.net>
Co-authored-by: Florian Duros <florianduros@element.io>
Co-authored-by: R Midhun Suresh <hi@midhun.dev>
Co-authored-by: dbkr <986903+dbkr@users.noreply.github.com>
Co-authored-by: ElementRobot <releases@riot.im>
Co-authored-by: dbkr <dbkr@users.noreply.github.com>
Co-authored-by: David Baker <dbkr@users.noreply.github.com>
Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>
Co-authored-by: Richard van der Hoff <1389908+richvdh@users.noreply.github.com>
Co-authored-by: David Langley <davidl@element.io>
Co-authored-by: Michael Weimann <michaelw@matrix.org>
Co-authored-by: Timshel <Timshel@users.noreply.github.com>
Co-authored-by: Sahil Silare <32628578+sahil9001@users.noreply.github.com>
Co-authored-by: Will Hunt <will@half-shot.uk>
Co-authored-by: Hubert Chathi <hubert@uhoreg.ca>
Co-authored-by: Andrew Ferrazzutti <andrewf@element.io>
Co-authored-by: Robin <robin@robin.town>
Co-authored-by: Tulir Asokan <tulir@maunium.net>
This commit is contained in:
Michael Telatynski
2024-10-16 13:31:55 +01:00
committed by GitHub
parent 2b99496025
commit c05c429803
3280 changed files with 586617 additions and 905 deletions

View File

@@ -0,0 +1,275 @@
/*
Copyright 2024 New Vector Ltd.
Copyright 2022 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
import { mocked } from "jest-mock";
import { EventType, MatrixClient, MatrixEvent, MsgType, RelationType, Room } from "matrix-js-sdk/src/matrix";
import {
JSONEventFactory,
MessageEventFactory,
pickFactory,
RoomCreateEventFactory,
TextualEventFactory,
} from "../../../src/events/EventTileFactory";
import SettingsStore from "../../../src/settings/SettingsStore";
import { VoiceBroadcastChunkEventType, VoiceBroadcastInfoState } from "../../../src/voice-broadcast";
import { createTestClient, mkEvent } from "../../test-utils";
import { mkVoiceBroadcastInfoStateEvent } from "../voice-broadcast/utils/test-utils";
const roomId = "!room:example.com";
describe("pickFactory", () => {
let client: MatrixClient;
let room: Room;
let createEventWithPredecessor: MatrixEvent;
let createEventWithoutPredecessor: MatrixEvent;
let dynamicPredecessorEvent: MatrixEvent;
let voiceBroadcastStartedEvent: MatrixEvent;
let voiceBroadcastStoppedEvent: MatrixEvent;
let voiceBroadcastChunkEvent: MatrixEvent;
let utdEvent: MatrixEvent;
let utdBroadcastChunkEvent: MatrixEvent;
let audioMessageEvent: MatrixEvent;
beforeAll(() => {
client = createTestClient();
room = new Room(roomId, client, client.getSafeUserId());
mocked(client.getRoom).mockImplementation((getRoomId: string): Room | null => {
if (getRoomId === room.roomId) return room;
return null;
});
createEventWithoutPredecessor = mkEvent({
event: true,
type: EventType.RoomCreate,
user: client.getUserId()!,
room: roomId,
content: {
creator: client.getUserId()!,
room_version: "9",
},
});
createEventWithPredecessor = mkEvent({
event: true,
type: EventType.RoomCreate,
user: client.getUserId()!,
room: roomId,
content: {
creator: client.getUserId()!,
room_version: "9",
predecessor: {
room_id: "roomid1",
event_id: null,
},
},
});
dynamicPredecessorEvent = mkEvent({
event: true,
type: EventType.RoomPredecessor,
user: client.getUserId()!,
room: roomId,
skey: "",
content: {
predecessor_room_id: "roomid2",
last_known_event_id: null,
},
});
voiceBroadcastStartedEvent = mkVoiceBroadcastInfoStateEvent(
roomId,
VoiceBroadcastInfoState.Started,
client.getUserId()!,
client.deviceId!,
);
room.addLiveEvents([voiceBroadcastStartedEvent]);
voiceBroadcastStoppedEvent = mkVoiceBroadcastInfoStateEvent(
roomId,
VoiceBroadcastInfoState.Stopped,
client.getUserId()!,
client.deviceId!,
);
voiceBroadcastChunkEvent = mkEvent({
event: true,
type: EventType.RoomMessage,
user: client.getUserId()!,
room: roomId,
content: {
msgtype: MsgType.Audio,
[VoiceBroadcastChunkEventType]: {},
},
});
audioMessageEvent = mkEvent({
event: true,
type: EventType.RoomMessage,
user: client.getUserId()!,
room: roomId,
content: {
msgtype: MsgType.Audio,
},
});
utdEvent = mkEvent({
event: true,
type: EventType.RoomMessage,
user: client.getUserId()!,
room: roomId,
content: {
msgtype: "m.bad.encrypted",
},
});
utdBroadcastChunkEvent = mkEvent({
event: true,
type: EventType.RoomMessage,
user: client.getUserId()!,
room: roomId,
content: {
"msgtype": "m.bad.encrypted",
"m.relates_to": {
rel_type: RelationType.Reference,
event_id: voiceBroadcastStartedEvent.getId(),
},
},
});
jest.spyOn(utdBroadcastChunkEvent, "isDecryptionFailure").mockReturnValue(true);
});
it("should return JSONEventFactory for a no-op m.room.power_levels event", () => {
const event = new MatrixEvent({
type: EventType.RoomPowerLevels,
state_key: "",
content: {},
sender: client.getUserId()!,
room_id: roomId,
});
expect(pickFactory(event, client, true)).toBe(JSONEventFactory);
});
describe("when showing hidden events", () => {
it("should return a JSONEventFactory for a voice broadcast event", () => {
expect(pickFactory(voiceBroadcastChunkEvent, client, true)).toBe(JSONEventFactory);
});
it("should return a JSONEventFactory for a room create event without predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithoutPredecessor.getStateKey()!, createEventWithoutPredecessor]]),
);
room.currentState.events.set(EventType.RoomPredecessor, new Map());
expect(pickFactory(createEventWithoutPredecessor, client, true)).toBe(JSONEventFactory);
});
it("should return a TextualEventFactory for a voice broadcast stopped event", () => {
expect(pickFactory(voiceBroadcastStoppedEvent, client, true)).toBe(TextualEventFactory);
});
it("should return a MessageEventFactory for an audio message event", () => {
expect(pickFactory(audioMessageEvent, client, true)).toBe(MessageEventFactory);
});
it("should return a MessageEventFactory for a UTD broadcast chunk event", () => {
expect(pickFactory(utdBroadcastChunkEvent, client, true)).toBe(MessageEventFactory);
});
});
describe("when not showing hidden events", () => {
describe("without dynamic predecessor support", () => {
beforeEach(() => {
jest.spyOn(SettingsStore, "getValue").mockReset();
});
it("should return undefined for a room without predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithoutPredecessor.getStateKey()!, createEventWithoutPredecessor]]),
);
room.currentState.events.set(EventType.RoomPredecessor, new Map());
expect(pickFactory(createEventWithoutPredecessor, client, false)).toBeUndefined();
});
it("should return a RoomCreateFactory for a room with fixed predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithPredecessor.getStateKey()!, createEventWithPredecessor]]),
);
room.currentState.events.set(EventType.RoomPredecessor, new Map());
expect(pickFactory(createEventWithPredecessor, client, false)).toBe(RoomCreateEventFactory);
});
it("should return undefined for a room with dynamic predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithoutPredecessor.getStateKey()!, createEventWithoutPredecessor]]),
);
room.currentState.events.set(
EventType.RoomPredecessor,
new Map([[dynamicPredecessorEvent.getStateKey()!, dynamicPredecessorEvent]]),
);
expect(pickFactory(createEventWithoutPredecessor, client, false)).toBeUndefined();
});
});
describe("with dynamic predecessor support", () => {
beforeEach(() => {
jest.spyOn(SettingsStore, "getValue")
.mockReset()
.mockImplementation((settingName) => settingName === "feature_dynamic_room_predecessors");
});
it("should return undefined for a room without predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithoutPredecessor.getStateKey()!, createEventWithoutPredecessor]]),
);
room.currentState.events.set(EventType.RoomPredecessor, new Map());
expect(pickFactory(createEventWithoutPredecessor, client, false)).toBeUndefined();
});
it("should return a RoomCreateFactory for a room with fixed predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithPredecessor.getStateKey()!, createEventWithPredecessor]]),
);
room.currentState.events.set(EventType.RoomPredecessor, new Map());
expect(pickFactory(createEventWithPredecessor, client, false)).toBe(RoomCreateEventFactory);
});
it("should return a RoomCreateFactory for a room with dynamic predecessor", () => {
room.currentState.events.set(
EventType.RoomCreate,
new Map([[createEventWithoutPredecessor.getStateKey()!, createEventWithoutPredecessor]]),
);
room.currentState.events.set(
EventType.RoomPredecessor,
new Map([[dynamicPredecessorEvent.getStateKey()!, dynamicPredecessorEvent]]),
);
expect(pickFactory(createEventWithoutPredecessor, client, false)).toBe(RoomCreateEventFactory);
});
});
it("should return undefined for a voice broadcast event", () => {
expect(pickFactory(voiceBroadcastChunkEvent, client, false)).toBeUndefined();
});
it("should return a TextualEventFactory for a voice broadcast stopped event", () => {
expect(pickFactory(voiceBroadcastStoppedEvent, client, false)).toBe(TextualEventFactory);
});
it("should return a MessageEventFactory for an audio message event", () => {
expect(pickFactory(audioMessageEvent, client, false)).toBe(MessageEventFactory);
});
it("should return a MessageEventFactory for a UTD event", () => {
expect(pickFactory(utdEvent, client, false)).toBe(MessageEventFactory);
});
it("should return undefined for a UTD broadcast chunk event", () => {
expect(pickFactory(utdBroadcastChunkEvent, client, false)).toBeUndefined();
});
});
});

View File

@@ -0,0 +1,188 @@
/*
Copyright 2024 New Vector Ltd.
Copyright 2022 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
import { mocked } from "jest-mock";
import { EventType, MatrixClient, MatrixEvent, MatrixEventEvent, RelationType, Room } from "matrix-js-sdk/src/matrix";
import { RelationsHelper, RelationsHelperEvent } from "../../../src/events/RelationsHelper";
import { mkEvent, stubClient } from "../../test-utils";
describe("RelationsHelper", () => {
const roomId = "!room:example.com";
let event: MatrixEvent;
let relatedEvent1: MatrixEvent;
let relatedEvent2: MatrixEvent;
let relatedEvent3: MatrixEvent;
let room: Room;
let client: MatrixClient;
let relationsHelper: RelationsHelper;
let onAdd: (event: MatrixEvent) => void;
beforeEach(() => {
client = stubClient();
mocked(client.relations).mockClear();
room = new Room(roomId, client, client.getSafeUserId());
mocked(client.getRoom).mockImplementation((getRoomId?: string): Room | null => {
if (getRoomId === roomId) return room;
return null;
});
event = mkEvent({
event: true,
type: EventType.RoomMessage,
room: roomId,
user: client.getSafeUserId(),
content: {},
});
relatedEvent1 = mkEvent({
event: true,
type: EventType.RoomMessage,
room: roomId,
user: client.getSafeUserId(),
content: {
["m.relates_to"]: {
rel_type: RelationType.Reference,
event_id: event.getId(),
},
},
});
relatedEvent2 = mkEvent({
event: true,
type: EventType.RoomMessage,
room: roomId,
user: client.getSafeUserId(),
content: {
["m.relates_to"]: {
rel_type: RelationType.Reference,
event_id: event.getId(),
},
},
});
relatedEvent3 = mkEvent({
event: true,
type: EventType.RoomMessage,
room: roomId,
user: client.getSafeUserId(),
content: {
["m.relates_to"]: {
rel_type: RelationType.Reference,
event_id: event.getId(),
},
},
});
onAdd = jest.fn();
});
afterEach(() => {
relationsHelper?.destroy();
});
describe("when there is an event without ID", () => {
it("should raise an error", () => {
jest.spyOn(event, "getId").mockReturnValue(undefined);
expect(() => {
new RelationsHelper(event, RelationType.Reference, EventType.RoomMessage, client);
}).toThrow("unable to create RelationsHelper: missing event ID");
});
});
describe("when there is an event without room ID", () => {
it("should raise an error", () => {
jest.spyOn(event, "getRoomId").mockReturnValue(undefined);
expect(() => {
new RelationsHelper(event, RelationType.Reference, EventType.RoomMessage, client);
}).toThrow("unable to create RelationsHelper: missing room ID");
});
});
describe("when there is an event without relations", () => {
beforeEach(() => {
relationsHelper = new RelationsHelper(event, RelationType.Reference, EventType.RoomMessage, client);
relationsHelper.on(RelationsHelperEvent.Add, onAdd);
});
describe("emitCurrent", () => {
beforeEach(() => {
relationsHelper.emitCurrent();
});
it("should not emit any event", () => {
expect(onAdd).not.toHaveBeenCalled();
});
});
describe("and a new event appears", () => {
beforeEach(() => {
room.relations.aggregateChildEvent(relatedEvent2);
event.emit(MatrixEventEvent.RelationsCreated, RelationType.Reference, EventType.RoomMessage);
});
it("should emit the new event", () => {
expect(onAdd).toHaveBeenCalledWith(relatedEvent2);
});
});
});
describe("when there is an event with two pages server side relations", () => {
beforeEach(() => {
mocked(client.relations)
.mockResolvedValueOnce({
events: [relatedEvent1, relatedEvent2],
nextBatch: "next",
})
.mockResolvedValueOnce({
events: [relatedEvent3],
nextBatch: null,
});
relationsHelper = new RelationsHelper(event, RelationType.Reference, EventType.RoomMessage, client);
relationsHelper.on(RelationsHelperEvent.Add, onAdd);
});
describe("emitFetchCurrent", () => {
beforeEach(async () => {
await relationsHelper.emitFetchCurrent();
});
it("should emit the server side events", () => {
expect(onAdd).toHaveBeenCalledWith(relatedEvent1);
expect(onAdd).toHaveBeenCalledWith(relatedEvent2);
expect(onAdd).toHaveBeenCalledWith(relatedEvent3);
});
});
});
describe("when there is an event with relations", () => {
beforeEach(() => {
room.relations.aggregateChildEvent(relatedEvent1);
relationsHelper = new RelationsHelper(event, RelationType.Reference, EventType.RoomMessage, client);
relationsHelper.on(RelationsHelperEvent.Add, onAdd);
});
describe("emitCurrent", () => {
beforeEach(() => {
relationsHelper.emitCurrent();
});
it("should emit the related event", () => {
expect(onAdd).toHaveBeenCalledWith(relatedEvent1);
});
});
describe("and a new event appears", () => {
beforeEach(() => {
room.relations.aggregateChildEvent(relatedEvent2);
event.emit(MatrixEventEvent.RelationsCreated, RelationType.Reference, EventType.RoomMessage);
});
it("should emit the new event", () => {
expect(onAdd).toHaveBeenCalledWith(relatedEvent2);
});
});
});
});

View File

@@ -0,0 +1,75 @@
/*
Copyright 2024 New Vector Ltd.
Copyright 2022 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
import { EventType, MatrixEvent, MsgType } from "matrix-js-sdk/src/matrix";
import { getForwardableEvent } from "../../../../src/events";
import {
getMockClientWithEventEmitter,
makeBeaconEvent,
makeBeaconInfoEvent,
makePollStartEvent,
makeRoomWithBeacons,
} from "../../../test-utils";
describe("getForwardableEvent()", () => {
const userId = "@alice:server.org";
const roomId = "!room:server.org";
const client = getMockClientWithEventEmitter({
getRoom: jest.fn(),
});
it("returns the event for a room message", () => {
const alicesMessageEvent = new MatrixEvent({
type: EventType.RoomMessage,
sender: userId,
room_id: roomId,
content: {
msgtype: MsgType.Text,
body: "Hello",
},
});
expect(getForwardableEvent(alicesMessageEvent, client)).toBe(alicesMessageEvent);
});
it("returns null for a poll start event", () => {
const pollStartEvent = makePollStartEvent("test?", userId);
expect(getForwardableEvent(pollStartEvent, client)).toBe(null);
});
describe("beacons", () => {
it("returns null for a beacon that is not live", () => {
const notLiveBeacon = makeBeaconInfoEvent(userId, roomId, { isLive: false });
makeRoomWithBeacons(roomId, client, [notLiveBeacon]);
expect(getForwardableEvent(notLiveBeacon, client)).toBe(null);
});
it("returns null for a live beacon that does not have a location", () => {
const liveBeacon = makeBeaconInfoEvent(userId, roomId, { isLive: true });
makeRoomWithBeacons(roomId, client, [liveBeacon]);
expect(getForwardableEvent(liveBeacon, client)).toBe(null);
});
it("returns the latest location event for a live beacon with location", () => {
const liveBeacon = makeBeaconInfoEvent(userId, roomId, { isLive: true }, "id");
const locationEvent = makeBeaconEvent(userId, {
beaconInfoId: liveBeacon.getId(),
geoUri: "geo:52,42",
// make sure its in live period
timestamp: Date.now() + 1,
});
makeRoomWithBeacons(roomId, client, [liveBeacon], [locationEvent]);
expect(getForwardableEvent(liveBeacon, client)).toBe(locationEvent);
});
});
});

View File

@@ -0,0 +1,75 @@
/*
Copyright 2024 New Vector Ltd.
Copyright 2022 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
import { EventType, MatrixEvent, MsgType } from "matrix-js-sdk/src/matrix";
import { getShareableLocationEvent } from "../../../../src/events";
import {
getMockClientWithEventEmitter,
makeBeaconEvent,
makeBeaconInfoEvent,
makeLocationEvent,
makeRoomWithBeacons,
} from "../../../test-utils";
describe("getShareableLocationEvent()", () => {
const userId = "@alice:server.org";
const roomId = "!room:server.org";
const client = getMockClientWithEventEmitter({
getRoom: jest.fn(),
});
it("returns null for a non-location event", () => {
const alicesMessageEvent = new MatrixEvent({
type: EventType.RoomMessage,
sender: userId,
room_id: roomId,
content: {
msgtype: MsgType.Text,
body: "Hello",
},
});
expect(getShareableLocationEvent(alicesMessageEvent, client)).toBe(null);
});
it("returns the event for a location event", () => {
const locationEvent = makeLocationEvent("geo:52,42");
expect(getShareableLocationEvent(locationEvent, client)).toBe(locationEvent);
});
describe("beacons", () => {
it("returns null for a beacon that is not live", () => {
const notLiveBeacon = makeBeaconInfoEvent(userId, roomId, { isLive: false });
makeRoomWithBeacons(roomId, client, [notLiveBeacon]);
expect(getShareableLocationEvent(notLiveBeacon, client)).toBe(null);
});
it("returns null for a live beacon that does not have a location", () => {
const liveBeacon = makeBeaconInfoEvent(userId, roomId, { isLive: true });
makeRoomWithBeacons(roomId, client, [liveBeacon]);
expect(getShareableLocationEvent(liveBeacon, client)).toBe(null);
});
it("returns the latest location event for a live beacon with location", () => {
const liveBeacon = makeBeaconInfoEvent(userId, roomId, { isLive: true }, "id");
const locationEvent = makeBeaconEvent(userId, {
beaconInfoId: liveBeacon.getId(),
geoUri: "geo:52,42",
// make sure its in live period
timestamp: Date.now() + 1,
});
makeRoomWithBeacons(roomId, client, [liveBeacon], [locationEvent]);
expect(getShareableLocationEvent(liveBeacon, client)).toBe(locationEvent);
});
});
});