What s the difference between a mock stub

Question

I ve read various articles about mocking vs stubbing in testing  including Martin Fowler s Mocks Aren t Stubs  but still don t understand the difference

User · Answer

Using a mental model really helped me understand this  rather than all of the explanations and articles  that didn t quite  sink in    Imagine your kid has a glass plate on the table and he starts playing with it  Now  you re afraid it will break  So  you give him a plastic plate instead  That would be a Mock  same behavior  same interface   softer  implementation     Now  say you don t have the plastic replacement  so you explain  If you continue playing with it  it will break    That s a Stub  you provided a predefined state in advance   A Dummy would be the fork he didn t even use    and a Spy could be something like providing the same explanation you already used that worked

User · Answer

Stub A stub is an object used to fake a method that has pre-programmed behavior  You may want to use this instead of an existing method in order to avoid unwanted side-effects  e g  a stub could make a fake fetch call that returns a pre-programmed response without actually making a request to a server   Mock A mock is an object used to fake a method that has pre-programmed behavior as well as pre-programmed expectations  If these expectations are not met then the mock will cause the test to fail  e g  a mock could make a fake fetch call that returns a pre-programmed response without actually making a request to a server which would expect e g  the first argument to be http   localhost 3008  otherwise the test would fail   Difference Unlike mocks  stubs do not have pre-programmed expectations that could fail your test

User · Answer

In the codeschool com course  Rails Testing for Zombies  they give this definition of the terms   Stub     For replacing a method with code that returns a specified result    Mock     A stub with an assertion that the method gets called    So as Sean Copenhaver described in his answer  the difference is that mocks set expectations  i e  make assertions  about whether or how they get called

User · Answer

A test subject performs actions in response to certain prompts  function calls  or other stimuli  Here are concrete examples of test situations   Scenario -- EMT student exam  A student has studied to be an Emergency Medical Technician  Go watch Ian Gallagher in Shameless Season 6  Episode 10 if you are unfamiliar with this test situation   It is too expensive to find patients with various illnesses for test purposes  Instead we use actors  We ask the test subject  Ian   you arrive on the scene and the patient is immobilized and unconscious what do you do first   Ian responds  I check if the scene is safe   And the test instructor says  the scene is safe    The instructor  and actor  are able to inject arbitrary answers to the test subject s queries   Here  the instructor  and actor  are a mock  Medical training uses this terminology  e g  mock code simulation  the same as computer scientists   Scenario -- register for a website  You are testing Yahoo  a new email service you heard about  In order to sign up  you must provide your birthday and answers to other intrusive questions   The website requires that you are 21 years or older  So you enter in the value January 1  1970  It meets the requirements and it saves you from the laborious process of implementing a remember-my-birthday-and-type-it-in workflow   This date is a stub  This word usage is specific to computer science

User · Answer

I was reading The Art of Unit Testing  and stumbled upon the following definition      A fake is a generic term that can be used to describe either a stub or a mock object  handwritten or otherwise   because they both look like the real object  Whether a fake is a stub or a mock depends on how it s used in the current test  if it s used to check an interaction  asserted against   it s a mock object  Otherwise  it s a stub

User · Answer

Stubs don t fail your tests  mock can

User · Answer

Stub  I believe the biggest distinction is that a stub you have already written with predetermined behavior  So you would have a class that implements the dependency  abstract class or interface most likely  you are faking for testing purposes and the methods would just be stubbed out with set responses  They would not do anything fancy and you would have already written the stubbed code for it outside of your test   Mock  A mock is something that as part of your test you have to setup with your expectations  A mock is not setup in a predetermined way so you have code that does it in your test  Mocks in a way are determined at runtime since the code that sets the expectations has to run before they do anything   Difference between Mocks and Stubs  Tests written with mocks usually follow an initialize - gt  set expectations - gt  exercise - gt  verify pattern to testing  While the pre-written stub would follow an initialize - gt  exercise - gt  verify    Similarity between Mocks and Stubs  The purpose of both is to eliminate testing all the dependencies of a class or function so your tests are more focused and simpler in what they are trying to prove

User · Answer

I came across this interesting article by UncleBob The Little Mocker  It explains all the terminology in a very easy to understand manner  so its useful for beginners  Martin Fowlers article is a hard read especially for beginners like me

User · Answer

This slide explain the main differences very good      From CSE 403 Lecture 16   University of Washington  slide created by  Marty Stepp

User · Answer

following is my understanding      if you create test objects locally and feed your local service with that  you are using mock object   this will give a test for the method you implemented in your local service  it is used to verify behaviors when you get the test data from the real service provider  though from a test version of interface and get a test version of the object  you are working with stubs the stub can have logic to accept certain input and give corresponding output to help you perform state verification

User · Answer

I have used python examples in my answer to illustrate the differences   Stub - Stubbing is a software development technique used to implement methods of classes early in the development life-cycle  They are used commonly as placeholders for implementation of a known interface  where the interface is finalized or known but the implementation is not yet known or finalized  You begin with stubs  which simply means that you only write the definition of a function down and leave the actual code for later  The advantage is that you won t forget methods and you can continue to think about your design while seeing it in code   You can also have your stub return a static response so that the response can be used by other parts of your code immediately  Stub objects provide a valid response  but it s static no matter what input you pass in  you ll always get the same response   class Foo object       def bar1 self           pass      def bar2 self            or             raise NotImplementedError      def bar3 self            or return dummy data         return  Dummy Data    Mock objects are used in mock test cases they validate that certain methods are called on those objects  Mock objects are simulated objects that mimic the behaviour of real objects in controlled ways  You typically creates a mock object to test the behaviour of some other object  Mocks let us simulate resources that are either unavailable or too unwieldy for unit testing   mymodule py   import os import os path  def rm filename       if os path isfile filename           os remove filename    test py   from mymodule import rm import mock import unittest  class RmTestCase unittest TestCase        mock patch  mymodule os       def test rm self  mock os           rm  any path             test that rm called os remove with the right parameters         mock os remove assert called with  any path    if   name         main         unittest main     This is a very basic example that just runs rm and asserts the parameter it was called with  You can use mock with objects not just functions as shown here  and you can also return a value so a mock object can be used to replace a stub for testing   More on unittest mock  note in python 2 x mock is not included in unittest but is a downloadable module that can be downloaded via pip  pip install mock    I have also read  The Art of Unit Testing  by Roy Osherove and I think it would be great if a similar book was written using Python and Python examples  If anyone knows of such a book please do share  Cheers

User · Answer

To be very clear and practical   Stub  A class or object that implements the methods of the class object to be faked and returns always what you want   Example in JavaScript   var Stub        method a  function param a  param b         return  This is an static result            Mock  The same of stub  but it adds some logic that  verifies  when a method is called so you can be sure some implementation is calling that method    As  mLevan says imagine as an example that you re testing a user registration class  After calling Save  it should call SendConfirmationEmail   A very stupid code Example   var Mock        calls          method a  0          method a  function param a  param b        this method a          console log  Mock method a its been called

User · Answer

A stub is a simple fake object  It just makes sure test runs smoothly  A mock is a smarter stub  You verify your test passes through it

User · Answer

Right from the paper Mock Roles  not Objects  by the developers of jMock       Stubs are dummy implementations of production code that return canned   results  Mock Objects act as stubs  but also include assertions to   instrument the interactions of the target object with its neighbours    So  the main differences are    expectations set on stubs are usually generic  while expectations set on mocks can be more  clever   e g  return this on the first call  this on the second etc    stubs are mainly used to setup indirect inputs of the SUT  while mocks can be used to test both indirect inputs and indirect outputs of the SUT    To sum up  while also trying to disperse the confusion from Fowler s article title  mocks are stubs  but they are not only stubs

User · Answer

Stubs are used on methods with an expected return value which you setup in your test  Mocks are used on void methods which are verified in the Assert that they are called

User · Answer

A stub is a test double that returns values to the SUT    A mock is a test double that a test uses to verify that the SUT correctly invokes a dependency    Also  a mock is often a stub

User · Answer

Mock - A mock intercepts a call to a method or function  or a group of methods and functions like in the case of a mocked class   It is not an alternative to that method or function  In that interception  the mock can do whatever it wants  such as record the input and output  decide to short circuit the call  change the returned value  etc   Stub - A stub is a valid full working implementation of a method or function  or group of methods and functions like in the case of a stubbed class  that has an identical interface signature to the method  function or group of methods and functions it is stubbing for  The stubbed implementation will generally only do things that are acceptable within the context of a unit test  that means it won t do IO for example  while mimicking the behavior of the thing it is stubbing

User · Answer

See below example of mocks vs stubs using C  and Moq framework  Moq doesn t have a special keyword for Stub but you can use Mock object to create stubs too    namespace UnitTestProject2       using Microsoft VisualStudio TestTools UnitTesting      using Moq       TestClass      public class UnitTest1                    lt summary gt              Test using Mock to Verify that GetNameWithPrefix method calls Repository GetName method  once  when Id is greater than Zero              lt  summary gt           TestMethod          public void GetNameWithPrefix IdIsTwelve GetNameCalledOnce                            Arrange              var mockEntityRepository   new Mock lt IEntityRepository gt                 mockEntityRepository Setup m   gt  m GetName It IsAny lt int gt                    var entity   new EntityClass mockEntityRepository Object                  Act              var name   entity GetNameWithPrefix 12                  Assert             mockEntityRepository Verify m   gt  m GetName It IsAny lt int gt      Times Once                          lt summary gt              Test using Mock to Verify that GetNameWithPrefix method doesn t call Repository GetName method when Id is Zero              lt  summary gt           TestMethod          public void GetNameWithPrefix IdIsZero GetNameNeverCalled                            Arrange              var mockEntityRepository   new Mock lt IEntityRepository gt                 mockEntityRepository Setup m   gt  m GetName It IsAny lt int gt                   var entity   new EntityClass mockEntityRepository Object                  Act              var name   entity GetNameWithPrefix 0                  Assert             mockEntityRepository Verify m   gt  m GetName It IsAny lt int gt      Times Never                          lt summary gt              Test using Stub to Verify that GetNameWithPrefix method returns Name with a Prefix              lt  summary gt           TestMethod          public void GetNameWithPrefix IdIsTwelve ReturnsNameWithPrefix                            Arrange              var stubEntityRepository   new Mock lt IEntityRepository gt                 stubEntityRepository Setup m   gt  m GetName It IsAny lt int gt                       Returns  Stub                const string EXPECTED NAME WITH PREFIX    Mr  Stub               var entity   new EntityClass stubEntityRepository Object                  Act              var name   entity GetNameWithPrefix 12                  Assert             Assert AreEqual EXPECTED NAME WITH PREFIX  name                       public class EntityClass               private IEntityRepository  entityRepository          public EntityClass IEntityRepository entityRepository                        this  entityRepository   entityRepository                    public string Name   get  set            public string GetNameWithPrefix int id                        string name   string Empty              if  id  gt  0                                name   this  entityRepository GetName id                             return  Mr      name                      public interface IEntityRepository               string GetName int id             public class EntityRepository IEntityRepository               public string GetName int id                           Code to connect to DB and get name based on Id             return  NameFromDb

User · Answer

A Mock is just testing behaviour  making sure certain methods are called  A Stub is a testable version  per se  of a particular object   What do you mean an Apple way

User · Answer

A stub is an empty function which is used to avoid unhandled exceptions during tests   function foo       A mock is an artificial function which is used to avoid OS  environment or hardware dependencies during tests   function foo bar   window   this  return window toString bar       In terms of assertions and state    Mocks are asserted before an event or state change Stubs are not asserted  they provide state before an event to avoid executing code from unrelated units Spies are setup like stubs  then asserted after an event or state change Fakes are not asserted  they run after an event with hardcoded dependencies to avoid state   References   Geek Glossary  Mock Geek Glossary  Stub Geek Glossary  Spy Test Doubles  Fakes  Mocks and Stubs

User · Answer

Plus useful answers  One of the most powerful point of using Mocks than Subs    If the collaborator  which the main code depend on it  is not under our control  e g  from a third-party library   In this case  stub is more difficult to write rather than mock

User · Answer

A Stub is an object that implements an interface of a component  but instead of returning what the component would return when called  the stub can be configured to return a value that suits the test  Using stubs a unit test can test if a unit can handle various return values from its collaborator  Using a stub instead of a real collaborator in a unit test could be expressed like this   unit test --  stub  unit test --  unit --  stub  unit test asserts on results and state of unit  First the unit test creates the stub and configures its return values  Then the unit test creates the unit and sets the stub on it  Now the unit test calls the unit which in turn calls the stub  Finally the unit test makes assertions about the results of the method calls on the unit   A Mock is like a stub  only it also has methods that make it possible determine what methods where called on the Mock  Using a mock it is thus possible to both test if the unit can handle various return values correctly  and also if the unit uses the collaborator correctly  For instance  you cannot see by the value returned from a dao object whether the data was read from the database using a Statement or a PreparedStatement  Nor can you see if the connection close   method was called before returning the value  This is possible with mocks  In other words  mocks makes it possible to test a units complete interaction with a collaborator  Not just the collaborator methods that return values used by the unit  Using a mock in a unit test could be expressed like this   unit test --  mock  unit test --  unit --  mock  unit test asserts on result and state of unit  unit test asserts on the methods called on mock  More Detail    Here

User · Answer

I like the explanantion put out by Roy Osherove  video link       Every class or object created is a Fake  It is a Mock if you verify   calls against it  Otherwise its a stub

User · Answer

A stub is a fake object built for test purposes  A mock is a stub that records whether expected calls effectively occurred

User · Answer

Foreword  There are several definitions of objects  that are not real  The general term is test double  This term encompasses  dummy  fake  stub  mock   Reference  According to Martin Fowler s article         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  Stubs may also record information about calls  such as an email gateway stub that remembers the messages it  sent   or maybe only how many messages it  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       Style  Mocks vs Stubs   Behavioral testing vs State testing  Principle  According to the principle of Test only one thing per test  there may be several stubs in one test  but generally there is only one mock   Lifecycle  Test lifecycle with stubs    Setup - Prepare object that is being tested and its stubs collaborators  Exercise - Test the functionality  Verify state - Use asserts to check object s state  Teardown - Clean up resources    Test lifecycle with mocks    Setup data - Prepare object that is being tested  Setup expectations - Prepare expectations in mock that is being used by primary object  Exercise - Test the functionality  Verify expectations - Verify that correct methods has been invoked in mock  Verify state - Use asserts to check object s state  Teardown - Clean up resources    Summary  Both mocks and stubs testing give an answer for the question  What is the result   Testing with mocks are also interested in  How the result has been achieved

User · Answer

I think the simplest and clearer answer about this question is given from Roy Osherove in his book The art of Unit Testing  page 85      The easiest way to tell we   re dealing with a stub is to notice  that the stub can never fail the test  The asserts the test uses are always against    the class under test       On the other hand  the test will use a mock object to verify whether the    test failed or not             Again  the mock object is the object we use to see if the test failed or not    That means if you are making assertions against the fake it means you are using the fake as a mock   if you are using the fake only to run the test without assertion over it you are using the fake as a stub

User · Answer

A mock is both a technical and a functional object      The mock is technical  It is indeed created by a mocking library  EasyMock  JMockit and more recently Mockito are known for these  thanks to byte code generation  The mock implementation is generated in a way where we could instrument it to return a specific value when a method is invoked but also some other things such as verifying that a mock method was invoked with some specific parameters  strict check  or whatever the parameters  no strict check        Instantiating a mock     Mock Foo fooMock   Recording a behavior      when fooMock hello    thenReturn  hello you       Verifying an invocation           verify fooMock  hello     These are clearly not the natural way to instantiate override the Foo class behavior   That s why I refer to a technical aspect      But the mock is also functional because it is an instance of the class we need to isolate from the SUT  And with recorded behaviors on it  we could use it in the SUT in the same way than we would do with a stub        The stub is just a functional object   that is an instance of the class we need to isolate from the SUT and that s all   That means that both the stub class and all behaviors fixtures needed during our unit tests have to be defined explicitly  For example to stub hello   would need to subclass the Foo class  or implements its interface it has it  and to override hello        public class HelloStub extends Hello        public String hello          return  hello you             If another test scenario requires another value return  we would probably need to define a generic way to set the return          public class HelloStub extends Hello        public HelloStub String helloReturn          this helloReturn   helloReturn        public String hello          return helloReturn           Other scenario   if I had a side effect method  no return  and I would check that that method was invoked  I should probably have added a boolean or a counter in the stub class to count how many times the method was invoked        Conclusion   The stub requires often much overhead code to write for your unit test  What mock prevents thanks to providing recording verifying features out of the box  That s why nowadays  the stub approach is rarely used in practice with the advent of excellent mock libraries       About the Martin Fowler Article   I don t think to be a  mockist  programmer while I use mocks and I avoid stubs  But I use  mock when it is really required  annoying dependencies  and I favor  test slicing and mini-integration tests when I test a class with dependencies which mocking would be an overhead

User · Answer

Both Stubs and Mocks override external dependencies but the difference is  Stubs -  To Test Data  Mocks -  To Test Behavior    Fake Dummy -  Test nothing  just override functionality with empty methods  eg replace Logger to avoid any logging noise while testing

User · Answer

Stubs vs  Mocks   Stubs    provide specific answers to methods calls   ex  myStubbedService getValues   just return a String needed by the code under test  used by code under test to isolate it cannot fail test   ex  myStubbedService getValues   just returns the stubbed value  often implement abstract methods  Mocks    superset  of stubs  can assert that certain methods are called   ex  verify that myMockedService getValues   is called only once  used to test behaviour of code under test can fail test   ex  verify that myMockedService getValues   was called once  verification fails  because myMockedService getValues   was not called by my tested code  often mocks interfaces

User · Answer

Reading all the explanations above  let me try to condense    Stub  a dummy piece of code that lets the test run  but you don t care what happens to it  Mock  a dummy piece of code  that you VERIFY is called correctly as part of the test  Spy  a dummy piece of code  that intercepts some calls to a real piece of code  allowing you to verify calls without replacing the entire original object

User · Answer

let see Test Doubles    Fake  Fakes are objects that have working implementations  but not the same as production one  Such as  in-memory implementation of Data Access Object or Repository   Stub  Stub is an object that holds predefined data and uses it to answer calls during tests  Such as  an object that needs to grab some data from the database to respond to a method call   Mocks  Mocks are objects that register calls they receive  In test assertion  we can verify on Mocks that all expected actions were performed  Such as  a functionality that calls e-mail sending service   for more just check this

User · Answer

If you compare it to debugging      Stub is like making sure a method returns the correct value      Mock is like actually stepping into the method and making sure everything inside is correct before returning the correct value

User · Answer

Stub and Mock testing point of view    Stub is dummy implementation done by user in static way mean i e in Stub writing the implementation code  So it can not handle service definition and dynamic condition  Normally this is done in JUnit framework without using mocking framework    Mock is also dummy implementation but its implementation done dynamic way by using Mocking frameworks like Mockito  So we can handle condition and service definition as dynamic way i e  mocks can be created dynamically from code at runtime  So using mock we can implement Stubs dynamically

User · Answer

a lot of valid answers up there but I think worth to mention this form uncle bob  https   8thlight com blog uncle-bob 2014 05 14 TheLittleMocker html  the best explanation ever with examples

User · Answer

A fake is a generic term that can be used to describe either a stub or a mock object  handwritten or otherwise   because they both look like the real object  Whether a fake is a stub or a mock depends on how it   s used in the current test  If it   s used to check an interaction  asserted against   it   s a mock object  Otherwise  it   s a stub  Fakes makes sure test runs smoothly  It means that reader of your future test will understand what will be the behavior of the fake object  without needing to read its source code  without needing to depend on external resource    What does test run smoothly mean  Forexample in below code    public void Analyze string filename                        if filename Length lt 8                                try                                       errorService LogError  long file entered named     filename                                     catch  Exception e                                        mailService SendEMail  admin hotmail com    ErrorOnWebService    someerror                                                You want to test mailService SendEMail   method  to do that you need to simulate an Exception in you test method  so you just need to create a Fake Stub errorService class to simulate that result  then your test code will be able to test mailService SendEMail   method  As you see you need to simulate a result which is from an another External Dependency ErrorService class

User · Answer

Say you have a class named EmployeeService that you want to test and that has one dependency on an interface named EmployeeDao   public class EmployeeService     private EmployeeDao dao     public EmployeeService Dao dao  this dao   dao       public String getEmployeeName int id        Employee emp   bar goToDatabaseAndBringTheEmployeeWithId id        return emp    null emp getFullName null            Further state and behavior    public interface EmployeeDao    Employee goToDatabaseAndBringTheEmployeeWithId int id       Inside your test class   public class EmployeeServiceTest     EmployeeService service     EmployeeDao mockDao   Mockito mock EmployeeDao class    Line 3      Before    public void setUp         service   new EmployeeService mockDao             Tests               In the above test class in line 3  we say to the mocking framework  in this case Mockito   Hey  Mockito  craft me an object that has the EmployeeDao functionality   The framework is going to create an object that has the method goToDatabaseAndBringTheEmployeeWithId but actually with no body  It s your job to instruct that mock what to do   This is a mock   But you could also create a class that implements the EmployeeDao interface and use it in the test class instead   public EmployeeDaoStub implements EmployeeDao     public Employee goToDatabaseAndBringTheEmployeeWithId int id           No trip to DB  just returning a dummy Employee object       return new Employee  John   Woo   123 Lincoln str             Inside your test class this time using stub instead of a mock   public class EmployeeServiceTest     EmployeeService service     EmployeeDao daoStub   new EmployeeDaoStub     Line 3      Before    public void setUp         service   new EmployeeService daoStub             Tests               So to wrap it all  stubs are the classes that you create or somebody else does  specifically to imitate some dependency just for the sake of having the desired state  Yes  as all the other people state  it s mostly about a state Whereas mocks are typically created by a mocking framework and you have no idea what its guts look like  But with stubs you know what class you re going to get  It s the one you created   Oh  btw  if your dependency is a class rather than an interface  you can just extend that class to create your stub

User · Answer

I think the most important difference between them is their intentions   Let me try to explain it in WHY stub vs  WHY mock  Suppose I m writing test code for my mac twitter client s public timeline controller  Here is test sample code  twitter api stub  public timeline  and return public timeline array  client ui should receive  insert timeline above  with public timeline array  controller refresh public timeline    STUB  The network connection to twitter API is very slow  which make my test slow  I know it will return timelines  so I made a stub simulating HTTP twitter API  so that my test will run it very fast  and I can running the test even I m offline   MOCK  I haven t written any of my UI methods yet  and I m not sure what methods I need to write for my ui object  I hope to know how my controller will collaborate with my ui object by writing the test code    By writing mock  you discover the objects collaboration relationship by verifying the expectation are met  while stub only simulate the object s behavior   I suggest to read this article if you re trying to know more about mocks  http   jmock org oopsla2004 pdf

User · Answer

Here s a description of each one followed by with real world sample    Dummy - just bogus values to satisfy the API       Example  If you re testing a method of a class which requires many mandatory parameters in a constructor which have no effect on your test  then you may create dummy objects for the purpose of creating new instances of a class   Fake - create a test implementation of a class which may have a dependency on some external infrastructure   It s good practice that your unit test does NOT actually interact with external infrastructure       Example  Create fake implementation for accessing a database  replace it with in-memory collection   Stub - override methods to return hard-coded values  also referred to as state-based      Example  Your test class depends on a method Calculate   taking 5 minutes to complete  Rather than wait for 5 minutes you can replace its real implementation with stub that returns hard-coded values  taking only a small fraction of the time   Mock - very similar to Stub but interaction-based rather than state-based  This means you don t expect from Mock to return some value  but to assume that specific order of method calls are made      Example  You re testing a user registration class  After calling Save  it should call SendConfirmationEmail     Stubs and Mocks are actually sub types of Mock  both swap real implementation with test implementation  but for different  specific reasons

User · Answer

Stub helps us to run test  How  It gives values which helps to run test  These values are itself not real and we created these values just to run the test  For example we create a HashMap to give us values which are similar to values in database table  So instead of directly interacting with database we interact with Hashmap   Mock is an fake object which runs the test  where we put assert

[testing] What's the difference between a mock & stub?

Examples related to testing

Examples related to mocking

Examples related to stub