Added test cases.

src/node/utils/Settings.ts

@@ -705,8 +705,6 @@ const lookupEnvironmentVariables = (obj: MapArrayType<any>) => {
 
     replaceEnvs(obj);
 
-    const envVars: MapArrayType<any> = {}
-
     // Add plugin ENV variables
 
     /**
@@ -720,7 +718,6 @@ const lookupEnvironmentVariables = (obj: MapArrayType<any>) => {
         if (!env.startsWith("EP")) continue
         treeEntries.set(env, envVal)
     }
-
     treeEntries.forEach((value, key) => {
         let pathToKey = key.split("__")
         let currentNode = root
@@ -730,9 +727,9 @@ const lookupEnvironmentVariables = (obj: MapArrayType<any>) => {
     })
 
     //console.log(root.collectFromLeafsUpwards())
-    //const rooting = root.collectFromLeafsUpwards()
+    const rooting = root.collectFromLeafsUpwards()
-
+    console.log("Rooting is", rooting.ADMIN)
-    obj = Object.assign(obj, envVars)
+    obj = Object.assign(obj, rooting)
     return obj;
 };
 

src/node/utils/SettingsTree.ts

@@ -73,23 +73,6 @@ export class SettingsNode {
         return collected;
     }
 
-
-    public transformObjectWithArrays() {
-        function isNumeric(str: string|object) {
-            if (typeof str != "string") return false // we only process strings!
-            // @ts-ignore
-            return !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
-                !isNaN(parseFloat(str)) // ...and ensure strings of whitespace fail
-        }
-        let collected: MapArrayType<any> = {};
-        for (const key in this.children) {
-            if (isNumeric(key)) {
-                Object.entries(this.children).map(([key, value]) => {
-                })
-            }
-        }
-    }
-
     coerceValue = (stringValue: string) => {
         // cooked from https://stackoverflow.com/questions/175739/built-in-way-in-javascript-to-check-if-a-string-is-a-valid-number
         // @ts-ignore

src/tests/backend/specs/settings.ts

@@ -6,56 +6,87 @@ import path from 'path';
 import process from 'process';
 
 describe(__filename, function () {
-  describe('parseSettings', function () {
+    describe('parseSettings', function () {
-    let settings:any;
+        let settings: any;
-    const envVarSubstTestCases = [
+        const envVarSubstTestCases = [
-      {name: 'true', val: 'true', var: 'SET_VAR_TRUE', want: true},
+            {name: 'true', val: 'true', var: 'SET_VAR_TRUE', want: true},
-      {name: 'false', val: 'false', var: 'SET_VAR_FALSE', want: false},
+            {name: 'false', val: 'false', var: 'SET_VAR_FALSE', want: false},
-      {name: 'null', val: 'null', var: 'SET_VAR_NULL', want: null},
+            {name: 'null', val: 'null', var: 'SET_VAR_NULL', want: null},
-      {name: 'undefined', val: 'undefined', var: 'SET_VAR_UNDEFINED', want: undefined},
+            {name: 'undefined', val: 'undefined', var: 'SET_VAR_UNDEFINED', want: undefined},
-      {name: 'number', val: '123', var: 'SET_VAR_NUMBER', want: 123},
+            {name: 'number', val: '123', var: 'SET_VAR_NUMBER', want: 123},
-      {name: 'string', val: 'foo', var: 'SET_VAR_STRING', want: 'foo'},
+            {name: 'string', val: 'foo', var: 'SET_VAR_STRING', want: 'foo'},
-      {name: 'empty string', val: '', var: 'SET_VAR_EMPTY_STRING', want: ''},
+            {name: 'empty string', val: '', var: 'SET_VAR_EMPTY_STRING', want: ''},
-    ];
+        ];
 
-    before(async function () {
+        before(async function () {
-      for (const tc of envVarSubstTestCases) process.env[tc.var] = tc.val;
+            for (const tc of envVarSubstTestCases) process.env[tc.var] = tc.val;
-      delete process.env.UNSET_VAR;
+            delete process.env.UNSET_VAR;
-      settings = parseSettings(path.join(__dirname, 'settings.json'), true);
+            settings = parseSettings(path.join(__dirname, 'settings.json'), true);
-      assert(settings != null);
+            assert(settings != null);
-    });
-
-    describe('environment variable substitution', function () {
-      describe('set', function () {
-        for (const tc of envVarSubstTestCases) {
-          it(tc.name, async function () {
-            const obj = settings['environment variable substitution'].set;
-            if (tc.name === 'undefined') {
-              assert(!(tc.name in obj));
-            } else {
-              assert.equal(obj[tc.name], tc.want);
-            }
-          });
-        }
-      });
-
-      describe('unset', function () {
-        it('no default', async function () {
-          const obj = settings['environment variable substitution'].unset;
-          assert.equal(obj['no default'], null);
         });
 
-        for (const tc of envVarSubstTestCases) {
+        describe('environment variable substitution', function () {
-          it(tc.name, async function () {
+            describe('set', function () {
-            const obj = settings['environment variable substitution'].unset;
+                for (const tc of envVarSubstTestCases) {
-            if (tc.name === 'undefined') {
+                    it(tc.name, async function () {
-              assert(!(tc.name in obj));
+                        const obj = settings['environment variable substitution'].set;
-            } else {
+                        if (tc.name === 'undefined') {
-              assert.equal(obj[tc.name], tc.want);
+                            assert(!(tc.name in obj));
-            }
+                        } else {
-          });
+                            assert.equal(obj[tc.name], tc.want);
-        }
+                        }
-      });
+                    });
+                }
+            });
+
+            describe('unset', function () {
+                it('no default', async function () {
+                    const obj = settings['environment variable substitution'].unset;
+                    assert.equal(obj['no default'], null);
+                });
+
+                for (const tc of envVarSubstTestCases) {
+                    it(tc.name, async function () {
+                        const obj = settings['environment variable substitution'].unset;
+                        if (tc.name === 'undefined') {
+                            assert(!(tc.name in obj));
+                        } else {
+                            assert.equal(obj[tc.name], tc.want);
+                        }
+                    });
+                }
+            });
+        });
     });
-  });
+
+
+    describe("Parse plugin settings", function () {
+
+        before(async function () {
+            process.env["EP__ADMIN__PASSWORD"] = "test"
+        })
+
+        it('should parse plugin settings', async function () {
+            let settings = parseSettings(path.join(__dirname, 'settings.json'), true);
+            assert.equal(settings.ADMIN.PASSWORD, "test");
+        })
+
+        it('should bundle settings with same path', async function () {
+            process.env["EP__ADMIN__USERNAME"] = "test"
+            let settings = parseSettings(path.join(__dirname, 'settings.json'), true);
+            assert.deepEqual(settings.ADMIN, {PASSWORD: "test", USERNAME: "test"});
+        })
+
+        it("Can set the ep themes", async function () {
+            process.env["EP__ep_themes__default_theme"] = "hacker"
+            let settings = parseSettings(path.join(__dirname, 'settings.json'), true);
+            assert.deepEqual(settings.ep_themes, {"default_theme": "hacker"});
+        })
+
+        it("can set the ep_webrtc settings", async function () {
+            process.env["EP__ep_webrtc__enabled"] = "true"
+            let settings = parseSettings(path.join(__dirname, 'settings.json'), true);
+            assert.deepEqual(settings.ep_webrtc, {"enabled": true});
+        })
+    })
 });