add .toBeJsonMatching(expectation) matcher

src/matchers/index.js

@@ -20,6 +20,7 @@ export { toBeFrozen } from './toBeFrozen';
 export { toBeFunction } from './toBeFunction';
 export { toBeHexadecimal } from './toBeHexadecimal';
 export { toBeInteger } from './toBeInteger';
+export { toBeJsonMatching } from './toBeJsonMatching';
 export { toBeNaN } from './toBeNaN';
 export { toBeNegative } from './toBeNegative';
 export { toBeNil } from './toBeNil';

src/matchers/toBeJsonMatching.js

@@ -0,0 +1,25 @@
+import { matchesObject, tryParseJSON } from '../utils';
+
+export function toBeJsonMatching(actual, expected) {
+  const { printExpected, printReceived, matcherHint } = this.utils;
+
+  const parsed = tryParseJSON(actual);
+  const isValidJSON = typeof parsed !== 'undefined';
+
+  const passMessage =
+    `${matcherHint('.not.toBeJsonMatching')}\n\n` +
+    `Expected input to not be a JSON string containing:\n  ${printExpected(expected)}\n` +
+    `${isValidJSON ? `Received:\n  ${printReceived(parsed)}` : `Received invalid JSON:\n  ${printReceived(actual)}`}`;
+
+  const failMessage =
+    `${matcherHint('.toBeJsonMatching')}\n\n` +
+    `Expected input to be a JSON string containing:\n  ${printExpected(expected)}\n` +
+    `${isValidJSON ? `Received:\n  ${printReceived(parsed)}` : `Received invalid JSON:\n  ${printReceived(actual)}`}`;
+
+  const pass =
+    typeof actual === 'string' &&
+    typeof tryParseJSON(actual) !== 'undefined' &&
+    matchesObject(this.equals, tryParseJSON(actual), expected);
+
+  return { pass, message: () => (pass ? passMessage : failMessage) };
+}

src/matchers/toPartiallyContain.js

@@ -1,14 +1,9 @@
-import { containsEntry } from '../utils';
+import { partiallyContains } from '../utils';
 
 export function toPartiallyContain(actual, expected) {
   const { printReceived, printExpected, matcherHint } = this.utils;
 
-  const pass =
-    Array.isArray(actual) &&
-    Array.isArray([expected]) &&
-    [expected].every(partial =>
-      actual.some(value => Object.entries(partial).every(entry => containsEntry(this.equals, value, entry))),
-    );
+  const pass = partiallyContains(this.equals, actual, [expected]);
 
   return {
     pass,

src/utils/index.js

@@ -12,3 +12,50 @@ export const isJestMockOrSpy = value => {
 
 export const containsEntry = (equals, obj, [key, value]) =>
   obj.hasOwnProperty && Object.prototype.hasOwnProperty.call(obj, key) && equals(obj[key], value);
+
+export const partiallyContains = (equals, actual, expected) =>
+  Array.isArray(actual) &&
+  Array.isArray(expected) &&
+  expected.every(partial =>
+    actual.some(value => {
+      if (typeof partial !== 'object' || partial === null) {
+        return equals(value, partial);
+      }
+      if (Array.isArray(partial)) {
+        return partiallyContains(equals, value, partial);
+      }
+      return Object.entries(partial).every(entry => containsEntry(equals, value, entry));
+    }),
+  );
+
+export const matchesObject = (equals, actual, expected) => {
+  if (equals(actual, expected)) {
+    return true;
+  }
+  if (Array.isArray(actual) || Array.isArray(expected)) {
+    return partiallyContains(equals, actual, expected);
+  }
+  if (typeof actual === 'object' && typeof expected === 'object' && expected !== null) {
+    return Object.getOwnPropertyNames(expected).every(name => {
+      if (equals(actual[name], expected[name])) {
+        return true;
+      }
+      if (Array.isArray(actual[name]) || Array.isArray(expected[name])) {
+        return partiallyContains(equals, actual[name], expected[name]);
+      }
+      if (typeof actual[name] === 'object' && typeof expected[name] === 'object' && expected[name] !== null) {
+        return matchesObject(equals, actual[name], expected[name]);
+      }
+      return false;
+    });
+  }
+  return false;
+};
+
+export const tryParseJSON = input => {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return undefined;
+  }
+};