diff --git a/src/autocomplete/SpaceProvider.tsx b/src/autocomplete/SpaceProvider.tsx index bef3b573541..3f6bd30e3e6 100644 --- a/src/autocomplete/SpaceProvider.tsx +++ b/src/autocomplete/SpaceProvider.tsx @@ -19,12 +19,13 @@ import React from "react"; import { _t } from "../languageHandler"; import { MatrixClientPeg } from "../MatrixClientPeg"; +import SettingsStore from "../settings/SettingsStore"; import RoomProvider from "./RoomProvider"; export default class SpaceProvider extends RoomProvider { protected getRooms(): Room[] { return MatrixClientPeg.get() - .getVisibleRooms() + .getVisibleRooms(SettingsStore.getValue("feature_dynamic_room_predecessors")) .filter((r) => r.isSpaceRoom()); } diff --git a/test/autocomplete/RoomProvider-test.ts b/test/autocomplete/RoomProvider-test.ts index a812c029c69..69c4af8bda0 100644 --- a/test/autocomplete/RoomProvider-test.ts +++ b/test/autocomplete/RoomProvider-test.ts @@ -19,7 +19,7 @@ import { MatrixClient, Room } from "matrix-js-sdk/src/matrix"; import RoomProvider from "../../src/autocomplete/RoomProvider"; import SettingsStore from "../../src/settings/SettingsStore"; -import { mkRoom, stubClient } from "../test-utils"; +import { mkRoom, mkSpace, stubClient } from "../test-utils"; describe("RoomProvider", () => { it("suggests a room whose alias matches a prefix", async () => { @@ -52,7 +52,8 @@ describe("RoomProvider", () => { const room1 = makeRoom(client, "room1:e.com"); const room2 = makeRoom(client, "room2:e.com"); const other = makeRoom(client, "other:e.com"); - mocked(client.getVisibleRooms).mockReturnValue([room1, room2, other]); + const space = makeSpace(client, "room3:e.com"); + mocked(client.getVisibleRooms).mockReturnValue([room1, room2, other, space]); // When we search for rooms starting with a prefix const roomProvider = new RoomProvider(room1); @@ -121,6 +122,12 @@ describe("RoomProvider", () => { }); }); +function makeSpace(client: MatrixClient, name: string): Room { + const space = mkSpace(client, `!${name}`); + space.getCanonicalAlias.mockReturnValue(`#${name}`); + return space; +} + function makeRoom(client: MatrixClient, name: string): Room { const room = mkRoom(client, `!${name}`); room.getCanonicalAlias.mockReturnValue(`#${name}`); diff --git a/test/autocomplete/SpaceProvider-test.ts b/test/autocomplete/SpaceProvider-test.ts new file mode 100644 index 00000000000..59f93369a66 --- /dev/null +++ b/test/autocomplete/SpaceProvider-test.ts @@ -0,0 +1,135 @@ +/* +Copyright 2023 The Matrix.org Foundation C.I.C. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +import { mocked } from "jest-mock"; +import { MatrixClient, Room } from "matrix-js-sdk/src/matrix"; + +import SpaceProvider from "../../src/autocomplete/SpaceProvider"; +import SettingsStore from "../../src/settings/SettingsStore"; +import { mkRoom, mkSpace, stubClient } from "../test-utils"; + +describe("SpaceProvider", () => { + it("suggests a space whose alias matches a prefix", async () => { + // Given a space + const client = stubClient(); + const space = makeSpace(client, "space:e.com"); + mocked(client.getVisibleRooms).mockReturnValue([space]); + + // When we search for spaces starting with its prefix + const spaceProvider = new SpaceProvider(space); + const completions = await spaceProvider.getCompletions("#sp", { beginning: true, start: 0, end: 3 }); + + // Then we find it + expect(completions).toStrictEqual([ + { + type: "room", + completion: space.getCanonicalAlias(), + completionId: space.roomId, + component: expect.anything(), + href: "https://matrix.to/#/#space:e.com", + range: { start: 0, end: 3 }, + suffix: " ", + }, + ]); + }); + + it("suggests only spaces matching a prefix", async () => { + // Given some spaces with different names + const client = stubClient(); + const space1 = makeSpace(client, "space1:e.com"); + const space2 = makeSpace(client, "space2:e.com"); + const other = makeSpace(client, "other:e.com"); + const room = makeRoom(client, "space3:e.com"); + mocked(client.getVisibleRooms).mockReturnValue([space1, space2, other, room]); + + // When we search for spaces starting with a prefix + const spaceProvider = new SpaceProvider(space1); + const completions = await spaceProvider.getCompletions("#sp", { beginning: true, start: 0, end: 3 }); + + // Then we find the two spaces with that prefix, but not the other one + expect(completions).toStrictEqual([ + { + type: "room", + completion: space1.getCanonicalAlias(), + completionId: space1.roomId, + component: expect.anything(), + href: "https://matrix.to/#/#space1:e.com", + range: { start: 0, end: 3 }, + suffix: " ", + }, + { + type: "room", + completion: space2.getCanonicalAlias(), + completionId: space2.roomId, + component: expect.anything(), + href: "https://matrix.to/#/#space2:e.com", + range: { start: 0, end: 3 }, + suffix: " ", + }, + ]); + }); + + describe("If the feature_dynamic_room_predecessors is not enabled", () => { + beforeEach(() => { + jest.spyOn(SettingsStore, "getValue").mockReturnValue(false); + }); + + it("Passes through the dynamic predecessor setting", async () => { + const client = stubClient(); + const space = makeSpace(client, "space:e.com"); + mocked(client.getVisibleRooms).mockReturnValue([space]); + mocked(client.getVisibleRooms).mockClear(); + + const spaceProvider = new SpaceProvider(space); + await spaceProvider.getCompletions("#ro", { beginning: true, start: 0, end: 3 }); + + expect(client.getVisibleRooms).toHaveBeenCalledWith(false); + }); + }); + + describe("If the feature_dynamic_room_predecessors is enabled", () => { + beforeEach(() => { + // Turn on feature_dynamic_space_predecessors setting + jest.spyOn(SettingsStore, "getValue").mockImplementation( + (settingName) => settingName === "feature_dynamic_room_predecessors", + ); + }); + + it("Passes through the dynamic predecessor setting", async () => { + const client = stubClient(); + const space = makeSpace(client, "space:e.com"); + mocked(client.getVisibleRooms).mockReturnValue([space]); + mocked(client.getVisibleRooms).mockClear(); + + const spaceProvider = new SpaceProvider(space); + await spaceProvider.getCompletions("#ro", { beginning: true, start: 0, end: 3 }); + + expect(client.getVisibleRooms).toHaveBeenCalledWith(true); + }); + }); +}); + +function makeSpace(client: MatrixClient, name: string): Room { + const space = mkSpace(client, `!${name}`); + space.getCanonicalAlias.mockReturnValue(`#${name}`); + return space; +} + +function makeRoom(client: MatrixClient, name: string): Room { + const room = mkRoom(client, `!${name}`); + room.getCanonicalAlias.mockReturnValue(`#${name}`); + return room; +}