Add tests to check config modifications are persisted.

When updating the configuration object, we want to make sure changes are
persisted to disk so this commit adds tests to check that functionality
does what is expected.

Author: rossjones

lib/importer/package-lock.json

@@ -29,6 +29,7 @@
     "eslint": "^9.19.0",
     "eslint-plugin-jest": "^28.11.0",
     "globals": "^15.14.0",
+    "mock-fs": "^5.5.0",
     "jest": "^29.7.0"
   }
 }

lib/importer/package.json

@@ -0,0 +1,97 @@
+var assert = require('assert');
+const cfg = require('./config');
+const fs = require('node:fs');
+const mock_files = require('mock-fs');
+
+mock_files({
+    './empty/app/config.json': '{}',
+    './fields/app/config.json': '{"fields": ["A", "B", "C"]}',
+    './path/app/config.json': '{"uploadPath": "/tmp"}',
+});
+
+describe("Configuration tests", () => {
+    // Restore the original fs after tests so that we
+    // don't break any other use of the fs module.
+    afterAll(() => { mock_files.restore(); })
+
+    test('initial empty config', () => {
+        withCurrent(
+            "./empty",
+            new cfg.PluginConfig(),
+            (c) => {
+                c.setFields(["A"])
+            },
+            (original, updated, c) => {
+                expect(original.fields).toBeUndefined()
+                expect(updated.fields).toStrictEqual(["A"])
+                expect(c.fields).toStrictEqual(["A"])
+
+                // We expect a non-null value by default, but can't construct something
+                // to compare against as the tmp directory given may be different on
+                // each call
+                expect(original.uploadPath).not.toBeNull()
+                expect(updated.uploadPath).not.toBeNull()
+                expect(c.uploadPath).not.toBeNull()
+            }
+        );
+    });
+
+    test('existing fields', () => {
+        withCurrent(
+            "./fields",
+            new cfg.PluginConfig(),
+            (c) => {
+                c.setFields(["A", "B"])
+            },
+            (original, updated, c) => {
+                expect(original.fields).toStrictEqual(["A", "B", "C"])
+                expect(updated.fields).toStrictEqual(["A", "B"])
+                expect(c.fields).toStrictEqual(["A", "B"])
+            }
+        );
+    });
+
+    test('existing path', () => {
+        withCurrent(
+            "./path",
+            new cfg.PluginConfig(),
+            (c) => {
+                c.setUploadPath("/opt")
+            },
+            (original, updated, c) => {
+                expect(original.uploadPath).toBe("/tmp")
+                expect(updated.uploadPath).toBe("/opt")
+                expect(c.uploadPath).toBe("/opt")
+            }
+        );
+    });
+
+})
+
+
+// withCurrent is a helper function which is used to load a plugin config
+// apply some changes, and then assert the expectations of the state.
+//
+//      rootFolder is the folder where the `app/config.json` can
+//      be found in this test.
+//
+//      pluginConfig is a newly constructed PluginConfig
+//
+//      cbFunction is a callback function that will be given the
+//      plugin configuration so that changes can be made via its API.
+//
+//      assertionsFunc is a function that is provided with:
+//          * the original json object (before cbFunction was called)
+//          * the new json object post-cbFunction
+//          * the pluginConfig that was modified by cbFunction
+function withCurrent(rootFolder, pluginConfig, cbFunction, assertionsFunc) {
+    assert(typeof (cbFunction) === 'function')
+    assert(typeof (assertionsFunc) === 'function')
+
+    process.env.KIT_PROJECT_DIR = rootFolder
+
+    const original = JSON.parse(fs.readFileSync(pluginConfig.configPath, 'utf8'));
+    cbFunction(pluginConfig)
+    const updated = JSON.parse(fs.readFileSync(pluginConfig.configPath, 'utf8'));
+    assertionsFunc(original, updated, pluginConfig)
+}