6. Mocking Functions and Modules

Question 1

What are the advantages of mocking?

Answer 1

1. Reduce dependencies required by tests, allowing faster execution.
2. Prevent “side effects” during testing.
3. Build custom mocks to facilitate desired testing procedures.

Question 2

What is a mock?

Answer 2

A convincing duplicate of an object with no internal workings — it has the same API as the original, but no side effects.

Question 3

How can a mock be created?

Answer 3

Automatically or manually.

Question 4

What is the process of mocking?

Answer 4

1. Scan the original object for methods, give the new object spy methods with the same names.
2. Ensure that any methods which returned a promise still return a promise in the mock.
3. Create mocks for any complex values that are returned from methods that are required for tests.

Question 5

What are mock functions also known as?

Answer 5

Spies.

Question 6

What are spies?

Answer 6

Mock functions.

Question 7

Do spies have side effects?

Answer 7

No.

Question 8

What are the six characteristics of mock functions?

Answer 8

1. Also known as “spies”.
2. No side-effects.
3. Count function calls.
4. Records arguments passed when called.
5. Can be “loaded” with return values.
6. Return value must approximate original.

Question 9

In what way do spies track the mocked function?

Answer 9

They count function calls and record the arguments passed.

Question 10

Where must mocks reside?

Answer 10

In a __mocks__ folder next to the mocked module.

Question 11

What modules can be mocked?

Answer 11

Bot NPM modules and the local modules can be mocked.

Question 12

If you mock an npm package using its original name inside the [root]/__mocks__ folder, what happens when you try to load that npm module in your tests?

Answer 12

Your mock is loaded instead of the npm package’s function.

Question 13

How do you define a spy with a specific return value?

Answer 13

By using jest.fn() and passing it an anonymous function that returns the value.

eg. `const mySpy = jest.fn(() => “foo”);

Question 14

How do you assert that a spy function was called with a specific parameter?

Answer 14

By using the .toHaveBeenCalledWith and passing it the parameter you expect it to have received.

eg. `expect(mySpy).toHaveBeenCalledWith(‘foo’);

Question 15

Which one takes precedence, manual or automatic mocks?

Answer 15

Manual mocks.

Question 16

What are the four main properties of manual mocking?

Answer 16

1. Exists as a separate file alongside the file being mocked.
2. Will be used automatically for NPM modules.
3. Requires more work than automatic mocks.
4. Needs to be updated when mocked file changes.

Question 17

What are the four main properties of automatic mocking?

Answer 17

1. Most modules can be automatically replaced with mocks.
2. Usually generated correctly, but sometimes not!
3. Greatly reduced the likelihood of side effects during testing.
4. Developer must use discretion.

Question 18

What are the N automatic mocking challenges?

Answer 18

1. Methods returning a specific and complex value often can’t be mocked automatically.
2. Methods that are not part of your module at compile-time won’t be mocked.
3. Modules that you did not expect to be mocked may be mocked.

Question 19

What can be said about manual vs automatic mocking when it comes to simple vs advanced modules?

Answer 19

Simple modules can be automatically mocked whereas advanced ones may need manual mocking.

Question 20

How are the manual mocks of modules created?

Answer 20

By placing a correctly named file in the \_\_mocks\_\_ directory.