1 files changed, 293 insertions, 0 deletions

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();
+    });
+  });
+});