test(main): ConfigFile integration test

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

6 files changed, 332 insertions, 28 deletions

diff --git a/jest.config.js b/jest.config.js
index be24800..340c6dc 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -1,7 +1,11 @@
 /** @type {import('@jest/types').Config.InitialOptions} */
 export default {
   projects: ['<rootDir>/packages/*/jest.config.js'],
-  collectCoverageFrom: ['**/*.{ts,tsx}', '!**/__fixtures__/**/*'],
+  collectCoverageFrom: [
+    '**/*.{ts,tsx}',
+    '**/*.{test,spec}.{ts,tsx}',
+    '!**/__fixtures__/**/*',
+  ],
   /** @type {'v8'} */
   coverageProvider: 'v8',
   /** @type {['cobertura', 'text']} */
diff --git a/jest.integ.config.cjs b/jest.integ.config.cjs
index b9411bc..4ba5cba 100644
--- a/jest.integ.config.cjs
+++ b/jest.integ.config.cjs
@@ -1,7 +1,11 @@
 /** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
   projects: ['<rootDir>/packages/*/jest.integ.config.cjs'],
-  collectCoverageFrom: ['**/*.{ts,tsx}', '!**/__fixtures__/**/*'],
+  collectCoverageFrom: [
+    '**/*.{ts,tsx}',
+    '!**/*.{test,spec}.{ts,tsx}',
+    '!**/__fixtures__/**/*',
+  ],
   /** @type {'v8'} */
   coverageProvider: 'v8',
   /** @type {['cobertura', 'text']} */
diff --git a/packages/main/src/infrastructure/config/impl/ConfigFile.ts b/packages/main/src/infrastructure/config/impl/ConfigFile.ts
index 684a827..4f0d4f0 100644
--- a/packages/main/src/infrastructure/config/impl/ConfigFile.ts
+++ b/packages/main/src/infrastructure/config/impl/ConfigFile.ts
@@ -32,6 +32,8 @@ import type { ReadConfigResult } from '../ConfigRepository.js';
 
 const log = getLogger('ConfigFile');
 
+export const CONFIG_FILE_NAME = 'settings.json';
+
 export default class ConfigFile implements ConfigRepository {
   private readonly configFilePath: string;
 
@@ -41,7 +43,7 @@ export default class ConfigFile implements ConfigRepository {
 
   constructor(
     private readonly userDataDir: string,
-    private readonly configFileName = 'settings.json',
+    private readonly configFileName = CONFIG_FILE_NAME,
   ) {
     this.configFilePath = path.join(userDataDir, configFileName);
   }
@@ -65,6 +67,9 @@ export default class ConfigFile implements ConfigRepository {
   }
 
   async writeConfig(contents: string): Promise<void> {
+    if (this.writingConfig) {
+      throw new Error('writeConfig cannot be called reentrantly');
+    }
     this.writingConfig = true;
     try {
       await writeFile(this.configFilePath, contents, 'utf8');
@@ -95,7 +100,11 @@ export default class ConfigFile implements ConfigRepository {
           );
           return;
         }
-        throw error;
+        log.error(
+          'Unexpected error while listening for config file changes',
+          error,
+        );
+        return;
       }
       if (
         !this.writingConfig &&
@@ -111,20 +120,23 @@ export default class ConfigFile implements ConfigRepository {
       }
     }, throttleMs);
 
-    const watcher = watch(this.userDataDir, {
-      persistent: false,
-    });
-
-    watcher.on('change', (eventType, filename) => {
-      if (
-        eventType === 'change' &&
-        (filename === this.configFileName || filename === null)
-      ) {
-        configChanged()?.catch((err) => {
-          log.error('Unhandled error while listening for config changes', err);
-        });
-      }
-    });
+    const watcher = watch(
+      this.userDataDir,
+      {
+        persistent: false,
+        recursive: false,
+      },
+      (_eventType, filename) => {
+        if (filename === this.configFileName || filename === null) {
+          configChanged()?.catch((err) => {
+            log.error(
+              'Unhandled error while listening for config changes',
+              err,
+            );
+          });
+        }
+      },
+    );
 
     return () => {
       log.trace('Removing watcher for', this.configFilePath);
diff --git a/packages/main/src/infrastructure/config/impl/__tests__/ConfigFile.integ.test.ts b/packages/main/src/infrastructure/config/impl/__tests__/ConfigFile.integ.test.ts
new file mode 100644
index 0000000..b61e85a
--- /dev/null
+++ b/packages/main/src/infrastructure/config/impl/__tests__/ConfigFile.integ.test.ts
@@ -0,0 +1,293 @@
+/*
+ * 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 {
+  chmod,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile,
+} from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { jest } from '@jest/globals';
+import { mocked } from 'jest-mock';
+
+import Disposer from '../../../../utils/Disposer.js';
+import ConfigFile, { CONFIG_FILE_NAME } from '../ConfigFile.js';
+
+const THROTTLE_MS = 1000;
+
+let filesystemDelay = 100;
+let realSetTimeout: typeof setTimeout;
+let userDataDir: string | undefined;
+let configFilePath: string;
+let repository: ConfigFile;
+
+/**
+ * Wait for a short (real-time) delay to let node be notified of file changes.
+ *
+ * Will also run all pending microtasks to completion.
+ *
+ * Use the `SOPHIE_INTEG_TEST_DELAY` environmental variable to customize the delay
+ * (e.g., quicker test execution on faster computers or longer wait time in CI).
+ * The default delay is 100 ms, but as little as 10 ms might be enough, depending on your system.
+ *
+ * @returns A promise that resolves in a short while.
+ */
+function catchUpWithFilesystem(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    realSetTimeout(() => {
+      try {
+        jest.runAllTicks();
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    }, filesystemDelay);
+  });
+}
+
+async function catchUpWithFilesystemAndTimers(): Promise<void> {
+  await catchUpWithFilesystem();
+  jest.runAllTimers();
+  await catchUpWithFilesystem();
+}
+
+beforeAll(() => {
+  const delayEnv = process.env.SOPHIE_INTEG_TEST_DELAY;
+  if (delayEnv !== undefined) {
+    filesystemDelay = Number.parseInt(delayEnv, 10);
+  }
+  jest.useRealTimers();
+  // Save the real implementation of `setTimeout` before we mock it.
+  realSetTimeout = setTimeout;
+  jest.useFakeTimers();
+});
+
+beforeEach(async () => {
+  try {
+    userDataDir = await mkdtemp(path.join(tmpdir(), 'sophie-configFile-'));
+    configFilePath = path.join(userDataDir, CONFIG_FILE_NAME);
+    repository = new ConfigFile(userDataDir);
+  } catch (error) {
+    userDataDir = undefined;
+    throw error;
+  }
+});
+
+afterEach(async () => {
+  jest.clearAllTimers();
+  if (userDataDir === undefined) {
+    return;
+  }
+  if (!userDataDir.startsWith(tmpdir())) {
+    throw new Error(
+      `Refusing to delete directory ${userDataDir} outside of tmp directory`,
+    );
+  }
+  await rm(userDataDir, {
+    force: true,
+    recursive: true,
+  });
+  userDataDir = undefined;
+});
+
+describe('readConfig', () => {
+  test('returns false when the config file is not found', async () => {
+    const result = await repository.readConfig();
+    expect(result.found).toBe(false);
+  });
+
+  test('reads the contents of the config file if found', async () => {
+    await writeFile(configFilePath, 'Hello World!', 'utf8');
+    const result = await repository.readConfig();
+    expect(result.found).toBe(true);
+    expect(result).toHaveProperty('contents', 'Hello World!');
+  });
+
+  test('throws an error if the config file cannot be read', async () => {
+    await mkdir(configFilePath);
+    await expect(repository.readConfig()).rejects.toThrow();
+  });
+});
+
+describe('writeConfig', () => {
+  test('writes the config file', async () => {
+    await repository.writeConfig('Hi Mars!');
+    const contents = await readFile(configFilePath, 'utf8');
+    expect(contents).toBe('Hi Mars!');
+  });
+
+  test('overwrites the config file', async () => {
+    await writeFile(configFilePath, 'Hello World!', 'utf8');
+    await repository.writeConfig('Hi Mars!');
+    const contents = await readFile(configFilePath, 'utf8');
+    expect(contents).toBe('Hi Mars!');
+  });
+
+  test('throws an error if the config file cannot be written', async () => {
+    await mkdir(configFilePath);
+    await expect(repository.writeConfig('Hi Mars!')).rejects.toThrow();
+  });
+
+  test('throws an error when called reentrantly', async () => {
+    const promise = repository.writeConfig('Hello World!');
+    try {
+      await expect(repository.writeConfig('Hi Mars!')).rejects.toThrow();
+    } finally {
+      await promise;
+    }
+  });
+});
+
+describe('watchConfig', () => {
+  let callback: () => Promise<void>;
+  let watcher: Disposer | undefined;
+
+  beforeEach(() => {
+    callback = jest.fn(() => Promise.resolve());
+  });
+
+  afterEach(() => {
+    if (watcher !== undefined) {
+      // Make sure we dispose the watcher.
+      watcher();
+    }
+  });
+
+  describe('when the config file does not exist', () => {
+    beforeEach(() => {
+      watcher = repository.watchConfig(callback, THROTTLE_MS);
+    });
+
+    test('notifies when the config file is created externally', async () => {
+      await writeFile(configFilePath, 'Hello World!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalled();
+    });
+
+    test('does not notify when the config file is created by the repository', async () => {
+      await repository.writeConfig('Hello World!');
+      await catchUpWithFilesystemAndTimers();
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when the config file already exists', () => {
+    beforeEach(async () => {
+      await writeFile(configFilePath, 'Hello World!', 'utf8');
+      watcher = repository.watchConfig(callback, THROTTLE_MS);
+    });
+
+    test('notifies when the config file is updated externally', async () => {
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalled();
+    });
+
+    test('does not notify when the config file is created by the repository', async () => {
+      await repository.writeConfig('Hi Mars!');
+      await catchUpWithFilesystemAndTimers();
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    test('throttles notifications of external changes to the config file', async () => {
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalledTimes(1);
+      mocked(callback).mockClear();
+
+      jest.advanceTimersByTime(100);
+      await writeFile(configFilePath, 'Howdy Venus!', 'utf8');
+      await catchUpWithFilesystem();
+
+      jest.advanceTimersByTime(100);
+      await catchUpWithFilesystem();
+      expect(callback).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(THROTTLE_MS);
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    test('handles the config file being deleted', async () => {
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      // Clear the mock if we inadverently set off `callback`.
+      mocked(callback).mockClear();
+      await rm(configFilePath);
+      await catchUpWithFilesystemAndTimers();
+      expect(callback).not.toHaveBeenCalled();
+
+      await writeFile(configFilePath, 'Hello World!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalled();
+    });
+
+    test('handles the config file being renamed', async () => {
+      const renamedPath = `${configFilePath}.renamed`;
+
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      // Clear the mock if we inadverently set off `callback`.
+      mocked(callback).mockClear();
+      await rename(configFilePath, renamedPath);
+      await catchUpWithFilesystemAndTimers();
+      expect(callback).not.toHaveBeenCalled();
+
+      await writeFile(renamedPath, 'Hello World!', 'utf8');
+      await catchUpWithFilesystemAndTimers();
+      expect(callback).not.toHaveBeenCalled();
+
+      await writeFile(configFilePath, 'Hello World!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalled();
+    });
+
+    test('handles other filesystem errors', async () => {
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      // Clear the mock if we inadverently set off `callback`.
+      mocked(callback).mockClear();
+      const { mode } = await stat(userDataDir!);
+      // Remove permission to force a filesystem error.
+      // eslint-disable-next-line no-bitwise -- Compute reduced permissions.
+      await chmod(userDataDir!, mode & 0o666);
+      try {
+        await catchUpWithFilesystemAndTimers();
+        expect(callback).not.toHaveBeenCalled();
+      } finally {
+        await chmod(userDataDir!, mode);
+      }
+    });
+
+    test('handles callback errors', async () => {
+      mocked(callback).mockRejectedValue(new Error('Test error'));
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      await catchUpWithFilesystem();
+      // This test would fail an unhandled promise rejection error if `ConfigFile`
+      // did not handle the rejection properly.
+      expect(callback).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/main/src/infrastructure/electron/impl/__tests__/electron.integ.test.ts b/packages/main/src/infrastructure/electron/impl/__tests__/electron.integ.test.ts
deleted file mode 100644
index 75b12ac..0000000
--- a/packages/main/src/infrastructure/electron/impl/__tests__/electron.integ.test.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { BrowserWindow } from 'electron';
-
-import '../ElectronMainWindow.js';
-
-test('create a BrowserWindow', async () => {
-  const w = new BrowserWindow();
-  await expect(w.loadURL('https://example.org')).resolves.toBeUndefined();
-  w.close();
-});
diff --git a/packages/main/src/reactions/__tests__/synchronizeConfig.test.ts b/packages/main/src/reactions/__tests__/synchronizeConfig.test.ts
index d4d8abf..ae3b59f 100644
--- a/packages/main/src/reactions/__tests__/synchronizeConfig.test.ts
+++ b/packages/main/src/reactions/__tests__/synchronizeConfig.test.ts
@@ -43,7 +43,7 @@ beforeEach(() => {
   store = SharedStore.create();
 });
 
-describe('when synchronizeializing', () => {
+describe('when initializing', () => {
   describe('when there is no config file', () => {
     beforeEach(() => {
       mocked(repository.readConfig).mockResolvedValueOnce({