feat(assertObjectMatchSpec): Compare object keys when doing a full match #44

Author: leguellec

src/core/assertions.js

@@ -28,41 +28,48 @@ const RuleName = Object.freeze({
 })
 
 /**
- * Count object properties including nested objects ones.
- * If a property is an object, its key is ignored.
+ * Make an array of keys from an object.
+ * Use a dot notation
+ * Only empty object keys are taken into account
+ * For subobjects only keys are taken into account
  *
  * @example
- * Assertions.countNestedProperties({
+ * Assertions.buildObjectKeysArray({
  *     a: true,
  *     b: true,
  *     c: true,
  * })
- * // => 3
- * Assertions.countNestedProperties({
+ * // => ["a", "b", "c"]
+ * Assertions.buildObjectKeysArray({
  *     a: true,
  *     b: true,
  *     c: {
- *         a: true,
- *         b: true,
+ *         d: true,
+ *         e: {},
+ *         f: {
+ *              g: true
+ *          }
  *     },
  * })
- * // => 4 (c is ignored because it's a nested object)
+ * // =>  ["a", "b", "c.d", "c.e", "c.f.g"] (c and c.f are ignored as non empty nested objects)
  *
  * @param {Object} object
  * @return {number}
  */
-exports.countNestedProperties = (object) => {
-    let propertiesCount = 0
+exports.buildObjectKeysArray = (object, dottedObjectKeys = [], currentPath = '') => {
     Object.keys(object).forEach((key) => {
         if (!_.isEmpty(object[key]) && typeof object[key] === 'object') {
-            const count = exports.countNestedProperties(object[key])
-            propertiesCount += count
+            dottedObjectKeys = exports.buildObjectKeysArray(
+                object[key],
+                dottedObjectKeys,
+                `${currentPath}${key}.`
+            )
         } else {
-            propertiesCount++
+            dottedObjectKeys.push(`${currentPath}${key}`)
         }
     })
 
-    return propertiesCount
+    return dottedObjectKeys
 }
 
 /**
@@ -106,10 +113,11 @@ exports.countNestedProperties = (object) => {
  * @param {boolean}           [exact=false] - if `true`, specification must match all object's properties
  */
 exports.assertObjectMatchSpec = (object, spec, exact = false) => {
+    const specPath = new Set()
     spec.forEach(({ field, matcher, value }) => {
         const currentValue = _.get(object, field)
         const expectedValue = Cast.value(value)
-
+        specPath.add(field)
         const rule = exports.getMatchingRule(matcher)
 
         switch (rule.name) {
@@ -208,11 +216,12 @@ exports.assertObjectMatchSpec = (object, spec, exact = false) => {
 
     // We check we have exactly the same number of properties as expected
     if (exact === true) {
-        const propertiesCount = exports.countNestedProperties(object)
+        const objectKeys = exports.buildObjectKeysArray(object)
+        const specObjectKeys = Array.from(specPath)
         expect(
-            propertiesCount,
+            objectKeys,
             'Expected json response to fully match spec, but it does not'
-        ).to.be.equal(spec.length)
+        ).to.be.deep.equal(specObjectKeys)
     }
 }
 

tests/core/assertions.test.js

@@ -1,6 +1,10 @@
 'use strict'
 
-const { countNestedProperties, assertObjectMatchSpec } = require('../../src/core/assertions')
+const {
+    countNestedProperties,
+    assertObjectMatchSpec,
+    buildObjectKeysArray,
+} = require('../../src/core/assertions')
 
 beforeAll(() => {
     const MockDate = (lastDate) => () => new lastDate(2018, 4, 1)
@@ -13,17 +17,17 @@ afterAll(() => {
 
 beforeEach(() => {})
 
-test('should allow to count object properties', () => {
+test('should allow to build an array of object properties', () => {
     expect(
-        countNestedProperties({
+        buildObjectKeysArray({
             a: true,
             b: true,
             c: true,
         })
-    ).toBe(3)
+    ).toStrictEqual(['a', 'b', 'c'])
 
     expect(
-        countNestedProperties({
+        buildObjectKeysArray({
             a: true,
             b: true,
             c: true,
@@ -32,53 +36,67 @@ test('should allow to count object properties', () => {
                 b: true,
             },
         })
-    ).toBe(5)
+    ).toStrictEqual(['a', 'b', 'c', 'd.a', 'd.b'])
 })
 
-test('should allow to count nested objects properties', () => {
+test('should allow to build an array of object propertieswith nested objects properties', () => {
     expect(
-        countNestedProperties({
+        buildObjectKeysArray({
             a: true,
             b: true,
             c: {
                 d: 'value1',
                 e: 'value2',
             },
         })
-    ).toBe(4)
+    ).toStrictEqual(['a', 'b', 'c.d', 'c.e'])
 })
 
-test('should allow to count object properties with null, undefined properties ', () => {
+test('should allow to build an array of object properties with null, undefined properties ', () => {
     expect(
-        countNestedProperties({
+        buildObjectKeysArray({
             a: null,
             b: undefined,
             c: 'value3',
         })
-    ).toBe(3)
+    ).toStrictEqual(['a', 'b', 'c'])
 })
 
-test('should allow to count object with properties array property', () => {
+test('should allow to build an array of object properties with properties array property', () => {
     expect(
-        countNestedProperties({
+        buildObjectKeysArray({
             a: [1, 2],
             b: true,
             c: true,
         })
-    ).toBe(4)
+    ).toStrictEqual(['a.0', 'a.1', 'b', 'c'])
 })
 
-test('should allow to count object properties with empty array property', () => {
+test('should allow to build an array of object properties with empty array property', () => {
     expect(
-        countNestedProperties({
+        buildObjectKeysArray({
             a: true,
             b: true,
             c: {
                 d: '',
                 e: [],
             },
         })
-    ).toBe(4)
+    ).toStrictEqual(['a', 'b', 'c.d', 'c.e'])
+})
+
+test('should allow to build an array of object properties from nested object', () => {
+    expect(
+        buildObjectKeysArray({
+            a: true,
+            b: {
+                b1: true,
+                b2: true,
+                b3: {},
+            },
+            c: true,
+        })
+    ).toStrictEqual(['a', 'b.b1', 'b.b2', 'b.b3', 'c'])
 })
 
 test('object property is defined', () => {
@@ -140,7 +158,12 @@ test('object property is not defined', () => {
     )
     expect(() =>
         assertObjectMatchSpec(
-            { name: 'john', gender: 'male', city: 'paris', street: 'rue du chat qui pêche' },
+            {
+                name: 'john',
+                gender: 'male',
+                city: 'paris',
+                street: 'rue du chat qui pêche',
+            },
             spec
         )
     ).toThrow(`Property 'name' is defined: expected 'john' to be undefined`)
@@ -227,35 +250,60 @@ test('check object property does not contain value', () => {
 
     expect(() =>
         assertObjectMatchSpec(
-            { first_name: 'foo', last_name: 'bar', city: 'miami', street: 'calle ocho' },
+            {
+                first_name: 'foo',
+                last_name: 'bar',
+                city: 'miami',
+                street: 'calle ocho',
+            },
             spec
         )
     ).not.toThrow()
     expect(() =>
         assertObjectMatchSpec(
-            { first_name: 'johnny', last_name: 'bar', city: 'miami', street: 'calle ocho' },
+            {
+                first_name: 'johnny',
+                last_name: 'bar',
+                city: 'miami',
+                street: 'calle ocho',
+            },
             spec
         )
     ).toThrow(
         `Property 'first_name' (johnny) contains 'john': expected 'johnny' to not include 'john'`
     )
     expect(() =>
         assertObjectMatchSpec(
-            { first_name: 'foo', last_name: 'doet', city: 'miami', street: 'calle ocho' },
+            {
+                first_name: 'foo',
+                last_name: 'doet',
+                city: 'miami',
+                street: 'calle ocho',
+            },
             spec
         )
     ).toThrow(`Property 'last_name' (doet) contains 'doe': expected 'doet' to not include 'doe'`)
     expect(() =>
         assertObjectMatchSpec(
-            { first_name: 'foo', last_name: 'bar', city: 'new york', street: 'calle ocho' },
+            {
+                first_name: 'foo',
+                last_name: 'bar',
+                city: 'new york',
+                street: 'calle ocho',
+            },
             spec
         )
     ).toThrow(
         `Property 'city' (new york) contains 'york': expected 'new york' to not include 'york'`
     )
     expect(() =>
         assertObjectMatchSpec(
-            { first_name: 'foo', last_name: 'bar', city: 'miami', street: 'krome avenue' },
+            {
+                first_name: 'foo',
+                last_name: 'bar',
+                city: 'miami',
+                street: 'krome avenue',
+            },
             spec
         )
     ).toThrow(
@@ -303,36 +351,6 @@ test('check object property does not match regexp', () => {
     )
 })
 
-test('check object fully matches spec', () => {
-    const spec = [
-        {
-            field: 'first_name',
-            matcher: 'equal',
-            value: 'john',
-        },
-        {
-            field: 'last_name',
-            matcher: 'match',
-            value: '^doe',
-        },
-    ]
-
-    expect(() =>
-        assertObjectMatchSpec({ first_name: 'john', last_name: 'doet' }, spec, true)
-    ).not.toThrow()
-    expect(() =>
-        assertObjectMatchSpec({ first_name: 'john', last_name: 'doet', gender: 'male' }, spec, true)
-    ).toThrow(`Expected json response to fully match spec, but it does not: expected 3 to equal 2`)
-    expect(() =>
-        assertObjectMatchSpec({ first_name: 'john', last_name: 'john' }, spec, true)
-    ).toThrow(`Property 'last_name' (john) does not match '^doe': expected 'john' to match /^doe/`)
-    expect(() =>
-        assertObjectMatchSpec({ first_name: 'doe', last_name: 'doe' }, spec, true)
-    ).toThrow(
-        `Expected property 'first_name' to equal 'john', but found 'doe': expected 'doe' to deeply equal 'john'`
-    )
-})
-
 test('check object property type', () => {
     const spec = [
         {
@@ -531,3 +549,69 @@ test('check unsupported matcher should fail', () => {
         `Matcher "unknown" did not match any supported assertions`
     )
 })
+
+test('check object fully matches spec', () => {
+    const spec = [
+        {
+            field: 'first_name',
+            matcher: 'equal',
+            value: 'john',
+        },
+        {
+            field: 'last_name',
+            matcher: 'match',
+            value: '^doe',
+        },
+        {
+            field: 'address',
+            matcher: 'type',
+            value: 'object',
+        },
+        {
+            field: 'phone.mobile',
+            matcher: 'match',
+            value: '^06',
+        },
+        {
+            field: 'phone.mobile',
+            matcher: 'type',
+            value: 'string',
+        },
+    ]
+
+    expect(() =>
+        assertObjectMatchSpec(
+            {
+                first_name: 'john',
+                last_name: 'doet',
+                address: {},
+                phone: { mobile: '0600000000' },
+            },
+            spec,
+            true
+        )
+    ).not.toThrow()
+    expect(() =>
+        assertObjectMatchSpec(
+            {
+                first_name: 'john',
+                last_name: 'doet',
+                gender: 'male',
+                address: {},
+                phone: { mobile: '0600000000' },
+            },
+            spec,
+            true
+        )
+    ).toThrow(
+        `Expected json response to fully match spec, but it does not: expected [ Array(5) ] to deeply equal [ Array(4) ]`
+    )
+    expect(() =>
+        assertObjectMatchSpec({ first_name: 'john', last_name: 'john' }, spec, true)
+    ).toThrow(`Property 'last_name' (john) does not match '^doe': expected 'john' to match /^doe/`)
+    expect(() =>
+        assertObjectMatchSpec({ first_name: 'doe', last_name: 'doe' }, spec, true)
+    ).toThrow(
+        `Expected property 'first_name' to equal 'john', but found 'doe': expected 'doe' to deeply equal 'john'`
+    )
+})