How To Register For Scat Test
WHY MOCK?
Most of the classes we come across have dependencies. and often times methods delegates some of the piece of work to other methods in other classes, and we call these classes dependencies. When unit testing such methods, if we but used JUnit, our tests will also depend on those methods as well. Nosotros want the unit of measurement tests to be independent of all other dependencies.
- eg: we want to examination the method
addCustomerinCustomerServiceform, and within thisaddCustomermethod, the save method of theCustomerDaoclass is invoked. We don't want to call the real implementation of theCustomerDaosalve()method for a few reasons:- We only want to test the logic within the
addCustomer()in isolation. - We may not yet accept implemented it.
- We don't want the unit examination of the
addCustomer()neglect if there is a defect insave()method in theCustomerDao.
- We only want to test the logic within the
- Then we should some how mock the beliefs of the dependencies. This is where mocking frameworks comes in to play.
- Mockito framework is what I utilize for just this and in this post we'll see how to use mockito finer to mock those dependencies.
If you lot are new to unit testing with JUnit, please check out the previous post on How to write corking unit tests with JUnit
What is mockito?
Mockito is a mocking framework that tastes really good. It lets yous write beautiful tests with a clean & simple API. Mockito doesn't give you hangover because the tests are very readable and they produce clean verification errors.
— "Mockito." Mockito Framework Site. N.p., north.d. Web. 28 Apr. 2017.
HOW TO INJECT MOCKS
So going dorsum to the example above, how exercise nosotros mock out the dependency using Mockito? Well, we could inject a mock to the class under examination instead of the existent implementation while we run our tests!
Let's look at an instance of a class under test which has a dependency on CustomerDao
public course CustomerService { @Inject private CustomerDao customerDao ; public boolean addCustomer ( Client client ){ if ( customerDao . exists ( customer . getPhone ())){ return faux ; } return customerDao . save ( customer ); } public CustomerDao getCustomerDao () { render customerDao ; } public void setCustomerDao ( CustomerDao customerDao ) { this . customerDao = customerDao ; } } Following is the exam which mocks the dependency using Mockito
public course CustomerServiceTest { @Mock private CustomerDao daoMock ; @InjectMocks private CustomerService service ; @Before public void setUp () throws Exception { MockitoAnnotations . initMocks ( this ); } @Examination public void exam () { //assertion here } } Let's look at the office of the annotations in the to a higher place example.
-
@Mockwill create a mock implementation for theCustomerDao -
@InjectMockswill inject the mocks marked with@Mockto this instance when information technology is created. - And so when or where are these instances created? Well, it is washed past this line which reside in the setUp method.
MockitoAnnotations.initMocks(this);
- And then these instances would be created at the outset of every test method of this test class.
HOW TO MOCK METHODS WITH MOCKITO
Keen! now nosotros have successfully created and injected the mock, and now we should tell the mock how to carry when certain methods are called on information technology.
The when then design
- We do this in each of the examination methods, the following line of code tells the Mockito framework that we want the
relieve()method of the mock dao instance to return true when passed in a certain client instance.
when(dao.salve(customer)).thenReturn(true);
-
whenis a static method of the Mockito course and it returns anOngoingStubbing<T>(Tis the return type of the method that we are mocking, in this instance information technology isboolean) - So if we just extract that out to get hold of the stub, it looks like this:
OngoingStubbing<Boolean> stub = when(dao.save(customer));
- Following are some of the methods that we can call on this
stub-
thenReturn(returnValue) -
thenThrow(exception) -
thenCallRealMethod() -
thenAnswer()- this could exist used to set up smarter stubs and likewise mock behavior of void methods as well (encounter How to mock void method behavior).
-
-
Merely putting this all in one line again.
when(dao.salve(customer)).thenReturn(true); -
Do we really need to pass in an actual customer object to the relieve method here? No, nosotros could use matchers like the following:
when(dao.save(whatsoever(Customer.form))).thenReturn(true); -
All the same, when there are multiple parameters to a method, we cannot mix matchers and actual objects, for example nosotros cannot practice the following:
Mockito.when(mapper.map(any(), "test")).thenReturn(new Something());This would compile without a complaint just would fail during runtime with an error maxim:
matchers can't be mixed with actual values in the list of arguments to a single method. - Nosotros either have to employ matchers for all parameters or should pass in real values or objects.
Mock behavior of dependencies using Mockito.when - Instance
packet com.tdd ; import static org . hamcrest . CoreMatchers . is ; import static org . junit . Assert . assertThat ; import static org . mockito . Mockito .*; import org.junit.Before ; import org.junit.Test ; import org.mockito.InjectMocks ; import org.mockito.Mock ; import org.mockito.MockitoAnnotations ; public class CustomerServiceTest { @Mock private CustomerDao daoMock ; @InjectMocks private CustomerService service ; @Before public void setUp () throws Exception { MockitoAnnotations . initMocks ( this ); } @Test public void testAddCustomer_returnsNewCustomer () { when ( daoMock . salve ( any ( Customer . class ))). thenReturn ( new Customer ()); Customer customer = new Client (); assertThat ( service . addCustomer ( client ), is ( notNullValue ())); } //Using Answer to gear up an id to the customer which is passed in every bit a parameter to the mock method. @Test public void testAddCustomer_returnsNewCustomerWithId () { when ( daoMock . save ( any ( Customer . class ))). thenAnswer ( new Respond < Client >() { @Override public Customer respond ( InvocationOnMock invocation ) throws Throwable { Object [] arguments = invocation . getArguments (); if ( arguments != null && arguments . length > 0 && arguments [ 0 ] != null ){ Customer customer = ( Customer ) arguments [ 0 ]; customer . setId ( 1 ); return customer ; } return cypher ; } }); Customer customer = new Customer (); assertThat ( service . addCustomer ( customer ), is ( notNullValue ())); } //Throwing an exception from the mocked method @Test ( expected = RuntimeException . class ) public void testAddCustomer_throwsException () { when ( daoMock . save ( any ( Customer . class ))). thenThrow ( RuntimeException . course ); Client customer = new Customer (); service . addCustomer ( customer ); // } } 
HOW TO MOCK VOID METHOS WITH MOCKITO
-
doAnswer- If nosotros want our mocked void method to exercise something (mock the behavior despite being void). -
doThrow- Then at that place isMockito.doThrow()if you want to throw an exception from the mocked void method.
Following is an example of how to use it (not an ideal usecase but just wanted to illustrate the basic usage).
@Examination public void testUpdate () { doAnswer ( new Respond < Void >() { @Override public Void answer ( InvocationOnMock invocation ) throws Throwable { Object [] arguments = invocation . getArguments (); if ( arguments != naught && arguments . length > 1 && arguments [ 0 ] != null && arguments [ i ] != null ) { Customer customer = ( Client ) arguments [ 0 ]; String email = ( Cord ) arguments [ 1 ]; client . setEmail ( electronic mail ); } return null ; } }). when ( daoMock ). updateEmail ( whatever ( Customer . grade ), any ( String . class )); // calling the method under examination Customer customer = service . changeEmail ( "[email protected]" , "[electronic mail protected]" ); //some asserts assertThat ( client , is ( notNullValue ())); assertThat ( customer . getEmail (), is ( equalTo ( "[email protected]" ))); } @Examination ( expected = RuntimeException . class ) public void testUpdate_throwsException () { doThrow ( RuntimeException . class ). when ( daoMock ). updateEmail ( any ( Customer . class ), whatever ( String . class )); // calling the method under examination Customer customer = service . changeEmail ( "[electronic mail protected]" , "[email protected]" ); } } HOW TO Test VOID METHODS WITH MOCKITO - TWO Means
Methods with render values can be tested by asserting the returned value, but how to exam void methods? The void method that y'all want to test could either be calling other methods to get things done or processing the input parameters or perhaps generating some values or all of it. With Mockito, you can examination all of the in a higher place scenarios.
1 | Verify with Mockito
- A great affair about mocking is that we can verify that certain methods have been called on those mock objects during examination execution in addition to assertions or in place of assertions when the method under examination is void.
- There are ii overloaded verify methods.
- one which accepts only the mock object - nosotros can use this if the method is supposed to be invoked only once.
- the other accepts the mock and a
VerificationMode- there are quite a few methods in the Mockito course which provides some useful verificationModes-
times(int wantedNumberOfInvocations) -
atLeast( int wantedNumberOfInvocations ) -
atMost( int wantedNumberOfInvocations ) -
calls( int wantedNumberOfInvocations ) -
only( int wantedNumberOfInvocations ) -
atLeastOnce() -
never()
-
Mockito.verify - Example
package com.tdd ; import static org . hamcrest . CoreMatchers . is ; import static org . junit . Assert . assertThat ; import static org . mockito . Mockito .*; import org.junit.Before ; import org.junit.Test ; import org.mockito.InjectMocks ; import org.mockito.Mock ; import org.mockito.MockitoAnnotations ; public class CustomerServiceTest { @Mock private CustomerDao daoMock ; @InjectMocks individual CustomerService service ; @Earlier public void setUp () throws Exception { MockitoAnnotations . initMocks ( this ); } @Exam public void exam () { when ( daoMock . salve ( any ( Customer . class ))). thenReturn ( true ); Customer customer = new Customer (); assertThat ( service . addCustomer ( client ), is ( truthful )); //verify that the save method has been invoked verify ( daoMock ). salve ( any ( Customer . class )); //the above is like to : verify(daoMock, times(1)).relieve(any(Client.class)); //verify that the exists method is invoked one time verify ( daoMock , times ( 1 )). exists ( anyString ()); //verify that the delete method has never been invoked verify ( daoMock , never ()). delete ( any ( Client . class )); } } 2 | Capture Arguments
Another absurd characteristic is the ArgumentCaptor which allows u.s.a. to capture any arguments passed in to the mocked or spied methods.
Mockito.ArgumentCaptor - Example
package com.service ; import static org . hamcrest . CoreMatchers .*; import static org . junit . Assert . assertThat ; import static org . mockito . Mockito . verify ; import org.junit.Examination ; import org.mockito.ArgumentCaptor ; import org.mockito.Captor ; import org.mockito.InjectMocks ; import org.mockito.Mock ; import org.mockito.MockitoAnnotations ; import com.dao.CustomerDao ; import com.entity.Client ; public class CustomerServiceTest { @Mock individual CustomerDao doaMock ; @InjectMocks private CustomerService service ; @Captor private ArgumentCaptor < Customer > customerArgument ; public CustomerServiceTest () { MockitoAnnotations . initMocks ( this ); } @Examination public void testRegister () { //Requirement: we desire to register a new customer. Every new customer should be assigned a random token before saving in the database. service . register ( new Customer ()); //captures the argument which was passed in to save method. verify ( doaMock ). save ( customerArgument . capture ()); //brand sure a token is assigned by the register method before saving. assertThat ( customerArgument . getValue (). getToken (), is ( notNullValue ())); } } HOW TO SPY WITH MOCKITO
Why spy?
- Sometimes we do demand to call real methods of a dependency just however want to verify or track interactions with that dependency, this is where we would utilise a spy.
- When a field is annotated with
@Spy, Mockito volition create a wrapper around an actual case of that object and therefore nosotros can call real implementation and also verify interactions at the aforementioned time. - Some of the behavior of a spy could be mocked if neened.
- in the example below, the dependency beliefs is not mocked but still information technology's interactions are verified.
import static org . hamcrest . CoreMatchers . is ; import static org . junit . Assert . assertThat ; import static org . mockito . Mockito .*; import org.junit.Before ; import org.junit.Exam ; import org.mockito.InjectMocks ; import org.mockito.MockitoAnnotations ; import org.mockito.Spy ; public grade CustomerServiceTestV2 { @Spy private CustomerDaoImpl daoSpy ; @InjectMocks private CustomerService service ; @Earlier public void setUp () throws Exception { MockitoAnnotations . initMocks ( this ); } @Examination public void exam () { Customer customer = new Customer (); assertThat ( service . addCustomer ( client ), is ( simulated )); verify ( daoSpy ). salvage ( any ( Customer . grade )); verify ( daoSpy , times ( 1 )). exists ( anyString ()); verify ( daoSpy , never ()). delete ( whatever ( Customer . class )); } } Click Here to go the example source code given in this tutorial.
That's it on this mail service, please check out the below websites for more cool features, best practices and guidelines on Mockito.
Official Mockito website
Mockito Main reference documentation
Wiki page
Source: https://javacodehouse.com/blog/mockito-tutorial/
Posted by: morganforway.blogspot.com
0 Response to "How To Register For Scat Test"
Post a Comment