Refactor mergeConfig without utils.deepMerge (#2844)

* Adding failing test

* Fixing #2587 default custom config persisting

* Adding Concat keys and filter duplicates

* Fixed value from CPE

* update for review feedbacks

* no deepMerge

* only merge between plain objects

* fix rename

* always merge config by mergeConfig

* extract function mergeDeepProperties

* refactor mergeConfig with all keys, and add special logic for validateStatus

* add test for resetting headers

* add lots of tests and fix a bug

* should not inherit `data`

* use simple toString

* revert #1845

Co-authored-by: David Tanner <david.tanner@lifeomic.com>
Co-authored-by: Justin Beckwith <justin.beckwith@gmail.com>

test/specs/utils/deepMerge.spec.js

@@ -1,66 +0,0 @@
-var deepMerge = require('../../../lib/utils').deepMerge;
-
-describe('utils::deepMerge', function () {
-  it('should be immutable', function () {
-    var a = {};
-    var b = {foo: 123};
-    var c = {bar: 456};
-
-    deepMerge(a, b, c);
-
-    expect(typeof a.foo).toEqual('undefined');
-    expect(typeof a.bar).toEqual('undefined');
-    expect(typeof b.bar).toEqual('undefined');
-    expect(typeof c.foo).toEqual('undefined');
-  });
-
-  it('should deepMerge properties', function () {
-    var a = {foo: 123};
-    var b = {bar: 456};
-    var c = {foo: 789};
-    var d = deepMerge(a, b, c);
-
-    expect(d.foo).toEqual(789);
-    expect(d.bar).toEqual(456);
-  });
-
-  it('should deepMerge recursively', function () {
-    var a = {foo: {bar: 123}};
-    var b = {foo: {baz: 456}, bar: {qux: null}};
-
-    expect(deepMerge(a, b)).toEqual({
-      foo: {
-        bar: 123,
-        baz: 456
-      },
-      bar: {
-        qux: null
-      }
-    });
-  });
-
-  it('should remove all references from nested objects', function () {
-    var a = {foo: {bar: 123}};
-    var b = {};
-    var d = deepMerge(a, b);
-
-    expect(d).toEqual({
-      foo: {
-        bar: 123
-      }
-    });
-
-    expect(d.foo).not.toBe(a.foo);
-  });
-
-  it('handles null and undefined arguments', function () {
-    expect(deepMerge(undefined, undefined)).toEqual(undefined);
-    expect(deepMerge(undefined, {foo: 123})).toEqual({foo: 123});
-    expect(deepMerge({foo: 123}, undefined)).toEqual(undefined);
-
-    expect(deepMerge(null, null)).toEqual(null);
-    expect(deepMerge(null, {foo: 123})).toEqual({foo: 123});
-    expect(deepMerge({foo: 123}, null)).toEqual(null);
-  });
-});
-

test/specs/utils/isX.spec.js

@@ -47,9 +47,17 @@ describe('utils::isX', function () {
 
   it('should validate Object', function () {
     expect(utils.isObject({})).toEqual(true);
+    expect(utils.isObject([])).toEqual(true);
     expect(utils.isObject(null)).toEqual(false);
   });
 
+  it('should validate plain Object', function () {
+    expect(utils.isPlainObject({})).toEqual(true);
+    expect(utils.isPlainObject([])).toEqual(false);
+    expect(utils.isPlainObject(null)).toEqual(false);
+    expect(utils.isPlainObject(Object.create({}))).toEqual(false);
+  });
+
   it('should validate Date', function () {
     expect(utils.isDate(new Date())).toEqual(true);
     expect(utils.isDate(Date.now())).toEqual(false);

test/specs/utils/merge.spec.js

@@ -38,5 +38,47 @@ describe('utils::merge', function () {
       }
     });
   });
-});
 
+  it('should remove all references from nested objects', function () {
+    var a = {foo: {bar: 123}};
+    var b = {};
+    var d = merge(a, b);
+
+    expect(d).toEqual({
+      foo: {
+        bar: 123
+      }
+    });
+
+    expect(d.foo).not.toBe(a.foo);
+  });
+
+  it('handles null and undefined arguments', function () {
+    expect(merge(undefined, undefined)).toEqual({});
+    expect(merge(undefined, {foo: 123})).toEqual({foo: 123});
+    expect(merge({foo: 123}, undefined)).toEqual({foo: 123});
+
+    expect(merge(null, null)).toEqual({});
+    expect(merge(null, {foo: 123})).toEqual({foo: 123});
+    expect(merge({foo: 123}, null)).toEqual({foo: 123});
+  });
+
+  it('should replace properties with null', function () {
+    expect(merge({}, {a: null})).toEqual({a: null});
+    expect(merge({a: null}, {})).toEqual({a: null});
+  });
+
+  it('should replace properties with arrays', function () {
+    expect(merge({}, {a: [1, 2, 3]})).toEqual({a: [1, 2, 3]});
+    expect(merge({a: 2}, {a: [1, 2, 3]})).toEqual({a: [1, 2, 3]});
+    expect(merge({a: {b: 2}}, {a: [1, 2, 3]})).toEqual({a: [1, 2, 3]});
+  });
+
+  it('should replace properties with cloned arrays', function () {
+    var a = [1, 2, 3];
+    var d = merge({}, {a: a});
+
+    expect(d).toEqual({a: [1, 2, 3]});
+    expect(d.a).not.toBe(a);
+  });
+});