nikrozman/element-web
1
0
Fork 0
Code Issues Actions 4 Packages Projects Releases Wiki Activity

MSC4380: Invite blocking (#31268)

Browse Source 
* Initial implementation of MSC4380

* fix lint

* Update InviteRulesAccountSetting-test

* add some docs

* `block_all` -> `default_action`

* Add a unit test for BlockInvitesConfigController
This commit is contained in:
Richard van der Hoff
2025-11-27 18:42:58 +00:00
committed by GitHub
parent 5869c519ed
commit 1c684489da
7 changed files with 294 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
test/unit-tests/components/views/settings/tabs/user/InviteRulesAccountSetting-test.tsx
View File

@@ -13,16 +13,25 @@ import SettingsStore from "../../../../../../../src/settings/SettingsStore";
import { type ComputedInviteConfig } from "../../../../../../../src/@types/invite-rules";
import { SettingLevel } from "../../../../../../../src/settings/SettingLevel";
function mockSetting(mediaPreviews: ComputedInviteConfig, supported = true) {
function mockSetting(inviteRules: ComputedInviteConfig, blockInvites: boolean) {
jest.spyOn(SettingsStore, "getValue").mockImplementation((settingName) => {
if (settingName === "inviteRules") {
return mediaPreviews;
return inviteRules;
}
if (settingName === "blockInvites") {
return blockInvites;
}
throw Error(`Unexpected setting ${settingName}`);
});
}
function mockDisabledMessage(msc4155supported: boolean, msc4380Supported: boolean) {
jest.spyOn(SettingsStore, "disabledMessage").mockImplementation((settingName) => {
if (settingName === "inviteRules") {
return supported ? undefined : "test-not-supported";
return msc4155supported ? undefined : "test-not-supported";
}
if (settingName === "blockInvites") {
return msc4380Supported ? undefined : "test-not-supported";
}
throw Error(`Unexpected setting ${settingName}`);
});
@@ -33,44 +42,103 @@ describe("InviteRulesAccountSetting", () => {
jest.restoreAllMocks();
});
it("does not render if not supported", async () => {
it("does not render if neither MSC4155 nor MSC4380 are supported", async () => {
mockSetting({ allBlocked: false }, false);
mockDisabledMessage(false, false);
const { findByText, findByLabelText } = render(<InviteRulesAccountSetting />);
const input = await findByLabelText("Allow users to invite you to rooms");
await userEvent.hover(input);
const result = await findByText("test-not-supported");
expect(result).toBeInTheDocument();
});
it("renders correct state when invites are not blocked", async () => {
mockSetting({ allBlocked: false }, true);
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
expect(result).toBeChecked();
});
it("renders correct state when invites are blocked", async () => {
mockSetting({ allBlocked: true }, true);
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
expect(result).not.toBeChecked();
});
it("handles disabling all invites", async () => {
mockSetting({ allBlocked: false }, true);
jest.spyOn(SettingsStore, "setValue").mockImplementation();
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
await userEvent.click(result);
expect(SettingsStore.setValue).toHaveBeenCalledWith("inviteRules", null, SettingLevel.ACCOUNT, {
allBlocked: true,
describe("when MSC4155 is supported", () => {
beforeEach(() => {
mockDisabledMessage(true, false);
});
it("renders correct state when invites are not blocked", async () => {
mockSetting({ allBlocked: false }, false);
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
expect(result).toBeChecked();
});
it("renders correct state when invites are blocked", async () => {
mockSetting({ allBlocked: true }, false);
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
expect(result).not.toBeChecked();
});
it("handles disabling all invites", async () => {
mockSetting({ allBlocked: false }, false);
jest.spyOn(SettingsStore, "setValue").mockImplementation();
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
await userEvent.click(result);
expect(SettingsStore.setValue).toHaveBeenCalledTimes(1);
expect(SettingsStore.setValue).toHaveBeenCalledWith("inviteRules", null, SettingLevel.ACCOUNT, {
allBlocked: true,
});
});
it("handles enabling all invites", async () => {
mockSetting({ allBlocked: true }, true);
jest.spyOn(SettingsStore, "setValue").mockImplementation();
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
await userEvent.click(result);
// Should clear both MSC4155 and MSC4380 settings
expect(SettingsStore.setValue).toHaveBeenCalledTimes(2);
expect(SettingsStore.setValue).toHaveBeenCalledWith("inviteRules", null, SettingLevel.ACCOUNT, {
allBlocked: false,
});
expect(SettingsStore.setValue).toHaveBeenCalledWith("blockInvites", null, SettingLevel.ACCOUNT, false);
});
});
it("handles enabling all invites", async () => {
mockSetting({ allBlocked: true }, true);
jest.spyOn(SettingsStore, "setValue").mockImplementation();
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
await userEvent.click(result);
expect(SettingsStore.setValue).toHaveBeenCalledWith("inviteRules", null, SettingLevel.ACCOUNT, {
allBlocked: false,
describe("when MSC4380 is supported", () => {
beforeEach(() => {
mockDisabledMessage(false, true);
});
it("renders correct state when invites are not blocked", async () => {
mockSetting({ allBlocked: false }, false);
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
expect(result).toBeChecked();
});
it("renders correct state when invites are blocked", async () => {
mockSetting({ allBlocked: false }, true);
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
expect(result).not.toBeChecked();
});
it("handles disabling all invites", async () => {
mockSetting({ allBlocked: false }, false);
jest.spyOn(SettingsStore, "setValue").mockImplementation();
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
await userEvent.click(result);
expect(SettingsStore.setValue).toHaveBeenCalledTimes(1);
expect(SettingsStore.setValue).toHaveBeenCalledWith("blockInvites", null, SettingLevel.ACCOUNT, true);
});
it("handles enabling all invites", async () => {
mockSetting({ allBlocked: true }, true);
jest.spyOn(SettingsStore, "setValue").mockImplementation();
const { findByLabelText } = render(<InviteRulesAccountSetting />);
const result = await findByLabelText("Allow users to invite you to rooms");
await userEvent.click(result);
// Should clear both MSC4155 and MSC4380 settings
expect(SettingsStore.setValue).toHaveBeenCalledTimes(2);
expect(SettingsStore.setValue).toHaveBeenCalledWith("inviteRules", null, SettingLevel.ACCOUNT, {
allBlocked: false,
});
expect(SettingsStore.setValue).toHaveBeenCalledWith("blockInvites", null, SettingLevel.ACCOUNT, false);
});
});
});

100
test/unit-tests/settings/controllers/BlockInvitesConfigController-test.ts Normal file
View File

@@ -0,0 +1,100 @@
/*
Copyright 2024 New Vector Ltd.
Copyright 2023 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
Please see LICENSE files in the repository root for full details.
*/
import { type MatrixClient, MatrixEvent } from "matrix-js-sdk/src/matrix";
import { mocked } from "jest-mock";
import { SETTINGS } from "../../../../src/settings/Settings";
import { stubClient } from "../../../test-utils";
import MatrixClientBackedController from "../../../../src/settings/controllers/MatrixClientBackedController";
import { SettingLevel } from "../../../../src/settings/SettingLevel.ts";
describe("BlockInvitesConfigController", () => {
describe("When server does not support MSC4380", () => {
let cli: MatrixClient;
beforeEach(() => {
cli = stubClient();
cli.doesServerSupportUnstableFeature = jest.fn(async () => false);
MatrixClientBackedController.matrixClient = cli;
});
test("settingDisabled() should give a message", () => {
const controller = SETTINGS.blockInvites.controller!;
expect(controller.settingDisabled).toEqual("Your server does not implement this feature.");
});
});
describe("When server supports MSC4380", () => {
let cli: MatrixClient;
beforeEach(async () => {
cli = stubClient();
cli.doesServerSupportUnstableFeature = jest.fn(async (feature) => {
return feature == "org.matrix.msc4380";
});
MatrixClientBackedController.matrixClient = cli;
});
test("settingDisabled() should be false", () => {
const controller = SETTINGS.blockInvites.controller!;
expect(controller.settingDisabled).toEqual(false);
});
describe("getValueOverride()", () => {
it("should return true when invites are blocked", async () => {
const controller = SETTINGS.blockInvites.controller!;
mockAccountData(cli, { default_action: "block" });
expect(controller.getValueOverride(SettingLevel.DEVICE, null, null, null)).toEqual(true);
});
it("should return false when invites are not blocked", async () => {
const controller = SETTINGS.blockInvites.controller!;
mockAccountData(cli, { default_action: {} });
expect(controller.getValueOverride(SettingLevel.DEVICE, null, null, null)).toEqual(false);
});
});
describe("beforeChange()", () => {
it("should set the account data when the value is enabled", async () => {
const controller = SETTINGS.blockInvites.controller!;
await controller.beforeChange(SettingLevel.DEVICE, null, true);
expect(cli.setAccountData).toHaveBeenCalledTimes(1);
expect(cli.setAccountData).toHaveBeenCalledWith("org.matrix.msc4380.invite_permission_config", {
default_action: "block",
});
});
it("should set the account data when the value is disabled", async () => {
const controller = SETTINGS.blockInvites.controller!;
await controller.beforeChange(SettingLevel.DEVICE, null, false);
expect(cli.setAccountData).toHaveBeenCalledTimes(1);
expect(cli.setAccountData).toHaveBeenCalledWith("org.matrix.msc4380.invite_permission_config", {
default_action: "allow",
});
});
});
});
});
/**
* Add a mock implementation for {@link MatrixClient.getAccountData} which will return the given data
* in respomsnse to any request for `org.matrix.msc4380.invite_permission_config`.
*/
function mockAccountData(cli: MatrixClient, mockAccountData: object) {
mocked(cli.getAccountData).mockImplementation((eventType) => {
if (eventType == "org.matrix.msc4380.invite_permission_config") {
return new MatrixEvent({
type: "org.matrix.msc4380.invite_permission_config",
content: mockAccountData,
});
} else {
return undefined;
}
});
}