feat(expect): remove alias methods (#14632)

Co-authored-by: EduardoSCosta <eduardoscaraujo@gmail.com>

CHANGELOG.md

@@ -44,6 +44,7 @@
 - `[*]` Depend on exact versions of monorepo dependencies instead of `^` range ([#14553](https://github.com/facebook/jest/pull/14553))
 - `[*]` [**BREAKING**] Add ESM wrapper for all of Jest's modules ([#14661](https://github.com/jestjs/jest/pull/14661))
 - `[babel-jest, babel-preset-jest]` [**BREAKING**] Increase peer dependency of `@babel/core` to `^7.11` ([#14109](https://github.com/jestjs/jest/pull/14109))
+- `[expect]` [**BREAKING**] Remove `.toBeCalled()`, `.toBeCalledTimes()`, `.toBeCalledWith()`, `.lastCalledWith()`, `.nthCalledWith()`, `.toReturn()`, `.toReturnTimes()`, `.toReturnWith()`, `.lastReturnedWith()`, `.nthReturnedWith()` and `.toThrowError()` matcher aliases ([#14632](https://github.com/facebook/jest/pull/14632))
 - `[jest-cli, jest-config, @jest/types]` [**BREAKING**] Remove deprecated `--init` argument ([#14490](https://github.com/jestjs/jest/pull/14490))
 - `[jest-config, @jest/core, jest-util]` Upgrade `ci-info` ([#14655](https://github.com/jestjs/jest/pull/14655))
 - `[jest-transform]` Upgrade `write-file-atomic` ([#14274](https://github.com/jestjs/jest/pull/14274))

docs/ExpectAPI.md

@@ -144,8 +144,6 @@ Although the `.toBe` matcher **checks** referential identity, it **reports** a d
 
 ### `.toHaveBeenCalled()`
 
-Also under the alias: `.toBeCalled()`
-
 Use `.toHaveBeenCalledWith` to ensure that a mock function was called with specific arguments. The arguments are checked with the same algorithm that `.toEqual` uses.
 
 For example, let's say you have a `drinkAll(drink, flavour)` function that takes a `drink` function and applies it to all available beverages. You might want to check that `drink` gets called for `'lemon'`, but not for `'octopus'`, because `'octopus'` flavour is really weird and why would anything be octopus-flavoured? You can do that with this test suite:
@@ -174,8 +172,6 @@ describe('drinkAll', () => {
 
 ### `.toHaveBeenCalledTimes(number)`
 
-Also under the alias: `.toBeCalledTimes(number)`
-
 Use `.toHaveBeenCalledTimes` to ensure that a mock function got called exact number of times.
 
 For example, let's say you have a `drinkEach(drink, Array<flavor>)` function that takes a `drink` function and applies it to array of passed beverages. You might want to check that drink function was called exact number of times. You can do that with this test suite:
@@ -190,8 +186,6 @@ test('drinkEach drinks each drink', () => {
 
 ### `.toHaveBeenCalledWith(arg1, arg2, ...)`
 
-Also under the alias: `.toBeCalledWith()`
-
 Use `.toHaveBeenCalledWith` to ensure that a mock function was called with specific arguments. The arguments are checked with the same algorithm that `.toEqual` uses.
 
 For example, let's say that you can register a beverage with a `register` function, and `applyToAll(f)` should apply the function `f` to all registered beverages. To make sure this works, you could write:
@@ -208,8 +202,6 @@ test('registration applies correctly to orange La Croix', () => {
 
 ### `.toHaveBeenLastCalledWith(arg1, arg2, ...)`
 
-Also under the alias: `.lastCalledWith(arg1, arg2, ...)`
-
 If you have a mock function, you can use `.toHaveBeenLastCalledWith` to test what arguments it was last called with. For example, let's say you have a `applyToAllFlavors(f)` function that applies `f` to a bunch of flavors, and you want to ensure that when you call it, the last flavor it operates on is `'mango'`. You can write:
 
 ```js
@@ -222,8 +214,6 @@ test('applying to all flavors does mango last', () => {
 
 ### `.toHaveBeenNthCalledWith(nthCall, arg1, arg2, ....)`
 
-Also under the alias: `.nthCalledWith(nthCall, arg1, arg2, ...)`
-
 If you have a mock function, you can use `.toHaveBeenNthCalledWith` to test what arguments it was nth called with. For example, let's say you have a `drinkEach(drink, Array<flavor>)` function that applies `f` to a bunch of flavors, and you want to ensure that when you call it, the first flavor it operates on is `'lemon'` and the second one is `'octopus'`. You can write:
 
 ```js
@@ -243,8 +233,6 @@ The nth argument must be positive integer starting from 1.
 
 ### `.toHaveReturned()`
 
-Also under the alias: `.toReturn()`
-
 If you have a mock function, you can use `.toHaveReturned` to test that the mock function successfully returned (i.e., did not throw an error) at least one time. For example, let's say you have a mock `drink` that returns `true`. You can write:
 
 ```js
@@ -259,8 +247,6 @@ test('drinks returns', () => {
 
 ### `.toHaveReturnedTimes(number)`
 
-Also under the alias: `.toReturnTimes(number)`
-
 Use `.toHaveReturnedTimes` to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times. Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
 
 For example, let's say you have a mock `drink` that returns `true`. You can write:
@@ -278,8 +264,6 @@ test('drink returns twice', () => {
 
 ### `.toHaveReturnedWith(value)`
 
-Also under the alias: `.toReturnWith(value)`
-
 Use `.toHaveReturnedWith` to ensure that a mock function returned a specific value.
 
 For example, let's say you have a mock `drink` that returns the name of the beverage that was consumed. You can write:
@@ -297,8 +281,6 @@ test('drink returns La Croix', () => {
 
 ### `.toHaveLastReturnedWith(value)`
 
-Also under the alias: `.lastReturnedWith(value)`
-
 Use `.toHaveLastReturnedWith` to test the specific value that a mock function last returned. If the last call to the mock function threw an error, then this matcher will fail no matter what value you provided as the expected return value.
 
 For example, let's say you have a mock `drink` that returns the name of the beverage that was consumed. You can write:
@@ -318,8 +300,6 @@ test('drink returns La Croix (Orange) last', () => {
 
 ### `.toHaveNthReturnedWith(nthCall, value)`
 
-Also under the alias: `.nthReturnedWith(nthCall, value)`
-
 Use `.toHaveNthReturnedWith` to test the specific value that a mock function returned for the nth call. If the nth call to the mock function threw an error, then this matcher will fail no matter what value you provided as the expected return value.
 
 For example, let's say you have a mock `drink` that returns the name of the beverage that was consumed. You can write:
@@ -782,8 +762,6 @@ describe('the La Croix cans on my desk', () => {
 
 ### `.toThrow(error?)`
 
-Also under the alias: `.toThrowError(error?)`
-
 Use `.toThrow` to test that a function throws when it is called. For example, if we want to test that `drinkFlavor('octopus')` throws, because octopus flavor is too disgusting to drink, we could write:
 
 ```js

e2e/__tests__/isolateModules.test.ts

@@ -45,7 +45,7 @@ test('works with mocks', () => {
           require("./read");
         });
 
-        expect(configGetMock).toBeCalledTimes(1);
+        expect(configGetMock).toHaveBeenCalledTimes(1);
       })
     `,
   });