Apply strictNullChecks to src/components/views/settings (#10724)

2023-05-05 09:13:50 +01:00
parent a4f0b80692
commit 1f4d857283
11 changed files with 772 additions and 48 deletions
@@ -0,0 +1,187 @@
+/*
+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 React from "react";
+import { fireEvent, render, screen, within } from "@testing-library/react";
+import { mocked } from "jest-mock";
+
+import { flushPromises, getMockClientWithEventEmitter, mockClientMethodsUser } from "../../../test-utils";
+import SecureBackupPanel from "../../../../src/components/views/settings/SecureBackupPanel";
+import { accessSecretStorage } from "../../../../src/SecurityManager";
+
+jest.mock("../../../../src/SecurityManager", () => ({
+    accessSecretStorage: jest.fn(),
+}));
+
+describe("<SecureBackupPanel />", () => {
+    const userId = "@alice:server.org";
+    const client = getMockClientWithEventEmitter({
+        ...mockClientMethodsUser(userId),
+        checkKeyBackup: jest.fn(),
+        isKeyBackupKeyStored: jest.fn(),
+        isSecretStorageReady: jest.fn(),
+        getKeyBackupEnabled: jest.fn(),
+        getKeyBackupVersion: jest.fn().mockReturnValue("1"),
+        isKeyBackupTrusted: jest.fn().mockResolvedValue(true),
+        getClientWellKnown: jest.fn(),
+        deleteKeyBackupVersion: jest.fn(),
+    });
+    // @ts-ignore allow it
+    client.crypto = {
+        secretStorage: { hasKey: jest.fn() },
+        getSessionBackupPrivateKey: jest.fn(),
+    } as unknown as Crypto;
+
+    const getComponent = () => render(<SecureBackupPanel />);
+
+    beforeEach(() => {
+        client.checkKeyBackup.mockResolvedValue({
+            backupInfo: {
+                version: "1",
+                algorithm: "test",
+                auth_data: {
+                    public_key: "1234",
+                },
+            },
+            trustInfo: {
+                usable: false,
+                sigs: [],
+            },
+        });
+
+        mocked(client.crypto!.secretStorage.hasKey).mockClear().mockResolvedValue(false);
+        client.deleteKeyBackupVersion.mockClear().mockResolvedValue();
+        client.getKeyBackupVersion.mockClear();
+        client.isKeyBackupTrusted.mockClear();
+
+        mocked(accessSecretStorage).mockClear().mockResolvedValue();
+    });
+
+    it("displays a loader while checking keybackup", async () => {
+        getComponent();
+        expect(screen.getByRole("progressbar")).toBeInTheDocument();
+        await flushPromises();
+        expect(screen.queryByRole("progressbar")).not.toBeInTheDocument();
+    });
+
+    it("handles null backup info", async () => {
+        // checkKeyBackup can fail and return null for various reasons
+        client.checkKeyBackup.mockResolvedValue(null);
+        getComponent();
+        // flush checkKeyBackup promise
+        await flushPromises();
+
+        // no backup info
+        expect(screen.getByText("Back up your keys before signing out to avoid losing them.")).toBeInTheDocument();
+    });
+
+    it("suggests connecting session to key backup when backup exists", async () => {
+        const { container } = getComponent();
+        // flush checkKeyBackup promise
+        await flushPromises();
+
+        expect(container).toMatchSnapshot();
+    });
+
+    it("displays when session is connected to key backup", async () => {
+        client.getKeyBackupEnabled.mockReturnValue(true);
+        getComponent();
+        // flush checkKeyBackup promise
+        await flushPromises();
+
+        expect(screen.getByText("✅ This session is backing up your keys.")).toBeInTheDocument();
+    });
+
+    it("asks for confirmation before deleting a backup", async () => {
+        getComponent();
+        // flush checkKeyBackup promise
+        await flushPromises();
+
+        fireEvent.click(screen.getByText("Delete Backup"));
+
+        const dialog = await screen.findByRole("dialog");
+
+        expect(
+            within(dialog).getByText(
+                "Are you sure? You will lose your encrypted messages if your keys are not backed up properly.",
+            ),
+        ).toBeInTheDocument();
+
+        fireEvent.click(within(dialog).getByText("Cancel"));
+
+        expect(client.deleteKeyBackupVersion).not.toHaveBeenCalled();
+    });
+
+    it("deletes backup after confirmation", async () => {
+        client.checkKeyBackup
+            .mockResolvedValueOnce({
+                backupInfo: {
+                    version: "1",
+                    algorithm: "test",
+                    auth_data: {
+                        public_key: "1234",
+                    },
+                },
+                trustInfo: {
+                    usable: false,
+                    sigs: [],
+                },
+            })
+            .mockResolvedValue(null);
+        getComponent();
+        // flush checkKeyBackup promise
+        await flushPromises();
+
+        fireEvent.click(screen.getByText("Delete Backup"));
+
+        const dialog = await screen.findByRole("dialog");
+
+        expect(
+            within(dialog).getByText(
+                "Are you sure? You will lose your encrypted messages if your keys are not backed up properly.",
+            ),
+        ).toBeInTheDocument();
+
+        fireEvent.click(within(dialog).getByTestId("dialog-primary-button"));
+
+        expect(client.deleteKeyBackupVersion).toHaveBeenCalledWith("1");
+
+        // delete request
+        await flushPromises();
+        // refresh backup info
+        await flushPromises();
+    });
+
+    it("resets secret storage", async () => {
+        mocked(client.crypto!.secretStorage.hasKey).mockClear().mockResolvedValue(true);
+        getComponent();
+        // flush checkKeyBackup promise
+        await flushPromises();
+
+        client.getKeyBackupVersion.mockClear();
+        client.isKeyBackupTrusted.mockClear();
+
+        fireEvent.click(screen.getByText("Reset"));
+
+        // enter loading state
+        expect(accessSecretStorage).toHaveBeenCalled();
+        await flushPromises();
+
+        // backup status refreshed
+        expect(client.getKeyBackupVersion).toHaveBeenCalled();
+        expect(client.isKeyBackupTrusted).toHaveBeenCalled();
+    });
+});