Add toIncludeAllMembersInOrder.

Author: sandinmyjoints

src/matchers/index.js

@@ -54,6 +54,7 @@ export { toHaveBeenCalledOnce } from './toHaveBeenCalledOnce';
 export { toHaveBeenCalledOnceWith } from './toHaveBeenCalledOnceWith';
 export { toInclude } from './toInclude';
 export { toIncludeAllMembers } from './toIncludeAllMembers';
+export { toIncludeAllMembersInOrder } from './toIncludeAllMembersInOrder';
 export { toIncludeAllPartialMembers } from './toIncludeAllPartialMembers';
 export { toIncludeAnyMembers } from './toIncludeAnyMembers';
 export { toIncludeMultiple } from './toIncludeMultiple';

src/matchers/toIncludeAllMembersInOrder.js

@@ -0,0 +1,74 @@
+import { contains } from '../utils';
+
+export function toIncludeAllMembersInOrder(actual, expected) {
+  const { printReceived, printExpected, matcherHint } = this.utils;
+  const options = {
+    isNot: this.isNot,
+    promise: this.promise,
+  };
+
+  // First, check contents.
+  const passMessage =
+    matcherHint('.not.toIncludeAllMembers') +
+    '\n\n' +
+    'Expected list to not have all of the following members:\n' +
+    `  ${printExpected(expected)}\n` +
+    'Received:\n' +
+    `  ${printReceived(actual)}`;
+
+  const failMessage =
+    matcherHint('.toIncludeAllMembers') +
+    '\n\n' +
+    'Expected list to have all of the following members:\n' +
+    `  ${printExpected(expected)}\n` +
+    'Received:\n' +
+    `  ${printReceived(actual)}`;
+
+  let pass =
+    Array.isArray(actual) && Array.isArray(expected) && expected.every(val => contains(this.equals, actual, val));
+
+  if (!pass) return { pass, message: () => (pass ? passMessage : failMessage) };
+
+  // Check if actual has additional items beyond expected.
+  let differingElementIdxs = [];
+  // Check if actual has additional items beyond expected.
+  if (actual.length > expected.length) {
+    differingElementIdxs = [expected.length];
+  } else {
+    // Second, check order. At this point, they must have the same length, so we
+    // can go element by element and fail at the first elements that don't
+    // match.
+
+    differingElementIdxs = expected
+      .map((element, idx) => {
+        return this.equals(element, actual[idx]) ? false : idx;
+      })
+      .filter(idx => idx !== false);
+  }
+
+  pass = differingElementIdxs.length === 0;
+
+  const message = pass
+    ? () =>
+        // eslint-disable-next-line prefer-template
+        this.utils.matcherHint('toIncludeAllMembersInOrder', undefined, undefined, options) +
+        '\n\n' +
+        `Expected: not ${this.utils.printExpected(expected)}\n` +
+        `Received: ${this.utils.printReceived(actual)}`
+    : () => {
+        const firstDifferingElementIdx = differingElementIdxs[0];
+        const firstDifferingElementInActual = actual[firstDifferingElementIdx];
+        const firstDifferingElementInExpected = expected[firstDifferingElementIdx];
+
+        return (
+          // eslint-disable-next-line prefer-template
+          this.utils.matcherHint('toIncludeAllMembersInOrder', undefined, undefined, options) +
+          '\n\n' +
+          `First differing element (index ${firstDifferingElementIdx}):\n\n` +
+          `Expected: ${this.utils.printExpected(firstDifferingElementInExpected)}\n` +
+          `Received: ${this.utils.printReceived(firstDifferingElementInActual)}`
+        );
+      };
+
+  return { actual, message, pass };
+}

test/matchers/__snapshots__/toIncludeAllMembersInOrder.test.js.snap

@@ -0,0 +1,55 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`.toIncludeAllMembersInOrder fails when array values do not contain all the members of the set 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).</intensity>toIncludeAllMembersInOrder<dim>(</intensity><green>expected</color><dim>)</intensity>
+
+First differing element (index 2):
+
+Expected: <green>undefined</color>
+Received: <red>3</color>"
+`;
+
+exports[`.toIncludeAllMembersInOrder fails when array values do not have the same order as the expected array 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).</intensity>toIncludeAllMembersInOrder<dim>(</intensity><green>expected</color><dim>)</intensity>
+
+First differing element (index 0):
+
+Expected: <green>2</color>
+Received: <red>1</color>"
+`;
+
+exports[`.toIncludeAllMembersInOrder fails when array values do not have the same order as the expected array 2`] = `
+"<dim>expect(</intensity><red>received</color><dim>).</intensity>toIncludeAllMembersInOrder<dim>(</intensity><green>expected</color><dim>)</intensity>
+
+First differing element (index 2):
+
+Expected: <green>undefined</color>
+Received: <red>2</color>"
+`;
+
+exports[`.toIncludeAllMembersInOrder fails when array values do not have the same order as the expected array 3`] = `
+"<dim>expect(</intensity><red>received</color><dim>).</intensity>toIncludeAllMembersInOrder<dim>(</intensity><green>expected</color><dim>)</intensity>
+
+First differing element (index 0):
+
+Expected: <green>{"baz": "qux"}</color>
+Received: <red>{"foo": "bar"}</color>"
+`;
+
+exports[`.toIncludeAllMembersInOrder fails when expected object is not an array 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toIncludeAllMembers(</intensity><green>expected</color><dim>)</intensity>
+
+Expected list to have all of the following members:
+  <green>2</color>
+Received:
+  <red>[1, 2, 3]</color>"
+`;
+
+exports[`.toIncludeAllMembersInOrder fails when given object is not an array 1`] = `
+"<dim>expect(</intensity><red>received</color><dim>).toIncludeAllMembers(</intensity><green>expected</color><dim>)</intensity>
+
+Expected list to have all of the following members:
+  <green>[1, 2, 3]</color>
+Received:
+  <red>2</color>"
+`;

test/matchers/toIncludeAllMembersInOrder.test.js

@@ -0,0 +1,50 @@
+import * as matcher from 'src/matchers/toIncludeAllMembersInOrder';
+
+expect.extend(matcher);
+
+describe('.toIncludeAllMembersInOrder', () => {
+  const array1 = [1, 2, 3];
+  const array2 = [1, 2, 2];
+
+  test('passes when array values match in order the expected array', () => {
+    expect(array1).toIncludeAllMembersInOrder([1, 2, 3]);
+    expect([{ foo: 'bar' }, { baz: 'qux' }]).toIncludeAllMembersInOrder([{ foo: 'bar' }, { baz: 'qux' }]);
+  });
+
+  test('fails when array values do not have the same order as the expected array', () => {
+    expect(() => expect(array1).toIncludeAllMembersInOrder([2, 1, 3])).toThrowErrorMatchingSnapshot();
+    expect(() => expect(array2).toIncludeAllMembersInOrder([2, 1])).toThrowErrorMatchingSnapshot();
+    expect(() =>
+      expect([{ foo: 'bar' }, { baz: 'qux' }]).toIncludeAllMembersInOrder([{ baz: 'qux' }, { foo: 'bar' }]),
+    ).toThrowErrorMatchingSnapshot();
+  });
+
+  test('fails when array values do not contain all the members of the set', () => {
+    expect(() => expect([1, 2, 3]).toIncludeAllMembersInOrder([1, 2])).toThrowErrorMatchingSnapshot();
+  });
+
+  test('fails when given object is not an array', () => {
+    expect(() => expect(2).toIncludeAllMembersInOrder([1, 2, 3])).toThrowErrorMatchingSnapshot();
+  });
+
+  test('fails when expected object is not an array', () => {
+    expect(() => expect(array1).toIncludeAllMembersInOrder(2)).toThrowErrorMatchingSnapshot();
+  });
+});
+
+describe('.not.toIncludeAllMembersInOrder', () => {
+  const array1 = [1, 2, 3];
+
+  test('passes when array values does not contain any members of the set', () => {
+    expect(array1).not.toIncludeAllMembersInOrder([4, 5, 6]);
+    expect([{ foo: 'bar' }, { baz: 'qux' }]).not.toIncludeAllMembersInOrder([{ hello: 'world' }]);
+  });
+
+  test('passes when given object is not an array', () => {
+    expect(4).not.toIncludeAllMembersInOrder([4, 5, 6]);
+  });
+
+  test('passes when array values matches the members of the set', () => {
+    expect(array1).not.toIncludeAllMembersInOrder([2, 1, 3]);
+  });
+});