test: tests for infrastructure/electron in main

Signed-off-by: Kristóf Marussy <kristof@marussy.com>

4 files changed, 365 insertions, 24 deletions

diff --git a/.eslintrc.cjs b/.eslintrc.cjs
index 289d374..3d944e4 100644
--- a/.eslintrc.cjs
+++ b/.eslintrc.cjs
@@ -85,7 +85,12 @@ module.exports = {
       files: ['**/stores/**/*.ts'],
       rules: {
         // In a mobx-state-tree action, we assign to the properties of `self` to update the store.
-        'no-param-reassign': 'off',
+        'no-param-reassign': [
+          'error',
+          {
+            props: false,
+          },
+        ],
         // mobx-state-tree uses empty interfaces to speed up typechecking.
         '@typescript-eslint/no-empty-interface': 'off',
       },
diff --git a/packages/main/src/infrastructure/electron/RendererBridge.ts b/packages/main/src/infrastructure/electron/RendererBridge.ts
index 3f9b512..097580a 100644
--- a/packages/main/src/infrastructure/electron/RendererBridge.ts
+++ b/packages/main/src/infrastructure/electron/RendererBridge.ts
@@ -22,16 +22,12 @@ import type { SharedStoreSnapshotOut } from '@sophie/shared';
 import {
   addMiddleware,
   getSnapshot,
-  IJsonPatch,
-  IMiddlewareEvent,
+  type IJsonPatch,
   onPatch,
 } from 'mobx-state-tree';
 
 import type MainStore from '../../stores/MainStore';
 import Disposer from '../../utils/Disposer';
-import getLogger from '../../utils/getLogger';
-
-const log = getLogger('RendererBridge');
 
 export type PatchListener = (patch: IJsonPatch[]) => void;
 
@@ -45,8 +41,6 @@ export default class RendererBridge {
   constructor(store: MainStore, listener: PatchListener) {
     this.snapshot = getSnapshot(store.shared);
 
-    // The call for the currently pending action, if any.
-    let topLevelCall: IMiddlewareEvent | undefined;
     // An array of accumulated patches if we're in an action, `undefined` otherwise.
     let patches: IJsonPatch[] | undefined;
 
@@ -63,25 +57,12 @@ export default class RendererBridge {
       }
     });
 
-    this.disposeMiddleware = addMiddleware(store, (call, next, abort) => {
-      if (call.parentActionEvent !== undefined) {
+    this.disposeMiddleware = addMiddleware(store, (call, next) => {
+      if (patches !== undefined) {
         // We're already in an action, there's no need to enter one.
         next(call);
         return;
       }
-      if (patches !== undefined) {
-        log.error(
-          'Unexpected call',
-          call,
-          'during dispatching another call',
-          topLevelCall,
-          'with accumulated patches',
-          patches,
-        );
-        abort(undefined);
-        return;
-      }
-      topLevelCall = call;
       patches = [];
       try {
         next(call);
@@ -91,7 +72,6 @@ export default class RendererBridge {
             listener(patches);
           }
         } finally {
-          topLevelCall = undefined;
           patches = undefined;
           this.snapshot = getSnapshot(store.shared);
         }
diff --git a/packages/main/src/infrastructure/electron/__tests__/RendererBridge.test.ts b/packages/main/src/infrastructure/electron/__tests__/RendererBridge.test.ts
new file mode 100644
index 0000000..b7c8a76
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/__tests__/RendererBridge.test.ts
@@ -0,0 +1,299 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+/* eslint-disable no-param-reassign -- Actions modify the `self` parameter. */
+
+import { jest } from '@jest/globals';
+import { configure } from 'mobx';
+import {
+  destroy,
+  flow,
+  type IJsonPatch,
+  type Instance,
+  unprotect,
+} from 'mobx-state-tree';
+
+import MainStore from '../../../stores/MainStore';
+import RendererBridge, { type PatchListener } from '../RendererBridge';
+
+const TestStore = MainStore.actions((theSelf) => ({
+  /**
+   * Dispatch `action` as an action in the context of the store.
+   *
+   * We cannot use `action` from `'mobx'` here, because it is not bound to
+   * a `'mobx-state-tree'` store, so it won't trigger our middleware.
+   *
+   * @param action The action to dispatch.
+   */
+  testAction(action: (self: MainStore) => void): void {
+    action(theSelf);
+  },
+  /**
+   * Executes a flow in the context of the store.
+   */
+  testFlow: flow(function* testFlow(
+    action: (self: MainStore) => Generator<PromiseLike<void>, void, void>,
+  ) {
+    yield* action(theSelf);
+  }),
+}));
+
+/*
+  eslint-disable-next-line @typescript-eslint/no-empty-interface,
+  @typescript-eslint/no-redeclare --
+  Intentionally naming the type the same as the store definition.
+*/
+type TestStore = Instance<typeof TestStore>;
+
+function resolveImmediately(): Promise<void> {
+  return new Promise((resolve) => {
+    setImmediate(resolve);
+  });
+}
+
+function rejectImmediately(error: Error): Promise<void> {
+  return new Promise((_resolve, reject) => {
+    setImmediate(() => reject(error));
+  });
+}
+
+const shouldUseDarkColorsPatch: IJsonPatch[] = [
+  {
+    op: 'replace',
+    path: '/shouldUseDarkColors',
+    value: false,
+  },
+];
+
+let store: TestStore;
+let listener: PatchListener;
+let bridge: RendererBridge;
+
+beforeEach(() => {
+  store = TestStore.create({
+    shared: {
+      shouldUseDarkColors: true,
+    },
+  });
+  listener = jest.fn<PatchListener>();
+  bridge = new RendererBridge(store, listener);
+});
+
+afterEach(() => {
+  bridge.dispose();
+  destroy(store);
+});
+
+test('sets the initial snapshot', () => {
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(true);
+});
+
+test('sets the snapshot after an action', () => {
+  store.shared.setShouldUseDarkColors(false);
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+});
+
+test('generates a patch after an action', () => {
+  store.shared.setShouldUseDarkColors(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
+
+describe('when the store is unprotected', () => {
+  beforeAll(() => configure({ enforceActions: 'never' }));
+
+  beforeEach(() => unprotect(store));
+
+  afterAll(() => configure({ enforceActions: 'observed' }));
+
+  test('sets the snapshot after directly setting a value', () => {
+    store.shared.shouldUseDarkColors = false;
+    expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  });
+
+  test('generates a patch after directly setting a value', () => {
+    store.shared.shouldUseDarkColors = false;
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+  });
+});
+
+test('does not generate a patch if an action does not modify the store', () => {
+  store.testAction(() => {});
+  expect(listener).not.toHaveBeenCalled();
+});
+
+test('does not set the snapshot until the end of the action', () => {
+  store.testAction(({ shared }) => {
+    shared.shouldUseDarkColors = false;
+    expect(bridge.snapshot.shouldUseDarkColors).not.toBe(false);
+  });
+});
+
+test('does not generate a patch until the end of the action', () => {
+  store.testAction(({ shared }) => {
+    shared.shouldUseDarkColors = false;
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
+
+test('does not set the snapshot until the end of the action with nested action', () => {
+  store.testAction(({ shared }) => {
+    shared.setShouldUseDarkColors(false);
+    expect(bridge.snapshot.shouldUseDarkColors).not.toBe(false);
+  });
+});
+
+test('does not generate a patch until the end of the action with nested action', () => {
+  store.testAction(({ shared }) => {
+    shared.setShouldUseDarkColors(false);
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
+
+test('generates a single patch for multiple nested actions', () => {
+  store.testAction(({ shared }) => {
+    shared.setShouldUseDarkColors(false);
+    shared.setLanguage('testLanguage', 'rtl');
+  });
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith([
+    ...shouldUseDarkColorsPatch,
+    {
+      op: 'replace',
+      path: '/language',
+      value: 'testLanguage',
+    },
+    {
+      op: 'replace',
+      path: '/writingDirection',
+      value: 'rtl',
+    },
+  ]);
+});
+
+test('does not abort on a failing action', () => {
+  expect(() =>
+    store.testAction(({ shared }) => {
+      shared.setShouldUseDarkColors(false);
+      throw new Error('test error');
+    }),
+  ).toThrow('test error');
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
+
+test('generates a snapshot and a patch in the beginning of a flow', async () => {
+  await store.testFlow(function* successfulTestFlowBeginning({ shared }) {
+    shared.setShouldUseDarkColors(false);
+
+    expect(bridge.snapshot.shouldUseDarkColors).not.toBe(false);
+    expect(listener).not.toHaveBeenCalled();
+
+    yield resolveImmediately();
+
+    expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+  });
+});
+
+test('generates a snapshot and a patch in the middle of a flow', async () => {
+  await store.testFlow(function* successfulTestFlowMiddle({ shared }) {
+    yield resolveImmediately();
+
+    shared.setShouldUseDarkColors(false);
+
+    expect(bridge.snapshot.shouldUseDarkColors).not.toBe(false);
+    expect(listener).not.toHaveBeenCalled();
+
+    yield resolveImmediately();
+
+    expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+  });
+});
+
+test('generates a snapshot and a patch in the end of a flow', async () => {
+  await store.testFlow(function* successfulTestFlowEnd({ shared }) {
+    yield resolveImmediately();
+
+    shared.setShouldUseDarkColors(false);
+
+    expect(bridge.snapshot.shouldUseDarkColors).not.toBe(false);
+    expect(listener).not.toHaveBeenCalled();
+  });
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
+
+test('generates a snapshot and a patch when a flow fails synchronously in the beginning', async () => {
+  await expect(
+    // eslint-disable-next-line require-yield -- We simulate a failure before `yield`.
+    store.testFlow(function* synchronousFailureTestFlowBeginning({ shared }) {
+      shared.setShouldUseDarkColors(false);
+      throw new Error('test error');
+    }),
+  ).rejects.toBeInstanceOf(Error);
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
+
+test('generates a snapshot and a patch when a flow fails asynchronously in the beginning', async () => {
+  await expect(
+    store.testFlow(function* asynchronousFailureTestFlowBeginning({ shared }) {
+      shared.setShouldUseDarkColors(false);
+      yield rejectImmediately(new Error('test error'));
+    }),
+  ).rejects.toBeInstanceOf(Error);
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
+
+test('generates a snapshot and a patch when a flow fails synchronously in the middle', async () => {
+  await expect(
+    store.testFlow(function* synchronousFailureTestFlowMiddle({ shared }) {
+      yield resolveImmediately();
+      shared.setShouldUseDarkColors(false);
+      throw new Error('test error');
+    }),
+  ).rejects.toBeInstanceOf(Error);
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
+
+test('generates a snapshot and a patch when a flow fails asynchronously in the middle', async () => {
+  await expect(
+    store.testFlow(function* asynchronousFailureTestFlowMiddle({ shared }) {
+      yield resolveImmediately();
+      shared.setShouldUseDarkColors(false);
+      yield rejectImmediately(new Error('test error'));
+    }),
+  ).rejects.toBeInstanceOf(Error);
+  expect(bridge.snapshot.shouldUseDarkColors).toBe(false);
+  expect(listener).toHaveBeenCalledTimes(1);
+  expect(listener).toHaveBeenCalledWith(shouldUseDarkColorsPatch);
+});
diff --git a/packages/main/src/infrastructure/electron/__tests__/UserAgents.test.ts b/packages/main/src/infrastructure/electron/__tests__/UserAgents.test.ts
new file mode 100644
index 0000000..d963704
--- /dev/null
+++ b/packages/main/src/infrastructure/electron/__tests__/UserAgents.test.ts
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import UserAgents from '../UserAgents';
+
+let userAgents: UserAgents;
+
+beforeEach(() => {
+  userAgents = new UserAgents(
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) sophie/0.1.0 Chrome/102.0.5005.27 Electron/19.0.0-beta.4 Safari/537.36',
+  );
+});
+
+test('removes Electron from the user agent outside dev mode', () => {
+  expect(userAgents.fallbackUserAgent(false)).toBe(
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.27 Safari/537.36',
+  );
+});
+
+test('does not remove Electron from the user agent in dev mode', () => {
+  expect(userAgents.fallbackUserAgent(true)).toBe(
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) sophie/0.1.0 Chrome/102.0.5005.27 Electron/19.0.0-beta.4 Safari/537.36',
+  );
+});
+
+test('displays the Chrome version for services', () => {
+  expect(userAgents.serviceUserAgent('https://example.org')).toBe(
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.5005.27 Safari/537.36',
+  );
+});
+
+test('does not display the Chrome version when loggin in to Google', () => {
+  expect(
+    userAgents.serviceUserAgent(
+      'https://accounts.google.com/signin/v2/identifier',
+    ),
+  ).toBe(
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36',
+  );
+});