jest-matchers - npm Package Compare versions

Comparing version 14.0.0 to 14.2.0-alpha.ca8bfb6e

build/index.js

@@ -28,8 +28,8 @@ /**
   Object.defineProperty(
-  global, 
-  GLOBAL_MATCHERS_OBJECT_SYMBOL, 
-  { value: Object.create(null) });}
+  global,
+  GLOBAL_MATCHERS_OBJECT_SYMBOL,
+  { value: Object.create(null) });
 
+}
 
-
 const expect = actual => {
@@ -39,21 +39,21 @@ const allMatchers = global[GLOBAL_MATCHERS_OBJECT_SYMBOL];
   Object.keys(allMatchers).forEach(name => {
-    expectation[name] = 
+    expectation[name] =
     makeThrowingMatcher(allMatchers[name], false, actual);
-    expectation.not[name] = 
-    makeThrowingMatcher(allMatchers[name], true, actual);});
+    expectation.not[name] =
+    makeThrowingMatcher(allMatchers[name], true, actual);
+  });
 
+  return expectation;
+};
 
-  return expectation;};
-
-
 const makeThrowingMatcher = (
-matcher, 
-isNot, 
-actual) => 
+matcher,
+isNot,
+actual) =>
 {
   return function throwingMatcher(expected, options) {
     const result = matcher(
-    actual, 
-    expected, 
-    options, 
+    actual,
+    expected,
+    options,
     { args: arguments });
@@ -68,17 +68,17 @@
       if (typeof message === 'function') {
-        message = message();}
+        message = message();
+      }
 
-
       const error = new Error(message);
       // Remove this function from the stack trace frame.
       Error.captureStackTrace(error, throwingMatcher);
-      throw error;}};};
+      throw error;
+    }
+  };
+};
 
-
-
-
 const addMatchers = matchersObj => {
-  Object.assign(global[GLOBAL_MATCHERS_OBJECT_SYMBOL], matchersObj);};
+  Object.assign(global[GLOBAL_MATCHERS_OBJECT_SYMBOL], matchersObj);
+};
 
-
 // add default jest matchers
@@ -88,4 +88,4 @@ addMatchers(matchers);
 
-module.exports = { 
-  addMatchers, 
+module.exports = {
+  addMatchers,
   expect };

build/matchers.js

@@ -15,3 +15,3 @@ /**
 
-const diff = require('jest-diff');var _require = 
+const diff = require('jest-diff');var _require =
 
@@ -23,3 +23,3 @@
 
-const matchers = { 
+const matchers = {
   toBe(actual, expected) {
@@ -29,177 +29,177 @@ const pass = actual === expected;
     if (pass) {
-      return { 
-        pass, 
+      return {
+        pass,
         message() {
-          return `expected '${ stringify(actual) }' not to be` + 
-          ` '${ stringify(expected) }'  (using '!==')`;} };} else 
+          return `expected '${ stringify(actual) }' not to be` +
+          ` '${ stringify(expected) }'  (using '!==')`;
+        } };
 
-
-    {
-      return { 
-        pass, 
+    } else {
+      return {
+        pass,
         message() {
           let diffString = '\n\n';
           diffString += diff(expected, actual);
-          return `expected '${ stringify(actual) }' to be` + 
-          ` '${ stringify(expected) }' (using '===')${ diffString }`;} };}}, 
+          return `expected '${ stringify(actual) }' to be` +
+          ` '${ stringify(expected) }' (using '===')${ diffString }`;
+        } };
 
+    }
+  },
 
-
-
-
   toBeTruthy(actual, expected) {
     ensureNoExpected(expected, 'toBeTruthy');
     const pass = !!actual;
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to be truthy` : 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to be truthy` :
     () => `expected '${ stringify(actual) }' to be truthy`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeFalsy(actual, expected) {
     ensureNoExpected(expected, 'toBeFalsy');
     const pass = !actual;
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to be falsy` : 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to be falsy` :
     () => `expected '${ stringify(actual) }' to be falsy`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeNaN(actual, expected) {
     ensureNoExpected(expected, 'toBeNaN');
     const pass = Number.isNaN(actual);
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to be NaN` : 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to be NaN` :
     () => `expected '${ stringify(actual) }' to be NaN`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeNull(actual, expected) {
     ensureNoExpected(expected, 'toBeNull');
     const pass = actual === null;
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to be null` : 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to be null` :
     () => `expected '${ stringify(actual) }' to be null`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeDefined(actual, expected) {
     ensureNoExpected(expected, 'toBeDefined');
     const pass = actual !== void 0;
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to be defined` : 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to be defined` :
     () => `expected '${ stringify(actual) }' to be defined`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeUndefined(actual, expected) {
     ensureNoExpected(expected, 'toBeUndefined');
     const pass = actual === void 0;
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to be undefined` : 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to be undefined` :
     () => `expected '${ stringify(actual) }' to be undefined`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeGreaterThan(actual, expected) {
     ensureNumbers(actual, expected, '.toBeGreaterThan');
     const pass = actual > expected;
-    const message = pass ? 
-    `expected '${ actual }' not to be greater than '${ expected }' (using >)` : 
+    const message = pass ?
+    `expected '${ actual }' not to be greater than '${ expected }' (using >)` :
     `expected '${ actual }' to be greater than '${ expected }' (using >)`;
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeGreaterThanOrEqual(actual, expected) {
     ensureNumbers(actual, expected, '.toBeGreaterThanOrEqual');
     const pass = actual >= expected;
-    const message = pass ? 
-    `expected '${ actual }' not to be greater than or equal ` + 
-    `'${ expected }' (using >=)` : 
-    `expected '${ actual }' to be greater than or equal ` + 
+    const message = pass ?
+    `expected '${ actual }' not to be greater than or equal ` +
+    `'${ expected }' (using >=)` :
+    `expected '${ actual }' to be greater than or equal ` +
     `'${ expected }' (using >=)`;
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeLessThan(actual, expected) {
     ensureNumbers(actual, expected, '.toBeLessThan');
     const pass = actual < expected;
-    const message = pass ? 
-    `expected '${ actual }' not to be less than '${ expected }' (using <)` : 
+    const message = pass ?
+    `expected '${ actual }' not to be less than '${ expected }' (using <)` :
     `expected '${ actual }' to be less than '${ expected }' (using <)`;
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeLessThanOrEqual(actual, expected) {
     ensureNumbers(actual, expected, '.toBeLessThanOrEqual');
     const pass = actual <= expected;
-    const message = pass ? 
-    `expected '${ actual }' not to be less than or equal ` + 
-    `'${ expected }' (using <=)` : 
-    `expected '${ actual }' to be less than or equal ` + 
+    const message = pass ?
+    `expected '${ actual }' not to be less than or equal ` +
+    `'${ expected }' (using <=)` :
+    `expected '${ actual }' to be less than or equal ` +
     `'${ expected }' (using <=)`;
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toContain(actual, expected) {
     if (!Array.isArray(actual) && typeof actual !== 'string') {
       throw new Error(
-      '.toContain() works only on arrays and strings. ' + 
-      `'${ typeof actual }': ` + 
-      `'${ stringify(actual) }' was passed`);}
+      '.toContain() works only on arrays and strings. ' +
+      `'${ typeof actual }': ` +
+      `'${ stringify(actual) }' was passed`);
 
+    }
 
-
     const pass = actual.indexOf(expected) != -1;
-    const message = pass ? 
-    () => `expected '${ stringify(actual) }' not to contain ` + 
-    `'${ stringify(expected) }'` : 
-    () => `expected '${ stringify(actual) }' to contain ` + 
+    const message = pass ?
+    () => `expected '${ stringify(actual) }' not to contain ` +
+    `'${ stringify(expected) }'` :
+    () => `expected '${ stringify(actual) }' to contain ` +
     `'${ stringify(expected) }'`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toBeCloseTo(actual, expected) {let precision = arguments.length <= 2 || arguments[2] === undefined ? 2 : arguments[2];
     ensureNumbers(actual, expected, '.toBeCloseTo');
     const pass = Math.abs(expected - actual) < Math.pow(10, -precision) / 2;
-    const message = pass ? 
-    () => `expected '${ actual }' not to be close to '${ expected }'` + 
-    ` with ${ precision }-digit precision` : 
-    () => `expected '${ actual }' to be close to '${ expected }'` + 
+    const message = pass ?
+    () => `expected '${ actual }' not to be close to '${ expected }'` +
+    ` with ${ precision }-digit precision` :
+    () => `expected '${ actual }' to be close to '${ expected }'` +
     ` with ${ precision }-digit precision`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toMatch(actual, expected) {
     if (typeof actual !== 'string') {
-      return { 
-        pass: false, 
-        message: `actual '${ actual }' is not a String` };}
+      return {
+        pass: false,
+        message: `actual '${ actual }' is not a String` };
 
+    }
 
-
     if (!(expected instanceof RegExp) && !(typeof expected == 'string')) {
-      return { 
-        pass: false, 
-        message: `expected '${ expected }' is not a String or a RegExp` };}
+      return {
+        pass: false,
+        message: `expected '${ expected }' is not a String or a RegExp` };
 
+    }
 
-
     const pass = new RegExp(expected).test(actual);
-    const message = pass ? 
-    () => `expected '${ actual }' not to match '${ stringify(expected) }'` : 
+    const message = pass ?
+    () => `expected '${ actual }' not to match '${ stringify(expected) }'` :
     () => `expected '${ actual }' to match '${ stringify(expected) }'`;
 
-    return { message, pass };} };
+    return { message, pass };
+  } };
 
 
-
 module.exports = matchers;

build/spy-matchers.js

@@ -11,3 +11,3 @@ /**
 
-'use strict';var _require = 
+'use strict';var _require =
 
@@ -21,3 +21,3 @@
 
-const spyMatchers = { 
+const spyMatchers = {
   toHaveBeenCalled(actual, expected) {
@@ -28,10 +28,10 @@ ensureNoExpected(expected, 'toHaveBeenCalled');
     const pass = actual.calls.any();
-    const message = pass ? 
-    `expected a spy to not be called, but it was` + 
-    ` called ${ actual.calls.count() } times` : 
+    const message = pass ?
+    `expected a spy to not be called, but it was` +
+    ` called ${ actual.calls.count() } times` :
     `expected a spy to be called but it wasn't`;
 
-    return { message, pass };}, 
+    return { message, pass };
+  },
 
-
   toHaveBeenCalledTimes(actual, expected) {
@@ -42,19 +42,19 @@ ensureExpectedIsNumber(expected, 'toHaveBeenCalledTimes');
     const pass = actual.calls.count() === expected;
-    const message = pass ? 
-    `expected a spy to not be called ${ expected } times,` + 
-    ` but it was called ${ actual.calls.count() } times` : 
-    `expected a spy to be called ${ expected } times,` + 
+    const message = pass ?
+    `expected a spy to not be called ${ expected } times,` +
+    ` but it was called ${ actual.calls.count() } times` :
+    `expected a spy to be called ${ expected } times,` +
     ` but it was called ${ actual.calls.count() } times`;
 
-    return { message, pass };} };
+    return { message, pass };
+  } };
 
 
-
 const ensureSpy = (spy, matcherName) => {
   if (spy.calls === undefined || spy.calls.all === undefined) {
     throw new Error(
-    `${ matcherName } matcher can only execute on a Spy function`);}};
+    `${ matcherName } matcher can only execute on a Spy function`);
+  }
+};
 
-
-
 module.exports = spyMatchers;

package.json

 {
   "name": "jest-matchers",
-  "version": "14.0.0",
+  "version": "14.2.0-alpha.ca8bfb6e",
   "repository": {
@@ -11,4 +11,4 @@ "type": "git",
   "dependencies": {
-    "jest-diff": "^14.0.0",
-    "jest-matcher-utils": "^14.0.0"
+    "jest-diff": "^14.2.0-alpha.ca8bfb6e",
+    "jest-matcher-utils": "^14.2.0-alpha.ca8bfb6e"
   },
@@ -18,8 +18,2 @@ "devDependencies": {
   },
-  "jest": {
-    "automock": false,
-    "rootDir": "./src",
-    "scriptPreprocessor": "../../babel-jest",
-    "testEnvironment": "node"
-  },
   "scripts": {
@@ -26,0 +20,0 @@ "test": "../../packages/jest-cli/bin/jest.js"

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Lines of code

270

increased by13.45%

Worsened metrics

Total package byte prevSize

10548

decreased by-0.92%

Number of low quality alerts

2

increased by100%

Dependency changes

• + [e-mail]8bfb6e(transitive)

• + [e-mail]8bfb6e(transitive)

• - Removedjest-diff@14.0.0(transitive)

• - Removedjest-matcher-utils@14.0.0(transitive)

• Updatedjest-diff@^14.2.0-alpha.ca8bfb6e

• Updatedjest-matcher-utils@^14.2.0-alpha.ca8bfb6e