@koech/esm-core 8.0.0

package/packages/framework/esm-config/src/module-config/module-config.test.ts

@@ -0,0 +1,1449 @@
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import unset from 'lodash/unset';
+import * as Config from './module-config';
+import type { MockedStore } from '@openmrs/esm-state/mock';
+import { mockStores } from '@openmrs/esm-state/mock';
+import { validator } from '../validators/validator';
+import { validators, isUrl } from '../validators/validators';
+import type { ConfigExtensionStore, ConfigInternalStore, ImplementerToolsConfigStore } from './state';
+import {
+  configExtensionStore,
+  configInternalStore,
+  getExtensionConfig,
+  implementerToolsConfigStore,
+  temporaryConfigStore,
+} from './state';
+import { Type } from '../types';
+import { getExtensionSlotsConfigStore } from '..';
+
+vi.mock('@openmrs/esm-state', () => import('@openmrs/esm-state/mock'));
+
+// Names from Wikipedia's "Metasyntactic variable" page:
+// foo, bar, baz, qux, quux, corge, grault, garply, waldo, fred, plugh, xyzzy, thud
+
+const mockConfigInternalStore = configInternalStore as MockedStore<ConfigInternalStore>;
+const mockTemporaryConfigStore = temporaryConfigStore as MockedStore<object>;
+const mockImplementerToolsConfigStore = implementerToolsConfigStore as MockedStore<ImplementerToolsConfigStore>;
+const mockConfigExtensionStore = configExtensionStore as MockedStore<ConfigExtensionStore>;
+
+async function resetAll() {
+  mockConfigInternalStore.resetMock();
+  mockTemporaryConfigStore.resetMock();
+  mockImplementerToolsConfigStore.resetMock();
+  mockConfigExtensionStore.resetMock();
+  for (let storeName of Object.keys(mockStores)) {
+    if (storeName.startsWith('config-module-')) {
+      delete mockStores[storeName];
+    } else if (storeName.startsWith('config-extension-slots-')) {
+      delete mockStores[storeName];
+    } else if (storeName.startsWith('config-extension-')) {
+      delete mockStores[storeName];
+    }
+  }
+}
+
+describe('defineConfigSchema', () => {
+  beforeEach(() => {
+    console.error = vi.fn();
+  });
+
+  afterEach(resetAll);
+
+  it('logs an error if a non-object value is provided as a config element definition', () => {
+    const schema = {
+      bar: true,
+    };
+    Config.defineConfigSchema('foo-module', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foo-module.*bar/));
+  });
+
+  it('logs an error if a nested non-object value is provided as a config element definition', () => {
+    const schema = {
+      bar: { baz: 'bad bad bad' },
+    };
+    Config.defineConfigSchema('foo-module', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foo-module.*bar\.baz/));
+  });
+
+  it('logs an error if an invalid type is provided', () => {
+    const schema = {
+      bar: { _default: 0, _type: 'numeral' },
+    };
+    Config.defineConfigSchema('foo-module', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foo-module.*bar[\s\S]*Number.*numeral/i));
+  });
+
+  it("doesn't mind higher-level description and validator keys", () => {
+    const schema = {
+      foo: {
+        _description: 'Composed of bar and baz.',
+        _validators: [validator((f) => f.bar != f.baz, 'bar and baz must not be equal')],
+        bar: {
+          _default: 0,
+        },
+        baz: {
+          _default: 1,
+        },
+      },
+    };
+    Config.defineConfigSchema('foo-module', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('runs top-level validators on filled-in config', () => {
+    const schema = {
+      foo: {
+        _type: Type.String,
+        _default: 'bar-value',
+      },
+      fooStart: {
+        _type: Type.String,
+        _default: 'bar',
+      },
+      _validators: [
+        validator(
+          (v) => v.foo.startsWith(v.fooStart),
+          (v) => `The value of \`foo\` must start with the value of \`fooStart\` (which is ${v.fooStart}).`,
+        ),
+      ],
+    };
+    Config.defineConfigSchema('foo-module', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({ 'foo-module': { foo: 'different' } });
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/The value of `foo` must start with the value of `fooStart`.*bar/),
+    );
+  });
+
+  it('logs an error if a non-function validator is provided', () => {
+    const schema = {
+      bar: { _default: [], _validators: [false] },
+    };
+    Config.defineConfigSchema('foo-module', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/foo-module.*has invalid validator.*bar[\s\S]*false.*/i),
+    );
+  });
+
+  it('logs an error if non-object value is provided as a config element definition within an array', () => {
+    const schema = {
+      foo: {
+        _default: [],
+        _type: Type.Array,
+        _elements: { bar: 'bad' },
+      },
+    };
+    Config.defineConfigSchema('mod-mod', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('mod-mod');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/mod-mod.*foo.*bar/));
+  });
+
+  it("logs an error if elements key is provided without type being 'Array' or 'Object'", () => {
+    const schema = {
+      foo: {
+        _default: [],
+        _type: Type.Boolean,
+        _elements: {},
+      },
+    };
+    Config.defineConfigSchema('mod-mod', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('mod-mod');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/mod-mod.*foo[\s\S]*elements.*Boolean/));
+  });
+
+  it('logs an error if any key does not include a default', () => {
+    const schema = {
+      foo: { bar: { _description: 'lol idk' } },
+    };
+    Config.defineConfigSchema('mod-mod', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('mod-mod');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/mod-mod.*foo\.bar[\s\S]*default/));
+  });
+
+  it('logs an error if any key is empty', () => {
+    const schema = {
+      foo: { bar: {} },
+    };
+    Config.defineConfigSchema('mod-mod', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('mod-mod');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/mod-mod.*foo\.bar[\s\S]*default/));
+  });
+
+  it('does not log an error if an array elements object has a key without a default', () => {
+    const schema = {
+      foo: {
+        _default: [],
+        _type: Type.Array,
+        _elements: {
+          bar: {},
+        },
+      },
+    };
+    Config.defineConfigSchema('mod-mod', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('mod-mod');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it("logs an error if the schema attempts to include a key named 'Display conditions'", () => {
+    const schema = {
+      'Display conditions': {
+        _type: Type.Array,
+        _default: [],
+      },
+    };
+
+    Config.defineConfigSchema('mod-mod', schema);
+    // load to trigger validation
+    Config.registerModuleLoad('mod-mod');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/mod-mod.*\bDisplay conditions\b/));
+  });
+});
+
+describe('getConfig', () => {
+  beforeAll(resetAll);
+
+  beforeEach(async () => {
+    console.error = vi.fn();
+  });
+
+  afterEach(resetAll);
+
+  it('uses config values from the provided config file', async () => {
+    Config.defineConfigSchema('foo-module', { foo: { _default: 'qux' } });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    type FooConfig = { foo: string };
+    const testConfig = { 'foo-module': { foo: 'bar' } };
+    Config.provide(testConfig);
+    const config = await Config.getConfig<FooConfig>('foo-module');
+    expect(config.foo).toBe('bar');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('returns default values from the schema', async () => {
+    Config.defineConfigSchema('testmod', {
+      foo: {
+        _default: 'qux',
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('testmod');
+    const config = await Config.getConfig('testmod');
+    expect(config.foo).toBe('qux');
+  });
+
+  it('logs an error if config values not defined in the schema', async () => {
+    Config.defineConfigSchema('foo-module', { foo: { _default: 'qux' } });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({ 'foo-module': { bar: 'baz' } });
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/Unknown.*key.*foo-module.*bar/));
+  });
+
+  it('validates the structure of the config tree', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: { bar: { _default: 'qux' } },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({ 'foo-module': { foo: { doof: 'nope' } } });
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foo-module.*foo\.doof.*/));
+  });
+
+  it('supports running validators on nested objects', async () => {
+    const fooSchema = {
+      bar: {
+        a: { _default: { b: 1 } },
+        c: { _default: 2 },
+        diff: { _default: 1 },
+        _validators: [validator((o) => o.a.b + o.diff == o.c, 'c must equal a.b + diff')],
+      },
+    };
+    Config.defineConfigSchema('foo-module', fooSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const badConfig = {
+      'foo-module': {
+        bar: { a: { b: 5 } },
+      },
+    };
+    Config.provide(badConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/Invalid configuration for foo-module.bar.*c must equal a\.b \+ diff/),
+    );
+
+    await resetAll();
+
+    Config.defineConfigSchema('foo-module', fooSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const goodConfig = { 'foo-module': { bar: { a: { b: 0 }, diff: 2 } } };
+    Config.provide(goodConfig);
+    const result = await Config.getConfig('foo-module');
+    expect(result).toStrictEqual({
+      bar: {
+        a: { b: 0 },
+        c: 2,
+        diff: 2,
+      },
+    });
+  });
+
+  // DISABLED: Presently getConfig *does not resolve* when looking up a module
+  //   with no schema. The behavior described in this test would be preferable,
+  //   but would require some deeper changes.
+  it.skip('throws if looking up module with no schema', async () => {
+    await expect(Config.getConfig('fake-module')).rejects.toThrow(/No config schema has been defined.*fake-module/);
+  });
+
+  it('returns a nested configuration', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        bar: {
+          _default: -1,
+        },
+        baz: {
+          qux: {
+            _default: 'N/A',
+          },
+          quy: {
+            _default: '',
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: {
+          bar: 0,
+          baz: {
+            quy: 'xyz',
+          },
+        },
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('foo-module');
+    expect(config.foo.bar).toBe(0);
+    expect(config.foo.baz.qux).toBe('N/A');
+    expect(config.foo.baz.quy).toBe('xyz');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('works for multiple modules and multiple provides', async () => {
+    Config.defineConfigSchema('foo-module', { foo: { _default: 'qux' } });
+    Config.registerModuleLoad('foo-module');
+    Config.defineConfigSchema('bar-module', { bar: { _default: 'quinn' } });
+    Config.registerModuleLoad('bar-module');
+    Config.defineConfigSchema('baz-module', { baz: { _default: 'quip' } });
+    Config.registerModuleLoad('baz-module');
+    const barTestConfig = { 'bar-module': { bar: 'barrr' } };
+    const bazTestConfig = { 'baz-module': { baz: 'bazzz' } };
+    Config.provide(barTestConfig);
+    Config.provide(bazTestConfig);
+    const fooConfig = Config.getConfig('foo-module');
+    await expect(fooConfig).resolves.toHaveProperty('foo', 'qux');
+    const barConfig = Config.getConfig('bar-module');
+    await expect(barConfig).resolves.toHaveProperty('bar', 'barrr');
+    const bazConfig = Config.getConfig('baz-module');
+    await expect(bazConfig).resolves.toHaveProperty('baz', 'bazzz');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('validates config values', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _default: 'thing',
+        _validators: [validator((val) => val.startsWith('thi'), "must start with 'thi'")],
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: 'bar',
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/bar.*foo.*must start with 'thi'.*/));
+  });
+
+  it("tolerates defaults that don't pass validation", async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _default: null,
+        _validators: [validator((val) => val.startsWith('thi'), "must start with 'thi'")],
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    await Config.getConfig('foo-module');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('validators pass', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _default: 'thing',
+        _validators: [validator((val) => val.startsWith('thi'), "must start with 'thi'")],
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: 'this',
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('foo-module');
+    expect(config.foo).toBe('this');
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('supports freeform object elements, which have no structural validation', async () => {
+    const fooSchema = {
+      baz: {
+        _type: Type.Object,
+        _default: {},
+      },
+    };
+    Config.defineConfigSchema('foo-module', fooSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        baz: { what: 'ever', goes: 'here' },
+      },
+    };
+    Config.provide(testConfig);
+    const result = await Config.getConfig('foo-module');
+    expect(console.error).not.toHaveBeenCalled();
+    expect(result.baz.what).toBe('ever');
+
+    await resetAll();
+
+    Config.defineConfigSchema('foo-module', fooSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const badConfig = {
+      'foo-module': {
+        baz: 0,
+      },
+    };
+    Config.provide(badConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/0.*foo-module.*baz.*must be an object/i));
+  });
+
+  it('supports freeform object elements with defined _elements type string', async () => {
+    const daikonSchema = {
+      daikon: {
+        _type: Type.Object,
+        _default: {},
+        _elements: {
+          _type: Type.String,
+        },
+      },
+    };
+    Config.defineConfigSchema('daikon-module', daikonSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('daikon-module');
+    const testConfig = {
+      'daikon-module': {
+        daikon: {
+          raw: 'pretty good',
+          pickled: 'very nice',
+        },
+      },
+    };
+    Config.provide(testConfig);
+    const result = await Config.getConfig('daikon-module');
+    expect(console.error).not.toHaveBeenCalled();
+    expect(result.daikon.pickled).toBe('very nice');
+
+    await resetAll();
+
+    Config.defineConfigSchema('daikon-module', daikonSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('daikon-module');
+    const badConfig = {
+      'daikon-module': {
+        daikon: {
+          howMany: 42,
+        },
+      },
+    };
+    Config.provide(badConfig);
+    await Config.getConfig('daikon-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/42.*daikon-module.*daikon.*must be a string/i));
+  });
+
+  it('does not crash when null is passed as a freeform object config value', async () => {
+    Config.defineConfigSchema('object-null-module', {
+      objnu: {
+        _type: Type.Object,
+        _default: {},
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('object-null-module');
+    const testConfig = {
+      'object-null-module': {
+        objnu: null,
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('object-null-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/.*object-null-module.*obj.*must be an object/i));
+  });
+
+  it('supports freeform object elements validations', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _type: Type.Object,
+        _elements: {
+          name: { _validators: [isUrl] },
+        },
+        _default: {},
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: {
+          b: {
+            name: 'B',
+          },
+          c: {
+            name: 1,
+          },
+        },
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foo-module.foo.c.name: .*url/i));
+  });
+
+  it('returns freeform object default', async () => {
+    Config.defineConfigSchema('object-def', {
+      furi: {
+        _type: Type.Object,
+        _elements: { gohan: { _type: Type.String } },
+        _default: { kake: { gohan: 'ok' } },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('object-def');
+    const config = await Config.getConfig('object-def');
+    expect(config).toStrictEqual({
+      furi: { kake: { gohan: 'ok' } },
+    });
+  });
+
+  it('interpolates freeform object element defaults', async () => {
+    Config.defineConfigSchema('object-def', {
+      tamago: {
+        _type: Type.Object,
+        _elements: {
+          gohan: { _type: Type.String },
+          nori: { _type: Type.Boolean, _default: true },
+        },
+        _default: {
+          kake: { gohan: 'ok', nori: true },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('object-def');
+    Config.provide({
+      'object-def': {
+        tamago: {
+          gyudon: { gohan: 'no' },
+          sake: { gohan: 'maybe', nori: false },
+        },
+      },
+    });
+    const config = await Config.getConfig('object-def');
+    expect(config).toStrictEqual({
+      tamago: {
+        gyudon: { gohan: 'no', nori: true },
+        sake: { gohan: 'maybe', nori: false },
+      },
+    });
+  });
+
+  it('supports array elements', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _default: [1, 2, 3],
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: [0, 2, 4],
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('foo-module');
+    expect(config.foo).toStrictEqual([0, 2, 4]);
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('supports array of string elements', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _type: Type.Array,
+        _default: ['bar'],
+        _elements: {
+          _type: Type.String,
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: ['bar', 'baz', 'qux'],
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('foo-module');
+    expect(config.foo).toStrictEqual(['bar', 'baz', 'qux']);
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('supports type validation of array elements', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _type: Type.Array,
+        _default: ['bar'],
+        _elements: {
+          _type: Type.String,
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: ['bar', 42],
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/Invalid.*42.*foo-module.foo\[1\].*string/i));
+  });
+
+  it('supports validation of array elements', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _type: Type.Array,
+        _default: [1, 2, 3],
+        _elements: {
+          _validators: [validator(Number.isInteger, 'must be an integer')],
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: [0, 1.5, 'bad'],
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/1\.5.*foo-module.*foo\[1\].*must be an integer/));
+  });
+
+  it('supports validating structure of array element objects', async () => {
+    Config.defineConfigSchema('foo-module', {
+      bar: {
+        baz: {
+          _default: [{ a: 0, b: 1 }],
+          _type: Type.Array,
+          _elements: {
+            a: {},
+            b: {},
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        bar: {
+          baz: [
+            { a: 1, b: 2 },
+            { a: 3, b: 4, dingo: 5 },
+          ],
+        },
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/key.*foo-module.*bar\.baz\[1\]\.dingo/));
+  });
+
+  it('supports validating structure of array element nested objects', async () => {
+    const configSchema = {
+      yoshi: {
+        nori: {
+          _default: [{ a: 0, b: { c: 2 } }],
+          _type: Type.Array,
+          _elements: {
+            a: {},
+            b: { c: {} },
+          },
+        },
+      },
+    };
+    // load to trigger validation
+    Config.registerModuleLoad('array-nest');
+    Config.defineConfigSchema('array-nest', configSchema);
+    const testConfig = {
+      'array-nest': {
+        yoshi: {
+          nori: [
+            { a: 1, b: { c: 1 } },
+            { a: 3, b: { shi: 5 } },
+          ],
+        },
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('array-nest');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/key.*array-nest.*yoshi\.nori\[1\]\.b\.shi/));
+  });
+
+  it('supports validation of nested array element objects elements', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        _default: [{ a: { b: 1 } }],
+        _type: Type.Array,
+        _elements: {
+          a: {
+            b: {
+              _validators: [validator(Number.isInteger, 'must be an integer')],
+            },
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const testConfig = {
+      'foo-module': {
+        foo: [{ a: { b: 0.2 } }],
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/value.*foo\[0\]\.a\.b.*must be an integer/));
+  });
+
+  it('supports validation of array element objects', async () => {
+    const fooSchema = {
+      bar: {
+        _default: [{ a: { b: 1 }, c: 2 }],
+        _type: Type.Array,
+        _elements: {
+          _validators: [validator((o) => o.a.b + 1 == o.c, 'c must equal a.b + 1')],
+        },
+      },
+    };
+    Config.defineConfigSchema('foo-module', fooSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const badConfig = {
+      'foo-module': {
+        bar: [
+          { a: { b: 4 }, c: 5 },
+          { a: { b: 1 }, c: 3 },
+        ],
+      },
+    };
+    Config.provide(badConfig);
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/foo-module.bar\[1\].*c must equal a\.b \+ 1/i));
+
+    await resetAll();
+
+    Config.defineConfigSchema('foo-module', fooSchema);
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    const goodConfig = { 'foo-module': { bar: [{ a: { b: 2 }, c: 3 }] } };
+    Config.provide(goodConfig);
+    const result = await Config.getConfig('foo-module');
+    expect(result.bar[0].a.b).toBe(2);
+  });
+
+  it('does not crash when null is passed as an array config value', async () => {
+    Config.defineConfigSchema('array-null-module', {
+      arnu: {
+        _type: Type.Array,
+        _default: [1, 2, 3],
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('array-null-module');
+    const testConfig = {
+      'array-null-module': {
+        arnu: null,
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('array-null-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/.*array-null-module.*arnu.*must be an array/i));
+  });
+
+  it('fills array element object elements with defaults', async () => {
+    Config.defineConfigSchema('array-def', {
+      foo: {
+        _default: [{ a: { b: 'arrayDefaultB', filler: 'arrayDefault' } }],
+        _type: Type.Array,
+        _elements: {
+          a: {
+            b: { _validators: [] },
+            filler: { _default: 'defaultFiller', _validators: [isUrl] },
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('array-def');
+    const testConfig = {
+      'array-def': {
+        foo: [{ a: { b: 'customB', filler: 'customFiller' } }, { a: { b: 'anotherB' } }],
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('array-def');
+    expect(config.foo).toStrictEqual([
+      { a: { b: 'customB', filler: 'customFiller' } },
+      { a: { b: 'anotherB', filler: 'defaultFiller' } },
+    ]);
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('supports array element objects with their own simple arrays', async () => {
+    Config.defineConfigSchema('array-array-simple', {
+      foo: {
+        _default: [],
+        _type: Type.Array,
+        _elements: {
+          shishito: {
+            _type: Type.Array,
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('array-array-simple');
+
+    // Ensure sensible default behavior
+    const configDefault = await Config.getConfig('array-array-simple');
+    expect(configDefault.foo).toStrictEqual([]);
+    expect(console.error).not.toHaveBeenCalled();
+
+    // Ensure that the config is filled in correctly
+    const testConfig = {
+      'array-array-simple': {
+        foo: [{ shishito: [0] }, { shishito: [1, 2] }],
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('array-array-simple');
+    expect(config.foo).toStrictEqual([{ shishito: [0] }, { shishito: [1, 2] }]);
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('supports array element objects with their own arrays of objects', async () => {
+    Config.defineConfigSchema('array-array-def', {
+      tamago: {
+        _default: [],
+        _type: Type.Array,
+        _elements: {
+          yaki: {
+            _type: Type.Array,
+            _elements: {
+              negi: { _type: Type.String },
+              nasu: { _type: Type.String, _default: 'yum' },
+            },
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('array-array-def');
+
+    // Ensure sensible default behavior
+    const configDefault = await Config.getConfig('array-array-def');
+    expect(configDefault.tamago).toStrictEqual([]);
+    expect(console.error).not.toHaveBeenCalled();
+
+    // Ensure that the config is filled in correctly
+    const testConfig = {
+      'array-array-def': {
+        tamago: [{ yaki: [{ negi: 'one' }] }, { yaki: [{ negi: 'two', nasu: 'no' }, { negi: 'three' }] }],
+      },
+    };
+    Config.provide(testConfig);
+    const config = await Config.getConfig('array-array-def');
+    expect(config.tamago).toStrictEqual([
+      { yaki: [{ negi: 'one', nasu: 'yum' }] },
+      {
+        yaki: [
+          { negi: 'two', nasu: 'no' },
+          { negi: 'three', nasu: 'yum' },
+        ],
+      },
+    ]);
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('validates structure of array element objects with their own arrays of objects', async () => {
+    Config.defineConfigSchema('array-array-valid', {
+      tamago: {
+        _default: [],
+        _type: Type.Array,
+        _elements: {
+          yaki: {
+            _type: Type.Array,
+            _elements: {
+              negi: { _type: Type.String },
+              nasu: { _type: Type.String, _default: 'yum' },
+            },
+          },
+        },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('array-array-valid');
+    const testConfig = {
+      'array-array-valid': {
+        tamago: [{ yaki: { negi: 'one' } }],
+      },
+    };
+    Config.provide(testConfig);
+    await Config.getConfig('array-array-valid');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/tamago\[0\].*yaki.*array/i));
+  });
+});
+
+describe('type validations', () => {
+  beforeEach(() => {
+    console.error = vi.fn();
+  });
+
+  afterEach(resetAll);
+
+  it.each([
+    [Type.Array, 'doop'],
+    [Type.Boolean, 0],
+    [Type.ConceptUuid, 'Weight'],
+    [Type.Number, 'foo'],
+    [Type.Object, []],
+    [Type.String, 0],
+    [Type.UUID, 'not-valid'],
+  ])('validates %s type', async (configType, badValue) => {
+    Config.defineConfigSchema('foo-module', {
+      foo: { _default: 'qux', _type: configType },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({ 'foo-module': { foo: badValue } });
+    await Config.getConfig('foo-module');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(new RegExp(`${badValue}.*foo-module.*foo`, 'i')));
+  });
+});
+
+describe('processConfig', () => {
+  beforeEach(() => {
+    console.error = vi.fn();
+  });
+
+  afterEach(resetAll);
+
+  it('validates a config object', () => {
+    const schema = {
+      abe: {
+        _default: 'www.google.com',
+        _validators: [validators.isUrl],
+      },
+    };
+    const inputConfig = {
+      abe: true,
+    };
+    const config = Config.processConfig(schema, inputConfig, 'nowhere');
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/true.*nowhere\.abe.*url/i));
+    expect(config.abe).toBe(true);
+  });
+
+  it('interpolates defaults', () => {
+    const schema = {
+      foo: { _default: false },
+    };
+    const inputConfig = {};
+    const config = Config.processConfig(schema, inputConfig, 'nowhere');
+    expect(config.foo).toBe(false);
+    expect(console.error).not.toHaveBeenCalled();
+  });
+});
+
+describe('implementer tools config', () => {
+  afterEach(resetAll);
+
+  const implicitConfigImplementerToolsResult = {
+    'Display conditions': {
+      privileges: {
+        _default: [],
+        _description: expect.any(String),
+        _source: 'default',
+        _type: Type.Array,
+        _value: [],
+      },
+      expression: {
+        _default: undefined,
+        _description: expect.any(String),
+        _source: 'default',
+        _type: Type.String,
+        _value: undefined,
+      },
+    },
+    'Translation overrides': {
+      _default: {},
+      _description: expect.any(String),
+      _source: 'default',
+      _type: Type.Object,
+      _validators: [expect.any(Function)],
+      _value: {},
+    },
+  };
+
+  it('returns all config schemas, with values and sources interpolated', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: { _default: 'qux', _description: 'All the foo', _validators: [] },
+    });
+    Config.registerModuleLoad('foo-module');
+    Config.defineConfigSchema('bar-module', { bar: { _default: 'quinn' } });
+    Config.registerModuleLoad('bar-module');
+    const testConfig = { 'bar-module': { bar: 'baz' } };
+    Config.provide(testConfig, 'my config source');
+    const devConfig = implementerToolsConfigStore.getState().config;
+    expect(devConfig).toStrictEqual({
+      'foo-module': {
+        foo: {
+          _value: 'qux',
+          _source: 'default',
+          _default: 'qux',
+          _description: 'All the foo',
+          _validators: [],
+        },
+        ...implicitConfigImplementerToolsResult,
+      },
+      'bar-module': {
+        bar: { _value: 'baz', _source: 'my config source', _default: 'quinn' },
+        ...implicitConfigImplementerToolsResult,
+      },
+    });
+  });
+});
+
+describe('temporary config', () => {
+  beforeEach(() => {
+    console.error = vi.fn();
+  });
+
+  afterEach(resetAll);
+
+  it('allows overriding the existing config', async () => {
+    Config.defineConfigSchema('foo-module', { foo: { _default: 'qux' } });
+    Config.registerModuleLoad('foo-module');
+    const testConfig = { 'foo-module': { foo: 'baz' } };
+    Config.provide(testConfig);
+    temporaryConfigStore.setState({ config: { 'foo-module': { foo: 3 } } });
+    expect(temporaryConfigStore.getState().config).toStrictEqual({
+      'foo-module': { foo: 3 },
+    });
+    let config = await Config.getConfig('foo-module');
+    expect(config).toStrictEqual({ foo: 3 });
+    temporaryConfigStore.setState({
+      config: unset(temporaryConfigStore.getState(), ['foo-module', 'foo']) as any,
+    });
+    config = await Config.getConfig('foo-module');
+    expect(config).toStrictEqual({ foo: 'baz' });
+  });
+
+  it('can be gotten and cleared', async () => {
+    Config.defineConfigSchema('foo-module', { foo: { _default: 'qux' } });
+    Config.registerModuleLoad('foo-module');
+    temporaryConfigStore.setState({ config: { 'foo-module': { foo: 3 } } });
+    expect(temporaryConfigStore.getState().config).toStrictEqual({
+      'foo-module': { foo: 3 },
+    });
+    temporaryConfigStore.setState({ config: {} });
+    expect(temporaryConfigStore.getState()).toStrictEqual({ config: {} });
+    const config = await Config.getConfig('foo-module');
+    expect(config).toStrictEqual({ foo: 'qux' });
+  });
+
+  it('is not mutated by getConfig', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: {
+        bar: { _default: 'qux' },
+        baz: { _default: 'also qux' },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    await Config.getConfig('foo-module');
+    temporaryConfigStore.setState({
+      config: { 'foo-module': { foo: { bar: 3 } } },
+    });
+    await Config.getConfig('foo-module');
+    temporaryConfigStore.setState({
+      config: { 'foo-module': { foo: { bar: 4 } } },
+    });
+    expect(temporaryConfigStore.getState().config).toStrictEqual({
+      'foo-module': { foo: { bar: 4 } },
+    });
+  });
+});
+
+describe('extension slot config', () => {
+  beforeEach(() => {
+    console.error = vi.fn();
+  });
+
+  afterEach(resetAll);
+
+  it('returns an object with add, remove, and order keys. No schema needs to be defined', async () => {
+    // TODO: Here's the problem: right now extension slot configs are computed only for
+    // modules that define schemas.
+    Config.provide({
+      'foo-module': {
+        extensionSlots: {
+          fooSlot: {
+            add: ['bar', 'baz'],
+            remove: ['zap'],
+            order: ['qux', 'baz', 'bar'],
+            configure: { bar: { a: 0 } },
+          },
+        },
+      },
+    });
+    const { config } = getExtensionSlotsConfigStore().getState().slots['fooSlot'];
+    expect(config).toStrictEqual({
+      add: ['bar', 'baz'],
+      remove: ['zap'],
+      order: ['qux', 'baz', 'bar'],
+      configure: {
+        bar: {
+          a: 0,
+        },
+      },
+    });
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it("doesn't get returned by getConfig", async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: { _default: 0 },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({
+      'foo-module': {
+        extensionSlots: { fooSlot: { remove: ['bar'] } },
+      },
+    });
+    const config = await Config.getConfig('foo-module');
+    expect(config).toStrictEqual({ foo: 0 });
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it("isn't mutated by getConfig", async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: { _default: 0 },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({
+      'foo-module': {
+        extensionSlots: { fooSlot: { remove: ['bar'] } },
+      },
+    });
+    await Config.getConfig('foo-module');
+    const { config } = getExtensionSlotsConfigStore().getState().slots['fooSlot'];
+    expect(config).toStrictEqual({ remove: ['bar'] });
+  });
+
+  it('is included in implementerToolsConfigStore', async () => {
+    Config.defineConfigSchema('foo-module', {
+      foo: { _default: 0 },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    Config.provide({
+      'foo-module': {
+        extensionSlots: { fooSlot: { remove: ['bar'] } },
+      },
+    });
+    const config = implementerToolsConfigStore.getState().config;
+    expect(config).toStrictEqual({
+      'foo-module': {
+        foo: { _default: 0, _value: 0, _source: 'default' },
+        extensionSlots: {
+          fooSlot: {
+            remove: { _value: ['bar'], _source: 'provided' },
+          },
+        },
+        'Display conditions': expect.any(Object),
+        'Translation overrides': expect.any(Object),
+      },
+    });
+  });
+
+  it('validates that no other keys are present for the slot', async () => {
+    Config.provide({
+      'foo-module': {
+        extensionSlots: { fooSlot: { quitar: ['bar'] } },
+      },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('foo-module');
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/foo-module.extensionSlots.fooSlot.*invalid.*quitar/),
+    );
+  });
+});
+
+describe('extension config', () => {
+  beforeEach(() => {
+    console.error = vi.fn();
+    Config.defineConfigSchema('ext-mod', {
+      bar: { _default: 'barry' },
+      baz: { _default: 'bazzy' },
+    });
+    // load to trigger validation
+    Config.registerModuleLoad('ext-mod');
+  });
+
+  afterEach(resetAll);
+
+  it('returns the module config', async () => {
+    const moduleLevelConfig = { 'ext-mod': { bar: 'qux' } };
+    updateConfigExtensionStore();
+    Config.provide(moduleLevelConfig);
+    const result = getExtensionConfig('barSlot', 'fooExt').getState().config;
+    expect(result).toStrictEqual({
+      bar: 'qux',
+      baz: 'bazzy',
+      'Display conditions': { expression: undefined, privileges: [] },
+      'Translation overrides': {},
+    });
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it("uses the 'configure' config if one is present, with module config schema", () => {
+    updateConfigExtensionStore('fooExt#id0');
+    const configureConfig = {
+      'ext-mod': { bar: 'qux' },
+      'slot-mod': {
+        extensionSlots: {
+          barSlot: {
+            configure: { 'fooExt#id0': { baz: 'quiz' } },
+          },
+        },
+      },
+    };
+    Config.provide(configureConfig);
+    const result = getExtensionConfig('barSlot', 'fooExt#id0').getState().config;
+    expect(result).toStrictEqual({
+      bar: 'qux',
+      baz: 'quiz',
+      'Display conditions': { expression: undefined, privileges: [] },
+      'Translation overrides': {},
+    });
+    expect(console.error).not.toHaveBeenCalled();
+  });
+
+  it('validates the extension configure config, with module config schema', () => {
+    updateConfigExtensionStore('fooExt#id1');
+    const badConfig = {
+      'ext-mod': { bar: 'qux' },
+      'slot-mod': {
+        extensionSlots: {
+          barSlot: {
+            configure: { 'fooExt#id1': { beef: 'bad' } },
+          },
+        },
+      },
+    };
+    Config.provide(badConfig);
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/unknown config key 'ext-mod.beef' provided.*/i));
+  });
+
+  it('returns the extension config if an extension config schema is defined', async () => {
+    updateConfigExtensionStore('fooExt');
+    Config.defineExtensionConfigSchema('fooExt', {
+      qux: { _default: 'quxxy' },
+    });
+    Config.registerModuleLoad('fooExt');
+    const extensionAtBaseConfig = { fooExt: { qux: 'quxolotl' } };
+    Config.provide(extensionAtBaseConfig);
+    const result = getExtensionConfig('barSlot', 'fooExt').getState().config;
+    expect(result).toStrictEqual({
+      qux: 'quxolotl',
+      'Display conditions': { expression: undefined, privileges: [] },
+      'Translation overrides': {},
+    });
+  });
+
+  it("uses the 'configure' config if one is present, with extension config schema", () => {
+    updateConfigExtensionStore('fooExt#id2');
+    Config.defineExtensionConfigSchema('fooExt', {
+      qux: { _default: 'quxxy' },
+    });
+    Config.registerModuleLoad('fooExt');
+    const configureConfig = {
+      fooExt: { qux: 'quxolotl' },
+      'slot-mod': {
+        extensionSlots: {
+          barSlot: {
+            configure: { 'fooExt#id2': { qux: 'quxotic' } },
+          },
+        },
+      },
+    };
+    Config.provide(configureConfig);
+    const result = getExtensionConfig('barSlot', 'fooExt#id2').getState().config;
+    expect(result).toStrictEqual({
+      qux: 'quxotic',
+      'Display conditions': { expression: undefined, privileges: [] },
+      'Translation overrides': {},
+    });
+  });
+
+  it('validates the extension configure config, with extension config schema', () => {
+    updateConfigExtensionStore('fooExt#id3');
+    Config.defineExtensionConfigSchema('fooExt', {
+      qux: { _default: 'quxxy' },
+    });
+    Config.registerModuleLoad('fooExt');
+    const configureConfig = {
+      'slot-mod': {
+        extensionSlots: {
+          barSlot: {
+            configure: { 'fooExt#id3': { no: 'bad' } },
+          },
+        },
+      },
+    };
+    Config.provide(configureConfig);
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/unknown config key 'fooExt.no' provided.*/i));
+  });
+
+  it('does not accept module config parameters for extension if extension config schema is defined', () => {
+    updateConfigExtensionStore();
+    Config.defineExtensionConfigSchema('fooExt', {
+      qux: { _default: 'quxxy' },
+    });
+    Config.registerModuleLoad('fooExt');
+    const badConfigNoModuleConfigsForExtension = {
+      fooExt: {
+        bar: 'no good',
+      },
+    };
+    Config.provide(badConfigNoModuleConfigsForExtension);
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/unknown config key 'fooExt.bar' provided.*/i));
+  });
+
+  it('does not accept extension config parameters for the module', () => {
+    updateConfigExtensionStore('fooExt#id5');
+    Config.defineExtensionConfigSchema('fooExt', {
+      qux: { _default: 'quxxy' },
+    });
+    Config.registerModuleLoad('fooExt');
+    const badConfigNoExtensionConfigsForModule = {
+      'ext-mod': {
+        qux: 'also bad',
+      },
+    };
+    Config.provide(badConfigNoExtensionConfigsForModule);
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/unknown config key 'ext-mod.qux' provided.*/i));
+  });
+});
+
+describe('translation overrides', () => {
+  it('allows obtaining translation overrides before schema is registered', async () => {
+    console.error = vi.fn();
+    Config.provide({
+      'corge-module': {
+        'Translation overrides': {
+          en: {
+            'foo.bar': 'baz',
+          },
+        },
+        corges: true,
+      },
+    });
+    Config.registerModuleWithConfigSystem('corge-module');
+    const translationOverrides = await Config.getTranslationOverrides('corge-module');
+    expect(translationOverrides).toStrictEqual([
+      {
+        en: {
+          'foo.bar': 'baz',
+        },
+      },
+    ]);
+    Config.defineConfigSchema('corge-module', {
+      corges: { _default: false, _type: Type.Boolean },
+    });
+    const config = Config.getConfig('corge-module');
+    expect(config).resolves.toStrictEqual({ corges: true });
+    expect(console.error).not.toHaveBeenCalled();
+  });
+});
+
+function updateConfigExtensionStore(extensionId = 'fooExt') {
+  configExtensionStore.setState({
+    mountedExtensions: [
+      {
+        slotModuleName: 'slot-mod',
+        extensionModuleName: 'ext-mod',
+        slotName: 'barSlot',
+        extensionId,
+      },
+    ],
+  });
+}