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

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

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

  ● .assertions() › throws

    expect.assertions(2)

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

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

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

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

    expect(received).toBeTruthy()

    Received: false

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

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

  ● .assertions() › throws on assertion

    expect.assertions(0)

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

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

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

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

    expect.hasAssertions()

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

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

      at Object.hasAssertions (__tests__/assertionCount.test.js:26: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) // deep equality

    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:13: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).resolves.toEqual(expected) // deep equality

    - Expected
    + Received

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

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

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

  ● reject, but fail

    expect(received).rejects.toEqual(expected) // deep equality

    - Expected
    + Received

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

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

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

  ● expect reject

    expect(received).rejects.toEqual()

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

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

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

  ● expect resolve

    expect(received).resolves.toEqual()

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

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

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

  ● timeout

<REPLACED>

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

      at Object.test (__tests__/asyncFailures.test.js:22: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

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

      at Object.assert (__tests__/assertionError.test.js:14: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

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

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

  ● assert.ok

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

    Expected value to be equal to:
      true
    Received:
      false

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

      at Object.ok (__tests__/assertionError.test.js:22: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

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

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

  ● assert.equal

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

    Expected value to be equal to:
      2
    Received:
      1

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

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

  ● assert.notEqual

    assert.notEqual(received, expected)

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

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

      at Object.notEqual (__tests__/assertionError.test.js:34: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,
          },
        },
      }

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

      at Object.deepEqual (__tests__/assertionError.test.js:38: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,
          },
        },
      }

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

      at Object.deepEqual (__tests__/assertionError.test.js:42: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.

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

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

  ● assert.strictEqual

    assert.strictEqual(received, expected)

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

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

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

  ● assert.notStrictEqual

    assert.notStrictEqual(received, expected)

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

    Message:
      My custom error message

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

      at Object.notStrictEqual (__tests__/assertionError.test.js:54: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,
      }

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

      at Object.deepStrictEqual (__tests__/assertionError.test.js:58: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.

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

      at Object.notDeepStrictEqual (__tests__/assertionError.test.js:62: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.

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

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

  ● assert.throws

    assert.throws(function)

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

    Message:
      Missing expected exception.

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

      at Object.throws (__tests__/assertionError.test.js:76: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

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

      at Object.equal (__tests__/assertionError.test.js:80:10)
`;

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

  ● failing snapshot

    expect(received).toMatchSnapshot()

    Snapshot name: \`failing snapshot 1\`

    Snapshot: "bar"
    Received: "foo"

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

      at Object.toMatchSnapshot (__tests__/snapshot.test.js:11: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: "bar"
    Received: "foo"

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

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

 › 1 snapshot failed.

`;