1 files changed, 289 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..c443d99
--- /dev/null
+++ b/packages/main/src/infrastructure/config/impl/__tests__/ConfigFile.integ.test.ts
@@ -0,0 +1,289 @@
+/*
+ * 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,
+  utimes,
+  writeFile,
+} from 'node:fs/promises';
+import { platform, tmpdir, userInfo } from 'node:os';
+import path from 'node:path';
+
+import { jest } from '@jest/globals';
+import { testIf } from '@sophie/test-utils';
+import { mocked } from 'jest-mock';
+
+import Disposer from '../../../../utils/Disposer.js';
+import ConfigFile, { CONFIG_FILE_NAME } from '../ConfigFile.js';
+
+const CONFIG_CHANGE_DEBOUNCE_MS = 10;
+
+let filesystemDelay = 100;
+let realSetTimeout: typeof setTimeout;
+let userDataDir: string | undefined;
+let configFilePath: string;
+let repository: ConfigFile;
+
+async function realDelay(ms: number): Promise<void> {
+  return new Promise<void>((resolve) => {
+    realSetTimeout(() => resolve(), ms);
+  });
+}
+
+/**
+ * Wait for a short (real-time) delay to let node be notified of file changes.
+ *
+ * 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.
+ *
+ * @param ms The time that should elapse after noticing the filesystem change.
+ * @returns A promise that resolves in a `filesystemDelay` ms.
+ */
+async function catchUpWithFilesystem(
+  ms = CONFIG_CHANGE_DEBOUNCE_MS,
+): Promise<void> {
+  await realDelay(filesystemDelay);
+  jest.advanceTimersByTime(ms);
+  // Some extra real time is needed after advancing the timer to make sure the callback runs.
+  await realDelay(Math.max(filesystemDelay / 10, 1));
+}
+
+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,
+      CONFIG_FILE_NAME,
+      CONFIG_CHANGE_DEBOUNCE_MS,
+    );
+  } 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);
+    });
+
+    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 catchUpWithFilesystem();
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when the config file already exists', () => {
+    beforeEach(async () => {
+      await writeFile(configFilePath, 'Hello World!', 'utf8');
+      watcher = repository.watchConfig(callback);
+    });
+
+    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 catchUpWithFilesystem();
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    test('debounces changes to the config file', async () => {
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      await catchUpWithFilesystem(5);
+      expect(callback).not.toHaveBeenCalled();
+
+      await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    test('handles the config file being deleted', async () => {
+      await rm(configFilePath);
+      await catchUpWithFilesystem();
+      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 rename(configFilePath, renamedPath);
+      await catchUpWithFilesystem();
+      expect(callback).not.toHaveBeenCalled();
+
+      await writeFile(renamedPath, 'Hello World!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).not.toHaveBeenCalled();
+
+      await writeFile(configFilePath, 'Hello World!', 'utf8');
+      await catchUpWithFilesystem();
+      expect(callback).toHaveBeenCalled();
+    });
+
+    // We can only cause a filesystem error by changing permissions if we run on a POSIX-like
+    // system and we aren't root (i.e., not in CI).
+    testIf(platform() !== 'win32' && userInfo().uid !== 0)(
+      'handles other filesystem errors',
+      async () => {
+        const { mode } = await stat(userDataDir!);
+        await writeFile(configFilePath, 'Hi Mars!', 'utf8');
+        // Remove permission to force a filesystem error.
+        // eslint-disable-next-line no-bitwise -- Compute reduced permissions.
+        await chmod(userDataDir!, mode & 0o666);
+        try {
+          await catchUpWithFilesystem();
+          expect(callback).not.toHaveBeenCalled();
+        } finally {
+          await chmod(userDataDir!, mode);
+        }
+      },
+    );
+
+    test('does not notify when the modification date is prior to the last write', async () => {
+      await repository.writeConfig('Hello World!');
+      const date = new Date(Date.now() - 3_600_000);
+      await utimes(configFilePath, date, date);
+      await catchUpWithFilesystem();
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    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();
+    });
+  });
+});