prettier --write '**/*.js'

unexpectedjs · Nov 19, 2020 · 0033de7 · 0033de7
1 parent 101bd87
commit 0033de7
Show file tree

Hide file tree

Showing 8 changed files with 174 additions and 180 deletions.
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -5,16 +5,16 @@ const config = {
     'import/no-unresolved': ['error', { commonjs: true }],
     'mocha/no-exclusive-tests': 'error',
     'mocha/no-nested-tests': 'error',
-    'mocha/no-identical-title': 'error'
+    'mocha/no-identical-title': 'error',
   },
   overrides: [
     {
       files: ['test/**/*.js'],
       env: {
-        mocha: true
-      }
-    }
-  ]
+        mocha: true,
+      },
+    },
+  ],
 };
 
 module.exports = config;
diff --git a/lib/unexpectedMap.js b/lib/unexpectedMap.js
@@ -20,7 +20,7 @@ function getFunctionName(f) {
 
 function retrieveMapValues(theMap) {
   const values = [];
-  theMap.forEach(value => {
+  theMap.forEach((value) => {
     values.push(value);
   });
   return values;
@@ -33,22 +33,16 @@ class MapValue {
 }
 
 function createUnexpectedMap(expect) {
-  expect.addStyle('propertyForMap', function(key, inspectedValue) {
-    this.text('[')
-      .appendInspected(key)
-      .text(',')
-      .sp()
-      .append(inspectedValue);
+  expect.addStyle('propertyForMap', function (key, inspectedValue) {
+    this.text('[').appendInspected(key).text(',').sp().append(inspectedValue);
   });
 
-  expect.addStyle('propertyForMapInSatisfy', function(
+  expect.addStyle('propertyForMapInSatisfy', function (
     key,
     inspectedValue,
     isValueDiff
   ) {
-    this.text('[')
-      .appendInspected(key)
-      .text(',');
+    this.text('[').appendInspected(key).text(',');
     if (isValueDiff) {
       this.nl().sp(2);
     } else {
@@ -82,7 +76,7 @@ function createUnexpectedMap(expect) {
     },
     suffix(output) {
       return output;
-    }
+    },
   });
 
   const objectType = expect.getType('object');
@@ -140,7 +134,7 @@ function createUnexpectedMap(expect) {
       return output;
     },
     getKeys: Object.getOwnPropertySymbols
-      ? function(obj) {
+      ? function (obj) {
           const keys = this.retrieveKeys(obj);
           const symbols = Object.getOwnPropertySymbols(obj);
           if (symbols.length > 0) {
@@ -149,7 +143,7 @@ function createUnexpectedMap(expect) {
             return keys;
           }
         }
-      : function(obj) {
+      : function (obj) {
           return this.retrieveKeys(obj);
         },
     hasKey(obj, key) {
@@ -165,7 +159,7 @@ function createUnexpectedMap(expect) {
     uniqueKeys(subjectKeys, valueKeys) {
       const subjectKeysSet = new Set(subjectKeys);
       const uniqueValueKeys = valueKeys.filter(
-        valueKey => !subjectKeysSet.has(valueKey)
+        (valueKey) => !subjectKeysSet.has(valueKey)
       );
 
       const uniqueKeys = [...subjectKeys, ...uniqueValueKeys];
@@ -174,7 +168,7 @@ function createUnexpectedMap(expect) {
     },
     valueForKey(obj, key) {
       return new MapValue(obj.get(key));
-    }
+    },
   });
 
   expect.addAssertion('<Map> [not] to be empty', (expect, subject) => {
@@ -190,20 +184,20 @@ function createUnexpectedMap(expect) {
       () => {
         expect(expect.equal(value, subject), 'to be truthy');
       },
-      e => {
+      (e) => {
         expect.fail({
           label: 'should equal',
           diff(output, diff) {
             return diff(subject, value);
-          }
+          },
         });
       }
     );
   });
 
   expect.addAssertion('<Map> to equal <any>', (expect, actual, expected) => {
     expect.fail({
-      diff: output => {
+      diff: (output) => {
         return output
           .text('Mismatching constructors ')
           .text(
@@ -215,7 +209,7 @@ function createUnexpectedMap(expect) {
             (expected.constructor && getFunctionName(expected.constructor)) ||
               expected.constructor
           );
-      }
+      },
     });
   });
 
@@ -256,17 +250,17 @@ function createUnexpectedMap(expect) {
         .all([
           expect.promise(() => {
             if (expect.flags.exhaustively) {
-              const nonOwnKeysWithDefinedValues = keys.filter(key => {
+              const nonOwnKeysWithDefinedValues = keys.filter((key) => {
                 return (
                   !Object.prototype.hasOwnProperty.call(subject, key) &&
                   typeof subject[key] !== 'undefined'
                 );
               });
-              const valueKeysWithDefinedValues = keys.filter(key => {
+              const valueKeysWithDefinedValues = keys.filter((key) => {
                 const valueKey = value.get(key);
                 return typeof valueKey !== 'undefined';
               });
-              const subjectKeysWithDefinedValues = subjectKeys.filter(key => {
+              const subjectKeysWithDefinedValues = subjectKeys.filter((key) => {
                 const subjectKey = subject.get(key);
                 return typeof subjectKey !== 'undefined';
               });
@@ -278,7 +272,7 @@ function createUnexpectedMap(expect) {
               );
             }
           }),
-          expect.promise.all(promisesInFlight)
+          expect.promise.all(promisesInFlight),
         ])
         .caught(() => {
           return expect.promise.settle(promisesInFlight).then(() => {
@@ -288,7 +282,7 @@ function createUnexpectedMap(expect) {
                 const valueKeys = valueType.getKeys(value);
                 const uniqueKeys = subjectType
                   .uniqueKeys(subjectKeys, valueKeys)
-                  .filter(key => {
+                  .filter((key) => {
                     const valueKey = value.get(key);
                     const subjectHasKey = subject.has(key);
                     // Skip missing keys expected to be missing so they don't get rendered in the diff
@@ -310,7 +304,7 @@ function createUnexpectedMap(expect) {
                   output
                     .nl(index > 0 ? 1 : 0)
                     .i()
-                    .block(function() {
+                    .block(function () {
                       let valueOutput;
                       const annotation = output.clone();
                       let conflicting;
@@ -416,7 +410,7 @@ function createUnexpectedMap(expect) {
                             valueOutput.sp();
                           }
 
-                          valueOutput.annotationBlock(function() {
+                          valueOutput.annotationBlock(function () {
                             this.append(annotation);
                           });
                         }
@@ -435,7 +429,7 @@ function createUnexpectedMap(expect) {
 
                       if (isExhaustiveValueDiff) {
                         output
-                          .annotationBlock(function() {
+                          .annotationBlock(function () {
                             this.append(annotation);
                           })
                           .text(':')
@@ -454,7 +448,7 @@ function createUnexpectedMap(expect) {
                 return output
                   .nl(suffixOutput.isEmpty() ? 0 : 1)
                   .append(suffixOutput);
-              }
+              },
             });
           });
         });
@@ -464,7 +458,7 @@ function createUnexpectedMap(expect) {
   expect.addAssertion(
     [
       '<Map> to have values [exhaustively] satisfying <any>',
-      '<Map> to have values [exhaustively] satisfying <assertion>'
+      '<Map> to have values [exhaustively] satisfying <assertion>',
     ],
     (expect, subject, nextArg) => {
       expect.errorMode = 'nested';
@@ -473,11 +467,11 @@ function createUnexpectedMap(expect) {
 
       const expected = new Map();
       const keys = expect.subjectType.getKeys(subject);
-      keys.forEach(key => {
+      keys.forEach((key) => {
         if (typeof nextArg === 'string') {
           expected.set(
             key,
-            expect.it(s => expect.shift(s))
+            expect.it((s) => expect.shift(s))
           );
         } else {
           expected.set(key, nextArg);
@@ -488,7 +482,7 @@ function createUnexpectedMap(expect) {
         () => {
           return expect(subject, 'to [exhaustively] satisfy', expected);
         },
-        err => {
+        (err) => {
           expect.fail({
             message(output) {
               output.append(
@@ -499,7 +493,7 @@ function createUnexpectedMap(expect) {
               const diff = err.getDiff({ output });
               diff.inline = true;
               return diff;
-            }
+            },
           });
         }
       );
@@ -516,5 +510,5 @@ function createUnexpectedMap(expect) {
 
 module.exports = {
   name: 'unexpected-map',
-  installInto: createUnexpectedMap
+  installInto: createUnexpectedMap,
 };
diff --git a/test/assertions/Map.to-be-empty.spec.js b/test/assertions/Map.to-be-empty.spec.js
@@ -9,7 +9,7 @@ describe('to be empty assertion', () => {
       new Map([
         [1, 'foo'],
         [2, 'bar'],
-        [3, 'baz']
+        [3, 'baz'],
       ]),
       'not to be empty'
     );
@@ -22,7 +22,7 @@ describe('to be empty assertion', () => {
           new Map([
             [1, 'foo'],
             [2, 'bar'],
-            [3, 'baz']
+            [3, 'baz'],
           ]),
           'to be empty'
         );

diff --git a/test/assertions/Map.to-equal.spec.js b/test/assertions/Map.to-equal.spec.js
@@ -1,14 +1,14 @@
 /* global expect */
-describe('to equal assertion', function() {
+describe('to equal assertion', function () {
   it('should show two maps being equal', () => {
-    expect(function() {
+    expect(function () {
       expect(new Map([['foo', 123]]), 'to equal', new Map([['foo', 123]]));
     }, 'not to throw');
   });
 
   it('should show two maps not being equal (subject)', () => {
     expect(
-      function() {
+      function () {
         expect(new Map([[{}, 123]]), 'to equal', new Map([[{}, 123]]));
       },
       'to throw an error satisfying',
@@ -26,7 +26,7 @@ describe('to equal assertion', function() {
 
   it('should show two maps not being equal (value)', () => {
     expect(
-      function() {
+      function () {
         expect(new Map([[123, {}]]), 'to equal', new Map([[123, {}]]));
       },
       'to throw an error satisfying',

diff --git a/test/assertions/Map.to-have-values-satisfying.spec.js b/test/assertions/Map.to-have-values-satisfying.spec.js
@@ -1,13 +1,13 @@
 /* global expect */
-describe('to have values satisfying assertion', function() {
-  it('should pass with an assertion', function() {
-    expect(function() {
+describe('to have values satisfying assertion', function () {
+  it('should pass with an assertion', function () {
+    expect(function () {
       expect(new Map([[[], null]]), 'to have values satisfying', 'to be null');
     }, 'not to error');
   });
 
-  it('should pass with an expect.it', function() {
-    expect(function() {
+  it('should pass with an expect.it', function () {
+    expect(function () {
       expect(
         new Map([[[], null]]),
         'to have values satisfying',
@@ -16,21 +16,21 @@ describe('to have values satisfying assertion', function() {
     }, 'not to error');
   });
 
-  it('should pass with an object value and satisfy semantics', function() {
-    expect(function() {
+  it('should pass with an object value and satisfy semantics', function () {
+    expect(function () {
       expect(new Map([[[], { foo: null }]]), 'to have values satisfying', {
-        foo: expect.it('to be falsy')
+        foo: expect.it('to be falsy'),
       });
     }, 'not to error');
   });
 
   it('fails if the given Map is empty', () => {
     expect(
-      function() {
+      function () {
         expect(
           new Map(),
           'to have values satisfying',
-          expect.it(value => {
+          expect.it((value) => {
             expect(value, 'to equal', '0');
           })
         );
@@ -47,11 +47,11 @@ describe('to have values satisfying assertion', function() {
     );
   });
 
-  it('should render a diff when failing "to have values satisfying"', function() {
+  it('should render a diff when failing "to have values satisfying"', function () {
     expect(
-      function() {
+      function () {
         expect(new Map([[[], { foo: null }]]), 'to have values satisfying', {
-          foo: expect.it('to be a number')
+          foo: expect.it('to be a number'),
         });
       },
       'to throw an error satisfying',