feat(expect): implement chai inspect for AsymmetricMatcher

packages/expect/src/jest-asymmetric-matchers.ts

@@ -41,6 +41,12 @@ export abstract class AsymmetricMatcher<
  abstract toString(): string
  getExpectedType?(): string
  toAsymmetricMatcher?(): string
+
+ // implement loupe-based serialization for AssertionError.message
+ // https://github.com/chaijs/loupe/blob/9b8a6deabcd50adc056a64fb705896194710c5c6/src/index.ts#L29
+ [Symbol.for('chai/inspect')]() {
+ return stringify(this)
+ }
 }
 
 export class StringContaining extends AsymmetricMatcher<string> {

test/core/test/__snapshots__/jest-expect.test.ts.snap

@@ -0,0 +1,139 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`asymmetric matcher error 1`] = `
+{
+ "actual": "hello",
+ "diff": null,
+ "expected": "StringContaining "xx"",
+ "message": "expected 'hello' to deeply equal StringContaining "xx"",
+}
+`;
+
+exports[`asymmetric matcher error 2`] = `
+{
+ "actual": "hello",
+ "diff": null,
+ "expected": "StringNotContaining "ll"",
+ "message": "expected 'hello' to deeply equal StringNotContaining "ll"",
+}
+`;
+
+exports[`asymmetric matcher error 3`] = `
+{
+ "actual": "Object {
+ "foo": "hello",
+}",
+ "diff": "- Expected
++ Received
+
+ Object {
+- "foo": StringContaining "xx",
++ "foo": "hello",
+ }",
+ "expected": "Object {
+ "foo": StringContaining "xx",
+}",
+ "message": "expected { foo: 'hello' } to deeply equal { foo: StringContaining "xx" }",
+}
+`;
+
+exports[`asymmetric matcher error 4`] = `
+{
+ "actual": "Object {
+ "foo": "hello",
+}",
+ "diff": "- Expected
++ Received
+
+ Object {
+- "foo": StringNotContaining "ll",
++ "foo": "hello",
+ }",
+ "expected": "Object {
+ "foo": StringNotContaining "ll",
+}",
+ "message": "expected { foo: 'hello' } to deeply equal { foo: StringNotContaining "ll" }",
+}
+`;
+
+exports[`asymmetric matcher error 5`] = `
+{
+ "actual": "hello",
+ "diff": "- Expected: 
+stringContainingCustom<xx>
+
++ Received: 
+"hello"",
+ "expected": "stringContainingCustom<xx>",
+ "message": "expected 'hello' to deeply equal stringContainingCustom<xx>",
+}
+`;
+
+exports[`asymmetric matcher error 6`] = `
+{
+ "actual": "hello",
+ "diff": "- Expected: 
+not.stringContainingCustom<ll>
+
++ Received: 
+"hello"",
+ "expected": "not.stringContainingCustom<ll>",
+ "message": "expected 'hello' to deeply equal not.stringContainingCustom<ll>",
+}
+`;
+
+exports[`asymmetric matcher error 7`] = `
+{
+ "actual": "Object {
+ "foo": "hello",
+}",
+ "diff": "- Expected
++ Received
+
+ Object {
+- "foo": stringContainingCustom<xx>,
++ "foo": "hello",
+ }",
+ "expected": "Object {
+ "foo": stringContainingCustom<xx>,
+}",
+ "message": "expected { foo: 'hello' } to deeply equal { foo: stringContainingCustom<xx> }",
+}
+`;
+
+exports[`asymmetric matcher error 8`] = `
+{
+ "actual": "Object {
+ "foo": "hello",
+}",
+ "diff": "- Expected
++ Received
+
+ Object {
+- "foo": not.stringContainingCustom<ll>,
++ "foo": "hello",
+ }",
+ "expected": "Object {
+ "foo": not.stringContainingCustom<ll>,
+}",
+ "message": "expected { foo: 'hello' } to deeply equal { foo: not.stringContainingCustom<ll> }",
+}
+`;
+
+exports[`asymmetric matcher error 9`] = `
+{
+ "actual": "undefined",
+ "diff": undefined,
+ "expected": "undefined",
+ "message": "expected "hello" to contain "xx"",
+}
+`;
+
+exports[`asymmetric matcher error 10`] = `
+{
+ "actual": "undefined",
+ "diff": undefined,
+ "expected": "undefined",
+ "message": "expected "hello" not to contain "ll"",
+}
+`;

test/core/test/jest-expect.test.ts

@@ -179,7 +179,7 @@ describe('jest-expect', () => {
  }).toEqual({
  sum: expect.closeTo(0.4),
  })
- }).toThrowErrorMatchingInlineSnapshot(`[AssertionError: expected { sum: 0.30000000000000004 } to deeply equal { sum: CloseTo{ …(4) } }]`)
+ }).toThrowErrorMatchingInlineSnapshot(`[AssertionError: expected { sum: 0.30000000000000004 } to deeply equal { sum: NumberCloseTo 0.4 (2 digits) }]`)
 
  // TODO: support set
  // expect(new Set(['bar'])).not.toEqual(new Set([expect.stringContaining('zoo')]))
@@ -949,7 +949,7 @@ it('toHaveProperty error diff', () => {
  // non match value (with asymmetric matcher)
  expect(getError(() => expect({ name: 'foo' }).toHaveProperty('name', expect.any(Number)))).toMatchInlineSnapshot(`
  [
- "expected { name: 'foo' } to have property "name" with value Any{ …(3) }",
+ "expected { name: 'foo' } to have property "name" with value Any<Number>",
  "- Expected:
  Any<Number>
 
@@ -961,7 +961,7 @@ it('toHaveProperty error diff', () => {
  // non match key (with asymmetric matcher)
  expect(getError(() => expect({ noName: 'foo' }).toHaveProperty('name', expect.any(Number)))).toMatchInlineSnapshot(`
  [
- "expected { noName: 'foo' } to have property "name" with value Any{ …(3) }",
+ "expected { noName: 'foo' } to have property "name" with value Any<Number>",
  "- Expected:
  Any<Number>
 
@@ -995,4 +995,49 @@ it('toHaveProperty error diff', () => {
  `)
 })
 
+it('asymmetric matcher error', () => {
+ setupColors(getDefaultColors())
+
+ expect.extend({
+ stringContainingCustom(received: unknown, other: string) {
+ return {
+ pass: typeof received === 'string' && received.includes(other),
+ message: () => `expected ${this.utils.printReceived(received)} ${this.isNot ? 'not ' : ''}to contain ${this.utils.printExpected(other)}`,
+ }
+ },
+ })
+
+ function getError(f: () => unknown) {
+ try {
+ f()
+ return expect.unreachable()
+ }
+ catch (error) {
+ const e = processError(error)
+ return {
+ message: e.message,
+ diff: e.diff,
+ expected: e.expected,
+ actual: e.actual,
+ }
+ }
+ }
+
+ // builtin
+ expect(getError(() => expect('hello').toEqual((expect as any).stringContaining('xx')))).toMatchSnapshot()
+ expect(getError(() => expect('hello').toEqual((expect as any).not.stringContaining('ll')))).toMatchSnapshot()
+ expect(getError(() => expect({ foo: 'hello' }).toEqual({ foo: (expect as any).stringContaining('xx') }))).toMatchSnapshot()
+ expect(getError(() => expect({ foo: 'hello' }).toEqual({ foo: (expect as any).not.stringContaining('ll') }))).toMatchSnapshot()
+
+ // custom
+ expect(getError(() => expect('hello').toEqual((expect as any).stringContainingCustom('xx')))).toMatchSnapshot()
+ expect(getError(() => expect('hello').toEqual((expect as any).not.stringContainingCustom('ll')))).toMatchSnapshot()
+ expect(getError(() => expect({ foo: 'hello' }).toEqual({ foo: (expect as any).stringContainingCustom('xx') }))).toMatchSnapshot()
+ expect(getError(() => expect({ foo: 'hello' }).toEqual({ foo: (expect as any).not.stringContainingCustom('ll') }))).toMatchSnapshot()
+
+ // assertion form
+ expect(getError(() => (expect('hello') as any).stringContainingCustom('xx'))).toMatchSnapshot()
+ expect(getError(() => (expect('hello') as any).not.stringContainingCustom('ll'))).toMatchSnapshot()
+})
+
 it('timeout', () => new Promise(resolve => setTimeout(resolve, 500)))