Add tests for config-ops

tests/lib/config/config-ops.js

@@ -11,6 +11,7 @@
 const assert = require("chai").assert,
     leche = require("leche"),
     environments = require("../../../conf/environments"),
+    configCache = require("../../../lib/config/config-cache"),
     ConfigOps = require("../../../lib/config/config-ops");
 
 const proxyquire = require("proxyquire").noCallThru().noPreserveCache();
@@ -519,6 +520,34 @@ describe("ConfigOps", () => {
 
                 assert.deepEqual(result, expectedResult);
             });
+
+            it("should work if overrides are null in the base config", () => {
+                const baseConfig = { overrides: null };
+                const customConfig = { overrides: [{ files: ["**/*.jsx"], ecmaFeatures: { jsx: true } }] };
+                const expectedResult = {
+                    overrides: [
+                        { files: ["**/*.jsx"], ecmaFeatures: { jsx: true } }
+                    ]
+                };
+
+                const result = ConfigOps.merge(baseConfig, customConfig);
+
+                assert.deepEqual(result, expectedResult);
+            });
+
+            it("should work if overrides are null in the custom config", () => {
+                const baseConfig = { overrides: [{ files: ["**/*Spec.js"], env: { mocha: true } }] };
+                const customConfig = { overrides: null };
+                const expectedResult = {
+                    overrides: [
+                        { files: ["**/*Spec.js"], env: { mocha: true } }
+                    ]
+                };
+
+                const result = ConfigOps.merge(baseConfig, customConfig);
+
+                assert.deepEqual(result, expectedResult);
+            });
         });
     });
 
@@ -838,4 +867,71 @@ describe("ConfigOps", () => {
 
     });
 
+    describe("getConfigFromVector()", () => {
+        beforeEach(() => {
+            configCache.reset();
+        });
+
+        it("should get from merged vector cache when present", () => {
+            const vector = ["configFile1", 1, "configFile2", 0, 1];
+            const merged = { merged: true };
+
+            configCache.setMergedVectorConfig(vector, merged);
+
+            const result = ConfigOps.getConfigFromVector(vector);
+
+            assert.deepEqual(result, merged);
+        });
+
+        it("should get from correct partial merged vector cache", () => {
+            const vector1 = ["configFile1", 1, "configFile2", 0, 1];
+
+            const vector2 = ["configFile1", 1, "configFile2", 0];
+            const merged2 = { mergedLevel2: true };
+
+            const vector3 = ["configFile1", 1];
+            const merged3 = { mergedLevel3: true };
+
+            const config2 = { overrides: [{}, { files: "pattern2", rules: { foo2: "off" } }] };
+
+            configCache.setMergedVectorConfig(vector2, merged2);
+            configCache.setMergedVectorConfig(vector3, merged3);
+            configCache.setConfig("configFile2", config2);
+
+            const result = ConfigOps.getConfigFromVector(vector1);
+
+            assert.isTrue(result.mergedLevel2);
+            assert.isUndefined(result.mergedLevel3);
+            assert.equal(result.rules.foo2, "off");
+        });
+
+        it("should get from raw cached configs when no merged vectors are cached", () => {
+            const config = [
+                {
+                    rules: { foo1: "off" },
+                    overrides: [
+                        { files: "pattern1", rules: { foo1: "warn" } },
+                        { files: "pattern2", rules: { foo1: "error" } }
+                    ]
+                },
+                {
+                    rules: { foo2: "warn" },
+                    overrides: [
+                        { files: "pattern1", rules: { foo2: "error" } },
+                        { files: "pattern2", rules: { foo2: "off" } }
+                    ]
+                }
+            ];
+
+            configCache.setConfig("configFile1", config[0]);
+            configCache.setConfig("configFile2", config[1]);
+
+            const vector = ["configFile1", 1, "configFile2", 0, 1];
+
+            const result = ConfigOps.getConfigFromVector(vector);
+
+            assert.equal(result.rules.foo1, "error");
+            assert.equal(result.rules.foo2, "off");
+        });
+    });
 });