test: Add tests for main package

- Changed jest to run from the root package and reference the packages
  as projects. This required moving the base jest config file away from
  the project root.
- Module isolation seems to prevent ts-jest from loading the shared
  package, so we disabled it for now.
- To better facilitate mocking, services should be split into interfaces
  and implementation
- Had to downgrade to chald 4.1.2 as per
  https://github.com/chalk/chalk/releases/tag/v5.0.0 at least until
  https://github.com/microsoft/TypeScript/issues/46452 is resolved.

8 files changed, 411 insertions, 116 deletions

diff --git a/packages/main/src/compositionRoot.ts b/packages/main/src/compositionRoot.ts
index eb6f50f..d420bd6 100644
--- a/packages/main/src/compositionRoot.ts
+++ b/packages/main/src/compositionRoot.ts
@@ -22,12 +22,12 @@ import { app } from 'electron';
 
 import { initConfig } from './controllers/config';
 import { initNativeTheme } from './controllers/nativeTheme';
-import { ConfigPersistenceService } from './services/ConfigPersistenceService';
+import { ConfigPersistenceServiceImpl } from './services/impl/ConfigPersistenceServiceImpl';
 import { MainStore } from './stores/MainStore';
 import { Disposer } from './utils';
 
 export async function init(store: MainStore): Promise<Disposer> {
-  const configPersistenceService = new ConfigPersistenceService(app.getPath('userData'));
+  const configPersistenceService = new ConfigPersistenceServiceImpl(app.getPath('userData'));
   const disposeConfigController = await initConfig(store.config, configPersistenceService);
   const disposeNativeThemeController = initNativeTheme(store);
 
diff --git a/packages/main/src/controllers/__tests__/config.spec.ts b/packages/main/src/controllers/__tests__/config.spec.ts
new file mode 100644
index 0000000..9471ca9
--- /dev/null
+++ b/packages/main/src/controllers/__tests__/config.spec.ts
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C)  2021-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 { jest } from '@jest/globals';
+import { mocked } from 'jest-mock';
+import ms from 'ms';
+
+import { initConfig } from '../config';
+import type { ConfigPersistenceService } from '../../services/ConfigPersistenceService';
+import { Config, config as configModel } from '../../stores/Config';
+import { Disposer, silenceLogger } from '../../utils';
+
+let config: Config;
+let persistenceService: ConfigPersistenceService = {
+  readConfig: jest.fn(),
+  writeConfig: jest.fn(),
+  watchConfig: jest.fn(),
+};
+let lessThanThrottleMs = ms('0.1s');
+let throttleMs = ms('1s');
+
+beforeAll(() => {
+  jest.useFakeTimers();
+  silenceLogger();
+});
+
+beforeEach(() => {
+  config = configModel.create();
+});
+
+describe('when initializing', () => {
+  describe('when there is no config file', () => {
+    beforeEach(() => {
+      mocked(persistenceService.readConfig).mockResolvedValueOnce({
+        found: false,
+      });
+    });
+
+    it('should create a new config file', async () => {
+      await initConfig(config, persistenceService);
+      expect(persistenceService.writeConfig).toBeCalledTimes(1);
+    });
+
+    it('should bail if there is an an error creating the config file', async () => {
+      mocked(persistenceService.writeConfig).mockRejectedValue(new Error('boo'));
+      await expect(() => initConfig(config, persistenceService)).rejects.toBeInstanceOf(Error);
+    });
+  });
+
+  describe('when there is a valid config file', () => {
+    beforeEach(() => {
+      mocked(persistenceService.readConfig).mockResolvedValueOnce({
+        found: true,
+        data: {
+          themeSource: 'dark',
+        },
+      });
+    });
+
+    it('should read the existing config file is there is one', async () => {
+      await initConfig(config, persistenceService);
+      expect(persistenceService.writeConfig).not.toBeCalled();
+      expect(config.themeSource).toBe('dark');
+    });
+
+    it('should bail if it cannot set up a watcher', async () => {
+      mocked(persistenceService.watchConfig).mockImplementationOnce(() => {
+        throw new Error('boo');
+      });
+      await expect(() => initConfig(config, persistenceService)).rejects.toBeInstanceOf(Error);
+    });
+  });
+
+  it('should not apply an invalid config file', async () => {
+    mocked(persistenceService.readConfig).mockResolvedValueOnce({
+      found: true,
+      data: {
+        themeSource: -1,
+      },
+    });
+    await initConfig(config, persistenceService);
+    expect(config.themeSource).not.toBe(-1);
+  });
+
+  it('should bail if it cannot determine whether there is a config file', async () => {
+    mocked(persistenceService.readConfig).mockRejectedValue(new Error('boo'));
+    await expect(() => initConfig(config, persistenceService)).rejects.toBeInstanceOf(Error);
+  });
+});
+
+describe('when it has loaded the config', () => {
+  let sutDisposer: Disposer;
+  let watcherDisposer: Disposer = jest.fn();
+  let configChangedCallback: () => Promise<void>;
+
+  beforeEach(async () => {
+    mocked(persistenceService.readConfig).mockResolvedValueOnce({
+      found: true,
+      data: {},
+    });
+    mocked(persistenceService.watchConfig).mockReturnValueOnce(watcherDisposer);
+    sutDisposer = await initConfig(config, persistenceService, throttleMs);
+    configChangedCallback = mocked(persistenceService.watchConfig).mock.calls[0][0];
+    jest.resetAllMocks();
+  });
+
+  it('should throttle saving changes to the config file', () => {
+    mocked(persistenceService.writeConfig).mockResolvedValue(undefined);
+    config.setThemeSource('dark');
+    jest.advanceTimersByTime(lessThanThrottleMs);
+    config.setThemeSource('light');
+    jest.advanceTimersByTime(throttleMs);
+    expect(persistenceService.writeConfig).toBeCalledTimes(1);
+  });
+
+  it('should handle config writing errors gracefully', () => {
+    mocked(persistenceService.writeConfig).mockRejectedValue(new Error('boo'));
+    config.setThemeSource('dark');
+    jest.advanceTimersByTime(throttleMs);
+    expect(persistenceService.writeConfig).toBeCalledTimes(1);
+  });
+
+  it('should read the config file when it has changed', async () => {
+    mocked(persistenceService.readConfig).mockResolvedValueOnce({
+      found: true,
+      data: {
+        themeSource: 'dark',
+      },
+    });
+    await configChangedCallback();
+    // Do not write back the changes we have just read.
+    expect(persistenceService.writeConfig).not.toBeCalled();
+    expect(config.themeSource).toBe('dark');
+  });
+
+  it('should not apply an invalid config file when it has changed', async () => {
+    mocked(persistenceService.readConfig).mockResolvedValueOnce({
+      found: true,
+      data: {
+        themeSource: -1,
+      },
+    });
+    await configChangedCallback();
+    expect(config.themeSource).not.toBe(-1);
+  });
+
+  it('should handle config writing errors gracefully', async () => {
+    mocked(persistenceService.readConfig).mockRejectedValue(new Error('boo'));
+    await configChangedCallback();
+  });
+
+  describe('when it was disposed', () => {
+    beforeEach(() => {
+      sutDisposer();
+    });
+
+    it('should dispose the watcher', () => {
+      expect(watcherDisposer).toBeCalled();
+    });
+
+    it('should not listen to store changes any more', () => {
+      config.setThemeSource('dark');
+      jest.advanceTimersByTime(2 * throttleMs);
+      expect(persistenceService.writeConfig).not.toBeCalled();
+    });
+  });
+});
diff --git a/packages/main/src/controllers/__tests__/nativeTheme.spec.ts b/packages/main/src/controllers/__tests__/nativeTheme.spec.ts
new file mode 100644
index 0000000..cfb557c
--- /dev/null
+++ b/packages/main/src/controllers/__tests__/nativeTheme.spec.ts
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C)  2021-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 { jest } from '@jest/globals';
+import { mocked } from 'jest-mock';
+
+import { createMainStore, MainStore } from '../../stores/MainStore';
+import { Disposer } from '../../utils';
+
+let shouldUseDarkColors = false;
+
+jest.unstable_mockModule('electron', () => ({
+  nativeTheme: {
+    themeSource: 'system',
+    get shouldUseDarkColors() {
+      return shouldUseDarkColors;
+    },
+    on: jest.fn(),
+    off: jest.fn(),
+  },
+}));
+
+const { nativeTheme } = await import('electron');
+const { initNativeTheme } = await import('../nativeTheme');
+
+let store: MainStore;
+let disposeSut: Disposer;
+
+beforeEach(() => {
+  store = createMainStore();
+  disposeSut = initNativeTheme(store);
+});
+
+it('should register a nativeTheme updated listener', () => {
+  expect(nativeTheme.on).toBeCalledWith('updated', expect.anything());
+});
+
+it('should synchronize themeSource changes to the nativeTheme', () => {
+  store.config.setThemeSource('dark');
+  expect(nativeTheme.themeSource).toBe('dark');
+});
+
+it('should synchronize shouldUseDarkColors changes to the store', () => {
+  const listener = mocked(nativeTheme.on).mock.calls.find(([event]) => event === 'updated')![1];
+  shouldUseDarkColors = true;
+  listener();
+  expect(store.shared.shouldUseDarkColors).toBe(true);
+});
+
+it('should remove the listener on dispose', () => {
+  const listener = mocked(nativeTheme.on).mock.calls.find(([event]) => event === 'updated')![1];
+  disposeSut();
+  expect(nativeTheme.off).toBeCalledWith('updated', listener);
+});
diff --git a/packages/main/src/controllers/config.ts b/packages/main/src/controllers/config.ts
index 600a142..d3559c8 100644
--- a/packages/main/src/controllers/config.ts
+++ b/packages/main/src/controllers/config.ts
@@ -60,12 +60,8 @@ export async function initConfig(
 
   if (!await readConfig()) {
     log.info('Config file was not found');
-    try {
-      await writeConfig();
-      log.info('Created config file');
-    } catch (err) {
-      log.error('Failed to initialize config', err);
-    }
+    await writeConfig();
+    log.info('Created config file');
   }
 
   const disposeOnSnapshot = onSnapshot(config, debounce((snapshot) => {
@@ -73,12 +69,16 @@ export async function initConfig(
     if (lastSnapshotOnDisk !== snapshot) {
       writeConfig().catch((err) => {
         log.error('Failed to write config on config change', err);
-      })
+      });
     }
   }, debounceTime));
 
   const disposeWatcher = persistenceService.watchConfig(async () => {
-    await readConfig();
+    try {
+      await readConfig();
+    } catch (err) {
+      log.error('Failed to read config', err);
+    }
   }, debounceTime);
 
   return () => {
diff --git a/packages/main/src/services/ConfigPersistenceService.ts b/packages/main/src/services/ConfigPersistenceService.ts
index b2109f6..b3ad162 100644
--- a/packages/main/src/services/ConfigPersistenceService.ts
+++ b/packages/main/src/services/ConfigPersistenceService.ts
@@ -17,112 +17,16 @@
  *
  * SPDX-License-Identifier: AGPL-3.0-only
  */
-import { watch } from 'fs';
-import { readFile, stat, writeFile } from 'fs/promises';
-import JSON5 from 'json5';
-import throttle from 'lodash-es/throttle';
-import { join } from 'path';
 
 import type { ConfigSnapshotOut } from  '../stores/Config';
-import { Disposer, getLogger } from '../utils';
-
-const log = getLogger('configPersistence');
+import { Disposer } from '../utils';
 
 export type ReadConfigResult = { found: true; data: unknown; } | { found: false; };
 
-export class ConfigPersistenceService {
-  private readonly configFilePath: string;
-
-  private writingConfig = false;
-
-  private timeLastWritten: Date | null = null;
-
-  constructor(
-    private readonly userDataDir: string,
-    private readonly configFileName: string = 'config.json5',
-  ) {
-    this.configFileName = configFileName;
-    this.configFilePath = join(this.userDataDir, this.configFileName);
-  }
-
-  async readConfig(): Promise<ReadConfigResult> {
-    let configStr;
-    try {
-      configStr = await readFile(this.configFilePath, 'utf8');
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-        log.debug('Config file', this.configFilePath, 'was not found');
-        return { found: false };
-      }
-      throw err;
-    }
-    log.info('Read config file', this.configFilePath);
-    return {
-      found: true,
-      data: JSON5.parse(configStr),
-    };
-  }
-
-  async writeConfig(configSnapshot: ConfigSnapshotOut): Promise<void> {
-    const configJson = JSON5.stringify(configSnapshot, {
-      space: 2,
-    });
-    this.writingConfig = true;
-    try {
-      await writeFile(this.configFilePath, configJson, 'utf8');
-      const { mtime } = await stat(this.configFilePath);
-      log.trace('Config file', this.configFilePath, 'last written at', mtime);
-      this.timeLastWritten = mtime;
-    } finally {
-      this.writingConfig = false;
-    }
-    log.info('Wrote config file', this.configFilePath);
-  }
-
-  watchConfig(callback: () => Promise<void>, throttleMs: number): Disposer {
-    log.debug('Installing watcher for', this.userDataDir);
-
-    const configChanged = throttle(async () => {
-      let mtime: Date;
-      try {
-        const stats = await stat(this.configFilePath);
-        mtime = stats.mtime;
-        log.trace('Config file last modified at', mtime);
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-          log.debug('Config file', this.configFilePath, 'was deleted after being changed');
-          return;
-        }
-        throw err;
-      }
-      if (!this.writingConfig
-        && (this.timeLastWritten === null || mtime > this.timeLastWritten)) {
-        log.debug(
-          'Found a config file modified at',
-          mtime,
-          'whish is newer than last written',
-          this.timeLastWritten,
-        );
-        return callback();
-      }
-    }, throttleMs);
-
-    const watcher = watch(this.userDataDir, {
-      persistent: false,
-    });
+export interface ConfigPersistenceService {
+  readConfig(): Promise<ReadConfigResult>;
 
-    watcher.on('change', (eventType, filename) => {
-      if (eventType === 'change'
-        && (filename === this.configFileName || filename === null)) {
-        configChanged()?.catch((err) => {
-          console.log('Unhandled error while listening for config changes', err);
-        });
-      }
-    });
+  writeConfig(configSnapshot: ConfigSnapshotOut): Promise<void>;
 
-    return () => {
-      log.trace('Removing watcher for', this.configFilePath);
-      watcher.close();
-    };
-  }
+  watchConfig(callback: () => Promise<void>, throttleMs: number): Disposer;
 }
diff --git a/packages/main/src/services/impl/ConfigPersistenceServiceImpl.ts b/packages/main/src/services/impl/ConfigPersistenceServiceImpl.ts
new file mode 100644
index 0000000..bffc38c
--- /dev/null
+++ b/packages/main/src/services/impl/ConfigPersistenceServiceImpl.ts
@@ -0,0 +1,128 @@
+
+/*
+ * Copyright (C)  2021-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 { watch } from 'fs';
+import { readFile, stat, writeFile } from 'fs/promises';
+import JSON5 from 'json5';
+import throttle from 'lodash-es/throttle';
+import { join } from 'path';
+
+import type { ConfigPersistenceService, ReadConfigResult } from '../ConfigPersistenceService';
+import type { ConfigSnapshotOut } from  '../../stores/Config';
+import { Disposer, getLogger } from '../../utils';
+
+const log = getLogger('configPersistence');
+
+export class ConfigPersistenceServiceImpl implements ConfigPersistenceService {
+  private readonly configFilePath: string;
+
+  private writingConfig = false;
+
+  private timeLastWritten: Date | null = null;
+
+  constructor(
+    private readonly userDataDir: string,
+    private readonly configFileName: string = 'config.json5',
+  ) {
+    this.configFileName = configFileName;
+    this.configFilePath = join(this.userDataDir, this.configFileName);
+  }
+
+  async readConfig(): Promise<ReadConfigResult> {
+    let configStr;
+    try {
+      configStr = await readFile(this.configFilePath, 'utf8');
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        log.debug('Config file', this.configFilePath, 'was not found');
+        return { found: false };
+      }
+      throw err;
+    }
+    log.info('Read config file', this.configFilePath);
+    return {
+      found: true,
+      data: JSON5.parse(configStr),
+    };
+  }
+
+  async writeConfig(configSnapshot: ConfigSnapshotOut): Promise<void> {
+    const configJson = JSON5.stringify(configSnapshot, {
+      space: 2,
+    });
+    this.writingConfig = true;
+    try {
+      await writeFile(this.configFilePath, configJson, 'utf8');
+      const { mtime } = await stat(this.configFilePath);
+      log.trace('Config file', this.configFilePath, 'last written at', mtime);
+      this.timeLastWritten = mtime;
+    } finally {
+      this.writingConfig = false;
+    }
+    log.info('Wrote config file', this.configFilePath);
+  }
+
+  watchConfig(callback: () => Promise<void>, throttleMs: number): Disposer {
+    log.debug('Installing watcher for', this.userDataDir);
+
+    const configChanged = throttle(async () => {
+      let mtime: Date;
+      try {
+        const stats = await stat(this.configFilePath);
+        mtime = stats.mtime;
+        log.trace('Config file last modified at', mtime);
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+          log.debug('Config file', this.configFilePath, 'was deleted after being changed');
+          return;
+        }
+        throw err;
+      }
+      if (!this.writingConfig
+        && (this.timeLastWritten === null || mtime > this.timeLastWritten)) {
+        log.debug(
+          'Found a config file modified at',
+          mtime,
+          'whish is newer than last written',
+          this.timeLastWritten,
+        );
+        return callback();
+      }
+    }, throttleMs);
+
+    const watcher = watch(this.userDataDir, {
+      persistent: false,
+    });
+
+    watcher.on('change', (eventType, filename) => {
+      if (eventType === 'change'
+        && (filename === this.configFileName || filename === null)) {
+        configChanged()?.catch((err) => {
+          console.log('Unhandled error while listening for config changes', err);
+        });
+      }
+    });
+
+    return () => {
+      log.trace('Removing watcher for', this.configFilePath);
+      watcher.close();
+    };
+  }
+}
diff --git a/packages/main/src/utils/index.ts b/packages/main/src/utils/index.ts
index 9a57e02..2b85989 100644
--- a/packages/main/src/utils/index.ts
+++ b/packages/main/src/utils/index.ts
@@ -22,4 +22,4 @@ import { IDisposer } from 'mobx-state-tree';
 
 export type Disposer = IDisposer;
 
-export { getLogger } from './logging';
+export { getLogger, silenceLogger } from './logging';
diff --git a/packages/main/src/utils/logging.ts b/packages/main/src/utils/logging.ts
index 6c4cba2..ed40365 100644
--- a/packages/main/src/utils/logging.ts
+++ b/packages/main/src/utils/logging.ts
@@ -18,17 +18,17 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import chalk, { ChalkInstance } from 'chalk';
+import chalk, { Chalk } from 'chalk';
 import loglevel, { Logger } from 'loglevel';
 import prefix from 'loglevel-plugin-prefix';
 
-if (import.meta.env.DEV) {
+if (import.meta.env?.DEV) {
   loglevel.setLevel('debug');
 } else {
   loglevel.setLevel('info');
 }
 
-const COLORS: Partial<Record<string, ChalkInstance>> = {
+const COLORS: Partial<Record<string, Chalk>> = {
   TRACE: chalk.magenta,
   DEBUG: chalk.cyan,
   INFO: chalk.blue,
@@ -37,7 +37,7 @@ const COLORS: Partial<Record<string, ChalkInstance>> = {
   CRITICAL: chalk.red,
 };
 
-function getColor(level: string): ChalkInstance {
+function getColor(level: string): Chalk {
   return COLORS[level] ?? chalk.gray;
 }
 
@@ -52,3 +52,11 @@ prefix.apply(loglevel, {
 export function getLogger(loggerName: string): Logger {
   return loglevel.getLogger(loggerName);
 }
+
+export function silenceLogger(): void {
+  loglevel.disableAll();
+  const loggers = loglevel.getLoggers();
+  for (const loggerName of Object.keys(loggers)) {
+    loggers[loggerName].disableAll();
+  }
+}