chore: fix types of few expect tests

packages/expect/src/__tests__/asymmetricMatchers.test.ts

@@ -104,7 +104,10 @@ test('Any.toAsymmetricMatcher() with function name', () => {
 });
 
 test('Any throws when called with empty constructor', () => {
-  jestExpect(() => any()).toThrow();
+  // @ts-expect-error: Testing runtime error
+  jestExpect(() => any()).toThrow(
+    'any() expects to be passed a constructor function. Please pass one or use anything() to match any object.',
+  );
 });
 
 test('Anything matches any type', () => {
@@ -150,8 +153,9 @@ test('ArrayContaining does not match', () => {
 
 test('ArrayContaining throws for non-arrays', () => {
   jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
     arrayContaining('foo').asymmetricMatch([]);
-  }).toThrow();
+  }).toThrow("You must provide an array to ArrayContaining, not 'string'.");
 });
 
 test('ArrayNotContaining matches', () => {
@@ -171,8 +175,9 @@ test('ArrayNotContaining does not match', () => {
 
 test('ArrayNotContaining throws for non-arrays', () => {
   jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
     arrayNotContaining('foo').asymmetricMatch([]);
-  }).toThrow();
+  }).toThrow("You must provide an array to ArrayNotContaining, not 'string'.");
 });
 
 test('ObjectContaining matches', () => {
@@ -224,13 +229,16 @@ test('ObjectContaining matches prototype properties', () => {
     function Foo() {}
     Foo.prototype = prototypeObject;
     Foo.prototype.constructor = Foo;
-    obj = new Foo();
+    obj = new (Foo as any)();
   }
   jestExpect(objectContaining({foo: 'bar'}).asymmetricMatch(obj)).toBe(true);
 });
 
 test('ObjectContaining throws for non-objects', () => {
-  jestExpect(() => objectContaining(1337).asymmetricMatch()).toThrow();
+  // @ts-expect-error: Testing runtime error
+  jestExpect(() => objectContaining(1337).asymmetricMatch()).toThrow(
+    "You must provide an object to ObjectContaining, not 'number'.",
+  );
 });
 
 test('ObjectContaining does not mutate the sample', () => {
@@ -243,6 +251,8 @@ test('ObjectContaining does not mutate the sample', () => {
 
 test('ObjectNotContaining matches', () => {
   [
+    objectContaining({}).asymmetricMatch(null),
+    objectContaining({}).asymmetricMatch(undefined),
     objectNotContaining({foo: 'foo'}).asymmetricMatch({bar: 'bar'}),
     objectNotContaining({foo: 'foo'}).asymmetricMatch({foo: 'foox'}),
     objectNotContaining({foo: undefined}).asymmetricMatch({}),
@@ -278,32 +288,40 @@ test('ObjectNotContaining does not match', () => {
       first: objectContaining({second: {}}),
     }).asymmetricMatch({first: {second: {}}}),
     objectNotContaining({}).asymmetricMatch(null),
+    objectNotContaining({}).asymmetricMatch(undefined),
     objectNotContaining({}).asymmetricMatch({}),
   ].forEach(test => {
     jestExpect(test).toEqual(false);
   });
 });
 
 test('ObjectNotContaining inverts ObjectContaining', () => {
-  [
-    [{}, null],
-    [{foo: 'foo'}, {foo: 'foo', jest: 'jest'}],
-    [{foo: 'foo', jest: 'jest'}, {foo: 'foo'}],
-    [{foo: undefined}, {foo: undefined}],
-    [{foo: undefined}, {}],
-    [{first: {second: {}}}, {first: {second: {}}}],
-    [{first: objectContaining({second: {}})}, {first: {second: {}}}],
-    [{first: objectNotContaining({second: {}})}, {first: {second: {}}}],
-    [{}, {foo: undefined}],
-  ].forEach(([sample, received]) => {
+  (
+    [
+      [{}, null],
+      [{foo: 'foo'}, {foo: 'foo', jest: 'jest'}],
+      [{foo: 'foo', jest: 'jest'}, {foo: 'foo'}],
+      [{foo: undefined}, {foo: undefined}],
+      [{foo: undefined}, {}],
+      [{first: {second: {}}}, {first: {second: {}}}],
+      [{first: objectContaining({second: {}})}, {first: {second: {}}}],
+      [{first: objectNotContaining({second: {}})}, {first: {second: {}}}],
+      [{}, {foo: undefined}],
+    ] as const
+  ).forEach(([sample, received]) => {
     jestExpect(objectNotContaining(sample).asymmetricMatch(received)).toEqual(
       !objectContaining(sample).asymmetricMatch(received),
     );
   });
 });
 
 test('ObjectNotContaining throws for non-objects', () => {
-  jestExpect(() => objectNotContaining(1337).asymmetricMatch()).toThrow();
+  jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
+    objectNotContaining(1337).asymmetricMatch();
+  }).toThrow(
+    "You must provide an object to ObjectNotContaining, not 'number'.",
+  );
 });
 
 test('StringContaining matches string against string', () => {
@@ -313,8 +331,9 @@ test('StringContaining matches string against string', () => {
 
 test('StringContaining throws if expected value is not string', () => {
   jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
     stringContaining([1]).asymmetricMatch('queen');
-  }).toThrow();
+  }).toThrow('Expected is not a string');
 });
 
 test('StringContaining returns false if received value is not string', () => {
@@ -328,8 +347,9 @@ test('StringNotContaining matches string against string', () => {
 
 test('StringNotContaining throws if expected value is not string', () => {
   jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
     stringNotContaining([1]).asymmetricMatch('queen');
-  }).toThrow();
+  }).toThrow('Expected is not a string');
 });
 
 test('StringNotContaining returns true if received value is not string', () => {
@@ -348,8 +368,9 @@ test('StringMatching matches string against string', () => {
 
 test('StringMatching throws if expected value is neither string nor regexp', () => {
   jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
     stringMatching([1]).asymmetricMatch('queen');
-  }).toThrow();
+  }).toThrow('Expected is not a String or a RegExp');
 });
 
 test('StringMatching returns false if received value is not string', () => {
@@ -372,8 +393,9 @@ test('StringNotMatching matches string against string', () => {
 
 test('StringNotMatching throws if expected value is neither string nor regexp', () => {
   jestExpect(() => {
+    // @ts-expect-error: Testing runtime error
     stringNotMatching([1]).asymmetricMatch('queen');
-  }).toThrow();
+  }).toThrow('Expected is not a String or a RegExp');
 });
 
 test('StringNotMatching returns true if received value is not string', () => {
@@ -451,26 +473,30 @@ describe('closeTo', () => {
 
   test('closeTo throw if expected is not number', () => {
     jestExpect(() => {
+      // @ts-expect-error: Testing runtime error
       closeTo('a');
-    }).toThrow();
+    }).toThrow('Expected is not a Number');
   });
 
   test('notCloseTo throw if expected is not number', () => {
     jestExpect(() => {
+      // @ts-expect-error: Testing runtime error
       notCloseTo('a');
-    }).toThrow();
+    }).toThrow('Expected is not a Number');
   });
 
   test('closeTo throw if precision is not number', () => {
     jestExpect(() => {
+      // @ts-expect-error: Testing runtime error
       closeTo(1, 'a');
-    }).toThrow();
+    }).toThrow('Precision is not a Number');
   });
 
   test('notCloseTo throw if precision is not number', () => {
     jestExpect(() => {
+      // @ts-expect-error: Testing runtime error
       notCloseTo(1, 'a');
-    }).toThrow();
+    }).toThrow('Precision is not a Number');
   });
 
   test('closeTo return false if received is not number', () => {

packages/expect/src/__tests__/extend.test.ts

@@ -16,7 +16,7 @@ expect.addSnapshotSerializer(alignedAnsiStyleSerializer);
 jestExpect.extend({
   toBeDivisibleBy(actual: number, expected: number) {
     const pass = actual % expected === 0;
-    const message = pass
+    const message: () => string = pass
       ? () =>
           `expected ${this.utils.printReceived(
             actual,
@@ -51,29 +51,47 @@ jestExpect.extend({
   },
 });
 
+declare module '../types' {
+  interface AsymmetricMatchers {
+    toBeDivisibleBy(expected: number): void;
+    toBeSymbol(expected: symbol): void;
+    toBeWithinRange(floor: number, ceiling: number): void;
+  }
+  interface Matchers<R> {
+    toBeDivisibleBy(expected: number): R;
+    toBeSymbol(expected: symbol): R;
+    toBeWithinRange(floor: number, ceiling: number): R;
+
+    shouldNotError(): R;
+    toFailWithoutMessage(): R;
+    toBeOne(): R;
+    toAllowOverridingExistingMatcher(): R;
+  }
+}
+
 it('is available globally when matcher is unary', () => {
   jestExpect(15).toBeDivisibleBy(5);
   jestExpect(15).toBeDivisibleBy(3);
   jestExpect(15).not.toBeDivisibleBy(6);
 
-  jestExpect(() =>
+  expect(() =>
     jestExpect(15).toBeDivisibleBy(2),
   ).toThrowErrorMatchingSnapshot();
 });
 
 it('is available globally when matcher is variadic', () => {
   jestExpect(15).toBeWithinRange(10, 20);
-  jestExpect(15).not.toBeWithinRange(6);
+  jestExpect(15).not.toBeWithinRange(6, 10);
 
-  jestExpect(() =>
+  expect(() =>
     jestExpect(15).toBeWithinRange(1, 3),
   ).toThrowErrorMatchingSnapshot();
 });
 
 it('exposes matcherUtils in context', () => {
   jestExpect.extend({
-    _shouldNotError(_actual: unknown, _expected: unknown) {
-      const pass = this.equals(
+    shouldNotError(_actual: unknown) {
+      const pass: boolean = this.equals(
         this.utils,
         Object.assign(matcherUtils, {
           iterableEquality,
@@ -88,13 +106,13 @@ it('exposes matcherUtils in context', () => {
     },
   });
 
-  jestExpect()._shouldNotError();
+  jestExpect('test').shouldNotError();
 });
 
 it('is ok if there is no message specified', () => {
   jestExpect.extend({
     toFailWithoutMessage(_expected: unknown) {
-      return {pass: false};
+      return {message: () => '', pass: false};
     },
   });
 
@@ -107,13 +125,13 @@ it('exposes an equality function to custom matchers', () => {
   // jestExpect and expect share the same global state
   expect.assertions(3);
   jestExpect.extend({
-    toBeOne() {
+    toBeOne(_expected: unknown) {
       expect(this.equals).toBe(equals);
-      return {pass: !!this.equals(1, 1)};
+      return {message: () => '', pass: !!this.equals(1, 1)};
     },
   });
 
-  expect(() => jestExpect().toBeOne()).not.toThrow();
+  expect(() => jestExpect('test').toBeOne()).not.toThrow();
 });
 
 it('defines asymmetric unary matchers', () => {
@@ -170,15 +188,15 @@ it('prints the Symbol into the error message', () => {
 it('allows overriding existing extension', () => {
   jestExpect.extend({
     toAllowOverridingExistingMatcher(_expected: unknown) {
-      return {pass: _expected === 'bar'};
+      return {message: () => '', pass: _expected === 'bar'};
     },
   });
 
   jestExpect('foo').not.toAllowOverridingExistingMatcher();
 
   jestExpect.extend({
     toAllowOverridingExistingMatcher(_expected: unknown) {
-      return {pass: _expected === 'foo'};
+      return {message: () => '', pass: _expected === 'foo'};
     },
   });
 
@@ -188,20 +206,23 @@ it('allows overriding existing extension', () => {
 it('throws descriptive errors for invalid matchers', () => {
   expect(() =>
     jestExpect.extend({
+      // @ts-expect-error: Testing runtime error
       default: undefined,
     }),
   ).toThrow(
     'expect.extend: `default` is not a valid matcher. Must be a function, is "undefined"',
   );
   expect(() =>
     jestExpect.extend({
+      // @ts-expect-error: Testing runtime error
       default: 42,
     }),
   ).toThrow(
     'expect.extend: `default` is not a valid matcher. Must be a function, is "number"',
   );
   expect(() =>
     jestExpect.extend({
+      // @ts-expect-error: Testing runtime error
       default: 'foobar',
     }),
   ).toThrow(

packages/expect/src/__tests__/stacktrace.test.ts

@@ -9,32 +9,42 @@
 import jestExpect from '../';
 
 jestExpect.extend({
-  toCustomMatch(callback: () => unknown, expectation: unknown) {
+  toCustomMatch(callback: () => unknown, expected: unknown) {
     const actual = callback();
 
-    if (actual !== expectation) {
+    if (actual !== expected) {
       return {
-        message: () => `Expected "${expectation}" but got "${actual}"`,
+        message: () => `Expected "${expected}" but got "${actual}"`,
         pass: false,
       };
     }
 
-    return {pass: true};
+    return {
+      message: () => '',
+      pass: true,
+    };
   },
-  toMatchPredicate(received: unknown, argument: (a: unknown) => void) {
-    argument(received);
+  toMatchPredicate(received: unknown, expected: (a: unknown) => void) {
+    expected(received);
     return {
       message: () => '',
       pass: true,
     };
   },
 });
 
+declare module '../types' {
+  interface Matchers<R> {
+    toCustomMatch(expected: unknown): R;
+    toMatchPredicate(expected: (a: unknown) => void): R;
+  }
+}
+
 it('stack trace points to correct location when using matchers', () => {
   try {
     jestExpect(true).toBe(false);
   } catch (error: any) {
-    expect(error.stack).toContain('stacktrace.test.ts:35');
+    expect(error.stack).toContain('stacktrace.test.ts:45:22');
   }
 });
 
@@ -44,7 +54,7 @@ it('stack trace points to correct location when using nested matchers', () => {
       jestExpect(value).toBe(false);
     });
   } catch (error: any) {
-    expect(error.stack).toContain('stacktrace.test.ts:44');
+    expect(error.stack).toContain('stacktrace.test.ts:54:25');
   }
 });
 
@@ -60,6 +70,6 @@ it('stack trace points to correct location when throwing from a custom matcher',
       foo();
     }).toCustomMatch('bar');
   } catch (error: any) {
-    expect(error.stack).toContain('stacktrace.test.ts:57');
+    expect(error.stack).toContain('stacktrace.test.ts:67:15');
   }
 });