failures.test.ts.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`not throwing Error objects 1`] = `
FAIL __tests__/throwNumber.test.js
  ● Test suite failed to run

    Expected an Error, but "1" was thrown
`;

exports[`not throwing Error objects 2`] = `
FAIL __tests__/throwString.test.js
  ● Test suite failed to run

    banana
`;

exports[`not throwing Error objects 3`] = `
FAIL __tests__/throwObject.test.js
  ● Test suite failed to run

    Error: No message was provided
`;

exports[`not throwing Error objects 4`] = `
FAIL __tests__/assertionCount.test.js
  .assertions()
    ✕ throws
    ✕ throws on redeclare of assertion count
    ✕ throws on assertion
  .hasAssertions()
    ✕ throws when there are not assertions

  ● .assertions() › throws

    expect(received).toBeTruthy()

    Received: false

      11 | const throws = () => {
      12 |   expect.assertions(2);
    > 13 |   expect(false).toBeTruthy();
         |                 ^
      14 | };
      15 | const redeclare = () => {
      16 |   expect.assertions(1);

      at Object.toBeTruthy (__tests__/assertionCount.test.js:13:17)

  ● .assertions() › throws

    expect.assertions(2)

    Expected two assertions to be called but received one assertion call.

      10 | 
      11 | const throws = () => {
    > 12 |   expect.assertions(2);
         |          ^
      13 |   expect(false).toBeTruthy();
      14 | };
      15 | const redeclare = () => {

      at Object.assertions (__tests__/assertionCount.test.js:12:10)

  ● .assertions() › throws on redeclare of assertion count

    expect(received).toBeTruthy()

    Received: false

      15 | const redeclare = () => {
      16 |   expect.assertions(1);
    > 17 |   expect(false).toBeTruthy();
         |                 ^
      18 |   expect.assertions(2);
      19 | };
      20 | 

      at Object.toBeTruthy (__tests__/assertionCount.test.js:17:17)

  ● .assertions() › throws on assertion

    expect.assertions(0)

    Expected zero assertions to be called but received one assertion call.

      20 | 
      21 | const noAssertions = () => {
    > 22 |   expect.assertions(0);
         |          ^
      23 |   expect(true).toBeTruthy();
      24 | };
      25 | 

      at Object.assertions (__tests__/assertionCount.test.js:22:10)

  ● .hasAssertions() › throws when there are not assertions

    expect.hasAssertions()

    Expected at least one assertion to be called but received none.

      25 | 
      26 | const hasNoAssertions = () => {
    > 27 |   expect.hasAssertions();
         |          ^
      28 | };
      29 | 
      30 | describe('.assertions()', () => {

      at Object.hasAssertions (__tests__/assertionCount.test.js:27:10)
`;

exports[`not throwing Error objects 5`] = `
FAIL __tests__/duringTests.test.js
  ✕ Promise thrown during test
  ✕ Boolean thrown during test
  ✕ undefined thrown during test
  ✕ Object thrown during test
  ✕ Error during test
  ✕ done(Error)
  ✕ done(non-error)
  ✕ returned promise rejection

  ● Promise thrown during test

    thrown: Promise {}

       7 | };
       8 | 
    >  9 | test('Promise thrown during test', () => {
         | ^
      10 |   throw Promise.resolve(5);
      11 | });
      12 | 

      at Object.test (__tests__/duringTests.test.js:9:1)

  ● Boolean thrown during test

    thrown: false

      11 | });
      12 | 
    > 13 | test('Boolean thrown during test', () => {
         | ^
      14 |   // eslint-disable-next-line no-throw-literal
      15 |   throw false;
      16 | });

      at Object.test (__tests__/duringTests.test.js:13:1)

  ● undefined thrown during test

    thrown: undefined

      16 | });
      17 | 
    > 18 | test('undefined thrown during test', () => {
         | ^
      19 |   // eslint-disable-next-line no-throw-literal
      20 |   throw undefined;
      21 | });

      at Object.test (__tests__/duringTests.test.js:18:1)

  ● Object thrown during test

    thrown: Object {
      "notAnError": Array [
        Object {
          "hello": true,
          "tooDeep": [Object],
        },
      ],
    }

      21 | });
      22 | 
    > 23 | test('Object thrown during test', () => {
         | ^
      24 |   throw deepObject;
      25 | });
      26 | 

      at Object.test (__tests__/duringTests.test.js:23:1)

  ● Error during test

    ReferenceError: doesNotExist is not defined

      27 | test('Error during test', () => {
      28 |   // eslint-disable-next-line no-undef
    > 29 |   doesNotExist.alsoThisNot;
         |   ^
      30 | });
      31 | 
      32 | test('done(Error)', done => {

      at Object.doesNotExist (__tests__/duringTests.test.js:29:3)

  ● done(Error)

    this is an error

      31 | 
      32 | test('done(Error)', done => {
    > 33 |   done(new Error('this is an error'));
         |        ^
      34 | });
      35 | 
      36 | test('done(non-error)', done => {

      at Object.<anonymous>.done (__tests__/duringTests.test.js:33:8)

  ● done(non-error)

    thrown: Object {
      "notAnError": Array [
        Object {
          "hello": true,
          "tooDeep": [Object],
        },
      ],
    }

      35 | 
      36 | test('done(non-error)', done => {
    > 37 |   done(deepObject);
         |   ^
      38 | });
      39 | 
      40 | test('returned promise rejection', () => Promise.reject(deepObject));

      at Object.done (__tests__/duringTests.test.js:37:3)

  ● returned promise rejection

    thrown: Object {
      "notAnError": Array [
        Object {
          "hello": true,
          "tooDeep": [Object],
        },
      ],
    }

      38 | });
      39 | 
    > 40 | test('returned promise rejection', () => Promise.reject(deepObject));
         | ^
      41 | 

      at Object.test (__tests__/duringTests.test.js:40:1)
`;

exports[`works with assertions in separate files 1`] = `
FAIL __tests__/testMacro.test.js
  ✕ use some imported macro to make assertion

  ● use some imported macro to make assertion

    expect(received).toEqual(expected)

    Expected: 2
    Received: 1

      10 | 
      11 | module.exports = (one: any, two: any) => {
    > 12 |   expect(one).toEqual(two);
         |               ^
      13 | };
      14 | 

      at toEqual (macros.js:12:15)
      at Object.shouldEqual (__tests__/testMacro.test.js:14:3)
`;

exports[`works with async failures 1`] = `
FAIL __tests__/asyncFailures.test.js
  ✕ resolve, but fail
  ✕ reject, but fail
  ✕ expect reject
  ✕ expect resolve
  ✕ timeout

  ● resolve, but fail

    expect(received).toEqual(expected)

    Difference:

    - Expected
    + Received

      Object {
    -   "baz": "bar",
    +   "foo": "bar",
      }

      10 | 
      11 | test('resolve, but fail', () =>
    > 12 |   expect(Promise.resolve({foo: 'bar'})).resolves.toEqual({baz: 'bar'}));
         |                                                  ^
      13 | 
      14 | test('reject, but fail', () =>
      15 |   expect(Promise.reject({foo: 'bar'})).rejects.toEqual({baz: 'bar'}));

      at Object.toEqual (__tests__/asyncFailures.test.js:12:50)

  ● reject, but fail

    expect(received).toEqual(expected)

    Difference:

    - Expected
    + Received

      Object {
    -   "baz": "bar",
    +   "foo": "bar",
      }

      13 | 
      14 | test('reject, but fail', () =>
    > 15 |   expect(Promise.reject({foo: 'bar'})).rejects.toEqual({baz: 'bar'}));
         |                                                ^
      16 | 
      17 | test('expect reject', () =>
      18 |   expect(Promise.resolve({foo: 'bar'})).rejects.toEqual({foo: 'bar'}));

      at Object.toEqual (__tests__/asyncFailures.test.js:15:48)

  ● expect reject

    expect(received).rejects.toEqual()

    Received promise resolved instead of rejected
    Resolved to value: {"foo": "bar"}

      16 | 
      17 | test('expect reject', () =>
    > 18 |   expect(Promise.resolve({foo: 'bar'})).rejects.toEqual({foo: 'bar'}));
         |   ^
      19 | 
      20 | test('expect resolve', () =>
      21 |   expect(Promise.reject({foo: 'bar'})).resolves.toEqual({foo: 'bar'}));

      at Object.expect (__tests__/asyncFailures.test.js:18:3)

  ● expect resolve

    expect(received).resolves.toEqual()

    Received promise rejected instead of resolved
    Rejected to value: {"foo": "bar"}

      19 | 
      20 | test('expect resolve', () =>
    > 21 |   expect(Promise.reject({foo: 'bar'})).resolves.toEqual({foo: 'bar'}));
         |   ^
      22 | 
      23 | test('timeout', done => {
      24 |   setTimeout(done, 50);

      at Object.expect (__tests__/asyncFailures.test.js:21:3)

  ● timeout

<REPLACED>

      21 |   expect(Promise.reject({foo: 'bar'})).resolves.toEqual({foo: 'bar'}));
      22 | 
    > 23 | test('timeout', done => {
         | ^
      24 |   setTimeout(done, 50);
      25 | }, 5);
      26 | 

      at Object.test (__tests__/asyncFailures.test.js:23:1)
`;

exports[`works with node assert 1`] = `
FAIL __tests__/assertionError.test.js
  ✕ assert
  ✕ assert with a message
  ✕ assert.ok
  ✕ assert.ok with a message
  ✕ assert.equal
  ✕ assert.notEqual
  ✕ assert.deepEqual
  ✕ assert.deepEqual with a message
  ✕ assert.notDeepEqual
  ✕ assert.strictEqual
  ✕ assert.notStrictEqual
  ✕ assert.deepStrictEqual
  ✕ assert.notDeepStrictEqual
  ✕ assert.ifError
  ✕ assert.doesNotThrow
  ✕ assert.throws
  ✕ async

  ● assert

    assert.equal(received, expected) or assert(received) 

    Expected value to be equal to:
      true
    Received:
      false

      13 | 
      14 | test('assert', () => {
    > 15 |   assert(false);
         |   ^
      16 | });
      17 | 
      18 | test('assert with a message', () => {

      at Object.assert (__tests__/assertionError.test.js:15:3)

  ● assert with a message

    assert.equal(received, expected) or assert(received) 

    Expected value to be equal to:
      true
    Received:
      false

    Message:
      this is a message

      17 | 
      18 | test('assert with a message', () => {
    > 19 |   assert(false, 'this is a message');
         |   ^
      20 | });
      21 | 
      22 | test('assert.ok', () => {

      at Object.assert (__tests__/assertionError.test.js:19:3)

  ● assert.ok

    assert.equal(received, expected) or assert(received) 

    Expected value to be equal to:
      true
    Received:
      false

      21 | 
      22 | test('assert.ok', () => {
    > 23 |   assert.ok(false);
         |          ^
      24 | });
      25 | 
      26 | test('assert.ok with a message', () => {

      at Object.ok (__tests__/assertionError.test.js:23:10)

  ● assert.ok with a message

    assert.equal(received, expected) or assert(received) 

    Expected value to be equal to:
      true
    Received:
      false

    Message:
      this is a message

      25 | 
      26 | test('assert.ok with a message', () => {
    > 27 |   assert.ok(false, 'this is a message');
         |          ^
      28 | });
      29 | 
      30 | test('assert.equal', () => {

      at Object.ok (__tests__/assertionError.test.js:27:10)

  ● assert.equal

    assert.equal(received, expected) or assert(received) 

    Expected value to be equal to:
      2
    Received:
      1

      29 | 
      30 | test('assert.equal', () => {
    > 31 |   assert.equal(1, 2);
         |          ^
      32 | });
      33 | 
      34 | test('assert.notEqual', () => {

      at Object.equal (__tests__/assertionError.test.js:31:10)

  ● assert.notEqual

    assert.notEqual(received, expected)

    Expected value to not be equal to:
      1
    Received:
      1

      33 | 
      34 | test('assert.notEqual', () => {
    > 35 |   assert.notEqual(1, 1);
         |          ^
      36 | });
      37 | 
      38 | test('assert.deepEqual', () => {

      at Object.notEqual (__tests__/assertionError.test.js:35:10)

  ● assert.deepEqual

    assert.deepEqual(received, expected)

    Expected value to deeply equal to:
      {"a": {"b": {"c": 6}}}
    Received:
      {"a": {"b": {"c": 5}}}

    Difference:

    - Expected
    + Received

      Object {
        "a": Object {
          "b": Object {
    -       "c": 6,
    +       "c": 5,
          },
        },
      }

      37 | 
      38 | test('assert.deepEqual', () => {
    > 39 |   assert.deepEqual({a: {b: {c: 5}}}, {a: {b: {c: 6}}});
         |          ^
      40 | });
      41 | 
      42 | test('assert.deepEqual with a message', () => {

      at Object.deepEqual (__tests__/assertionError.test.js:39:10)

  ● assert.deepEqual with a message

    assert.deepEqual(received, expected)

    Expected value to deeply equal to:
      {"a": {"b": {"c": 7}}}
    Received:
      {"a": {"b": {"c": 5}}}

    Message:
      this is a message

    Difference:

    - Expected
    + Received

      Object {
        "a": Object {
          "b": Object {
    -       "c": 7,
    +       "c": 5,
          },
        },
      }

      41 | 
      42 | test('assert.deepEqual with a message', () => {
    > 43 |   assert.deepEqual({a: {b: {c: 5}}}, {a: {b: {c: 7}}}, 'this is a message');
         |          ^
      44 | });
      45 | 
      46 | test('assert.notDeepEqual', () => {

      at Object.deepEqual (__tests__/assertionError.test.js:43:10)

  ● assert.notDeepEqual

    assert.notDeepEqual(received, expected)

    Expected value not to deeply equal to:
      {"a": 1}
    Received:
      {"a": 1}

    Difference:

    Compared values have no visual difference.

      45 | 
      46 | test('assert.notDeepEqual', () => {
    > 47 |   assert.notDeepEqual({a: 1}, {a: 1});
         |          ^
      48 | });
      49 | 
      50 | test('assert.strictEqual', () => {

      at Object.notDeepEqual (__tests__/assertionError.test.js:47:10)

  ● assert.strictEqual

    assert.strictEqual(received, expected)

    Expected value to strictly be equal to:
      NaN
    Received:
      1

      49 | 
      50 | test('assert.strictEqual', () => {
    > 51 |   assert.strictEqual(1, NaN);
         |          ^
      52 | });
      53 | 
      54 | test('assert.notStrictEqual', () => {

      at Object.strictEqual (__tests__/assertionError.test.js:51:10)

  ● assert.notStrictEqual

    assert.notStrictEqual(received, expected)

    Expected value not be strictly equal to:
      1
    Received:
      1

    Message:
      My custom error message

      53 | 
      54 | test('assert.notStrictEqual', () => {
    > 55 |   assert.notStrictEqual(1, 1, 'My custom error message');
         |          ^
      56 | });
      57 | 
      58 | test('assert.deepStrictEqual', () => {

      at Object.notStrictEqual (__tests__/assertionError.test.js:55:10)

  ● assert.deepStrictEqual

    assert.deepStrictEqual(received, expected)

    Expected value to deeply and strictly equal to:
      {"a": 2}
    Received:
      {"a": 1}

    Difference:

    - Expected
    + Received

      Object {
    -   "a": 2,
    +   "a": 1,
      }

      57 | 
      58 | test('assert.deepStrictEqual', () => {
    > 59 |   assert.deepStrictEqual({a: 1}, {a: 2});
         |          ^
      60 | });
      61 | 
      62 | test('assert.notDeepStrictEqual', () => {

      at Object.deepStrictEqual (__tests__/assertionError.test.js:59:10)

  ● assert.notDeepStrictEqual

    assert.notDeepStrictEqual(received, expected)

    Expected value not to deeply and strictly equal to:
      {"a": 1}
    Received:
      {"a": 1}

    Difference:

    Compared values have no visual difference.

      61 | 
      62 | test('assert.notDeepStrictEqual', () => {
    > 63 |   assert.notDeepStrictEqual({a: 1}, {a: 1});
         |          ^
      64 | });
      65 | 
      66 | test('assert.ifError', () => {

      at Object.notDeepStrictEqual (__tests__/assertionError.test.js:63:10)

  ● assert.ifError

  ● assert.doesNotThrow

    assert.doesNotThrow(function)

    Expected the function not to throw an error.
    Instead, it threw:
      [Error: err!]

    Message:
      Got unwanted exception.

      69 | 
      70 | test('assert.doesNotThrow', () => {
    > 71 |   assert.doesNotThrow(() => {
         |          ^
      72 |     throw Error('err!');
      73 |   });
      74 | });

      at Object.doesNotThrow (__tests__/assertionError.test.js:71:10)

  ● assert.throws

    assert.throws(function)

    Expected the function to throw an error.
    But it didn't throw anything.

    Message:
      Missing expected exception.

      75 | 
      76 | test('assert.throws', () => {
    > 77 |   assert.throws(() => {});
         |          ^
      78 | });
      79 | 
      80 | test('async', async () => {

      at Object.throws (__tests__/assertionError.test.js:77:10)

  ● async

    assert.equal(received, expected) or assert(received) 

    Expected value to be equal to:
      "hello"
    Received:
      "hello
    goodbye"

    Message:
      hmmm

    Difference:

    - Expected
    + Received

      hello
    + goodbye

      79 | 
      80 | test('async', async () => {
    > 81 |   assert.equal('hello\\ngoodbye', 'hello', 'hmmm');
         |          ^
      82 | });
      83 | 

      at Object.equal (__tests__/assertionError.test.js:81:10)
      at asyncGeneratorStep (__tests__/assertionError.test.js:11:103)
      at _next (__tests__/assertionError.test.js:13:194)
      at __tests__/assertionError.test.js:13:364
      at Object.<anonymous> (__tests__/assertionError.test.js:13:97)
`;

exports[`works with snapshot failures 1`] = `
FAIL __tests__/snapshot.test.js
  ✕ failing snapshot

  ● failing snapshot

    expect(received).toMatchSnapshot()

    Snapshot name: \`failing snapshot 1\`

    - Snapshot
    + Received

    - "bar"
    + "foo"

      10 | 
      11 | test('failing snapshot', () => {
    > 12 |   expect('foo').toMatchSnapshot();
         |                 ^
      13 | });
      14 | 

      at Object.toMatchSnapshot (__tests__/snapshot.test.js:12:17)

 › 1 snapshot failed.

`;

exports[`works with snapshot failures with hint 1`] = `
FAIL __tests__/snapshotWithHint.test.js
  ✕ failing snapshot with hint

  ● failing snapshot with hint

    expect(received).toMatchSnapshot(hint)

    Snapshot name: \`failing snapshot with hint: descriptive hint 1\`

    - Snapshot
    + Received

    - "bar"
    + "foo"

      10 | 
      11 | test('failing snapshot with hint', () => {
    > 12 |   expect('foo').toMatchSnapshot('descriptive hint');
         |                 ^
      13 | });
      14 | 

      at Object.toMatchSnapshot (__tests__/snapshotWithHint.test.js:12:17)

 › 1 snapshot failed.

`;