[SOLVED] Mock vs Spy in Angular


I’m new to Angular and am working on unit testing.

I’m trying to confirm my understanding of Fakes vs Spies (spyOn).

My understanding is that Fakes let you mock up data that is not really being returned from a service. It’s just simulating like it is passing from a service.

Spies on the other hand let you actually call, or spy on, a service and get back a real result to compare in your test.

Am I correct?


Here’s some info that will help you make the difference better:

Dummy objects are passed around but never actually used. Usually they are just used to fill parameter lists.

Fake objects actually have working implementations, but usually take some shortcut which makes them not suitable for production (an in memory database is a good example).

Stubs provide canned answers to calls made during the test, usually not responding at all to anything outside what’s programmed in for the test.

Spies are stubs that also record some information based on how they were called. One form of this might be an email service that records how many messages it was sent.

Mocks are what we are talking about here: objects pre-programmed with expectations which form a specification of the calls they are expected to receive.

Long article here

And now that you know what is the difference between a stub and a spy, here’s some more info which explains it even better 🙂

A test double is an object that can stand in for a real object in a test, similar to how a stunt double stands in for an actor in a movie. These are sometimes all commonly referred to as “mocks”, but it’s important to distinguish between the different types of test doubles since they all have different uses. The most common types of test doubles are stubs, mocks, and fakes.

A stub has no logic, and only returns what you tell it to return. Stubs can be used when you need an object to return specific values in order to get your code under test into a certain state. While it’s usually easy to write stubs by hand, using a mocking framework is often a convenient way to reduce boilerplate.

A mock has expectations about the way it should be called, and a test should fail if it’s not called that way. Mocks are used to test interactions between objects, and are useful in cases where there are no other visible state changes or return results that you can verify (e.g. if your code reads from disk and you want to ensure that it doesn’t do more than one disk read, you can use a mock to verify that the method that does the read is only called once).

A fake doesn’t use a mocking framework: it’s a lightweight implementation of an API that behaves like the real implementation, but isn’t suitable for production (e.g. an in-memory database). Fakes can be used when you can’t use a real implementation in your test (e.g. if the real implementation is too slow or it talks over the network). You shouldn’t need to write your own fakes often since fakes should usually be created and maintained by the person or team that owns the real implementation.

Code examples here.

Answered By – Lucia P.

Answer Checked By – Cary Denson (BugsFixing Admin)

Leave a Reply

Your email address will not be published. Required fields are marked *