PowerMockito usage preparation

Powermockito is required when:
----------------------------------------------------

-    We are unable to mock static methods using normal mockito API.
-    We want to test final classes / methods
-    We are unable to test private methods.
-    We want to mock constructor.

Powermockito limitations:
-------------------------------------------
-    Currently there are no limitations with this API.


Creating mock object with PowerMockito:
-------------------------------------------------------------------
//similar to Mockito
    Singleton mockedObj=PowerMockito.mock(Singleton.class);

//writing stub methods is same as Mockito

 
Mock static method example:
-----------------------------------------------
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.nagarjuna.java.junit.A;
import com.nagarjuna.java.junit.B;
import com.nagarjuna.java.junit.Singleton;

@RunWith(PowerMockRunner.class)
@PrepareForTest({ A.class, B.class, Singleton.class })
public class TestPowerMock {
    @Before
    public void init() {
        PowerMockito.mockStatic(Singleton.class);
        PowerMockito.when(Singleton.getOwnerName()).thenReturn("Suhail");
    }
    @Test
    public void test() {
        System.out.println(Singleton.getOwnerName());
    }
}



Mock private static method example:
--------------------------------------------------
//Similar to mock normal methods..
    http://code.google.com/p/powermock/wiki/MockitoUsage13

Mock void static method example:
-------------------------------------------------------
    PowerMockito.doThrow(new NullPointerException()).when(Singleton.class, "go");
    Singleton.go(); // will throw NullPointerException






Important Note:
-   Partial mock can be done in both Mockito and PowerMockito API using spy concept.
 
Powermockito maevn depedency:
------------------------------------------------------
   
        1.5.4
   
   
       
       
            junit
            junit
            4.11
       
       
            org.powermock
            powermock-module-junit4
            ${powermock.version}
       
       
            org.powermock
            powermock-module-junit4-common
            ${powermock.version}
       
       
            org.powermock
            powermock-api-mockito
            ${powermock.version}
       
       
            org.powermock
            powermock-api-support
            ${powermock.version}
       
       
            org.powermock
            powermock-core
            ${powermock.version}
       
       
            org.powermock
            powermock-api-easymock
            ${powermock.version}
       
       
            cglib
            cglib
            2.2.2
       
       
            easymock
            easymock
            2.0
       
   


VeryGood Resource: http://www.packtpub.com/article/mocking-static-methods

Mockito usage preparation

Mockito is required when:

-    We don't require / unable to create an object to a class which depends on any network related objects.  We can create a mock object to that class and write stubbing method calls.

-    We are unable to stop an object functionality which depends on other object ( returns some response) that will be impossible.  We can spy the real object and write stubbing method calls.

-   


Limitations with Mockito:
-----------------------------------------
-    We can't create mock object to final / immutable classes.
-    We can't write stub method calls for static methods in a class.
-    We can't write stub method calls for private methods in a class.
-    Mockito framework is useful only to create mock object and write stubb method calls on those mocked objects, ( not on static methods ). Go for PowerMockito


Basic examples:

Creating a mock object to class / Interface:
-------------------------------------------------------------------
import org.mockito.Mockito;
    List mockedList=Mockito.mock(List.class);   
    List mockedListC=Mockito.mock(ArrayList.class);



 

Writing basic stub method calls for non-void methods:
---------------------------------------------------------------------------------------
    Mockito.when(mockedList.get(Mockito.anyInt())).thenReturn("mockedresult");

 

Writing basic stub method calls for void methods - mocked object :
----------------------------------------------------------------------------------------------------------
    Stubbing voids requires different approach from when(Object) because the compiler does not like void methods inside brackets...

    doThrow(new RuntimeException()).when(mockedList).clear();

 
 Creating spy object:
-------------------------------
When you use the spy then the real methods are called (unless a method was stubbed).
    List list = new LinkedList();
    List spy = spy(list);


Writing basic stub method calls for void methods - spy object:
-----------------------------------------------------------------------------------------------
Sometimes it's impossible or impractical to use when(Object) for stubbing spies. Therefore when using spies please consider doReturn|Answer|Throw() family of methods for stubbing.
    List list = new LinkedList();
    List spy = spy(list);
   
    //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
    when(spy.get(0)).thenReturn("foo");
   
    //You have to use doReturn() for stubbing
    doReturn("foo").when(spy).get(0);

 
Reset mock objects:
--------------------------------
    Mockito.reset(mockedList);






Maven depedency:
       
            org.mockito
            mockito-all
            1.9.5
       

Simple introduction to JUnit

Hi All,

  After a long time I am started posting ....:)

  In this post I show you how to use JUnit4.11

Junit is a java framework for the sake of unit test for our java code.

Here we have to know some notable annnotations .

1) @Before
2) @After
3) @BeforeClass
4) @AfterClass
5) @Test

@Before
    This annotation is used for any object level initialisation part.

This initialisation part will execute once per each test case in a test class.

Suppose if a test class has 4 test cases then this initialisation part will execute 4 times.

@After
    This annotation is used for any object level cleanup part.

This cleanup part will execute once per each test case in a test class.

Suppose if a test class has 4 test cases then this cleanup part will execute 4 times.

@BeforeClass
    This annotation is used for class level initialisation part.

This initialisation part will execute once per test class.

Suppose if a test class has 4 test cases then this cleanup part will execute 1 time only.

@AfterClass
    This annotation is used for class level cleanup part.

This cleanup part will execute once per test class.

Suppose if a test class has 4 test cases then this cleanup part will execute 1 time only.

@Test
    This annotation is the main one which executes our test case.

If you want any method to be executed without main method then use this annotation.

You have to use assertions for test pass.
We can have many assertions from junit framework.

Ex:- assertNotNull,
    assertNull,
    assertTrue,
    assertFalse,
    assertEquals,
    assertNotEquals.....etc