add mockito test case

Author: openweb

.idea/uiDesigner.xml

@@ -0,0 +1,29 @@
+package tech.rongxing.devops.mockito;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+public class CapturingArguments09 {
+    @Test
+    public void test() {
+        @SuppressWarnings("unchecked")
+        List<String> list = mock(List.class);
+        list.add("one");
+        list.add("two");
+
+        ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
+        verify(list,Mockito.times(2)).add(argument.capture());
+        //	assertEquals("one", argument.getValue());
+
+        List<String> list1 =argument.getAllValues();
+        assertEquals("one",list1.get(0));
+        assertEquals("two",list1.get(1));
+    }
+}

src/test/java/tech/rongxing/devops/mockito/CapturingArguments09.java

@@ -0,0 +1,29 @@
+package tech.rongxing.devops.mockito;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.*;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class DeepMocking {
+    @Test
+    public void test(){
+        @SuppressWarnings("unchecked")
+        List<String> mockedList = mock(List.class,Mockito.RETURNS_DEEP_STUBS);
+        //Mockito.when(mockedList.iterator()).thenReturn();
+        Iterator<String> iterator1 = mockedList.iterator();
+        doReturn("aaa").doReturn(null).when(iterator1).next();
+        //.thenReturn(null);
+        Iterator<String> iterator = iterator1;
+        assertNotNull(iterator);
+        assertFalse(iterator.hasNext());
+        assertNotNull(iterator.next());
+        assertNotNull(iterator.next());
+    }
+}
+

src/test/java/tech/rongxing/devops/mockito/DeepMocking.java

@@ -0,0 +1,21 @@
+package tech.rongxing.devops.mockito;
+
+import java.util.List;
+import org.junit.Test;
+import static org.mockito.Mockito.*;
+
+public class FindingRedundantInvocations06 {
+    @Test
+    public void test(){
+        @SuppressWarnings("unchecked")
+        List<String> mockedList = mock(List.class);
+        //using mocks
+        mockedList.add("one");
+        mockedList.add("two");
+
+        verify(mockedList).add("one");
+        verify(mockedList).add("two");
+        //following verification will fail
+        verifyNoMoreInteractions(mockedList);
+    }
+}

src/test/java/tech/rongxing/devops/mockito/FindingRedundantInvocations06.java

@@ -0,0 +1,29 @@
+package tech.rongxing.devops.mockito;
+
+import java.util.List;
+import org.junit.Test;
+import static org.mockito.Mockito.*;
+
+public class MakingSureInteractionNeverHappenedOnMock05 {
+    @Test
+    public void test() {
+        @SuppressWarnings("unchecked")
+        List<String> mockOne = mock(List.class);
+        @SuppressWarnings({ "unchecked", "unused" })
+        List<String> mockTwo = mock(List.class);
+        @SuppressWarnings("unchecked")
+        List<String> mockThree = mock(List.class);
+
+        //using mocks - only mockOne is interacted
+        mockOne.add("one");
+
+        //ordinary verification
+        verify(mockOne).add("one");
+
+        //verify that method was never called on a mock
+        verify(mockOne, never()).add("two");
+
+        //verify that other mocks were not interacted
+        verifyZeroInteractions(mockOne, mockThree);
+    }
+}

src/test/java/tech/rongxing/devops/mockito/MakingSureInteractionNeverHappenedOnMock05.java

@@ -0,0 +1,30 @@
+package tech.rongxing.devops.mockito;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.LinkedList;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+public class RealPartialMocks10 {
+    @Test
+    public void test(){
+        //you can create partial mock with spy() method:
+
+        @SuppressWarnings("unchecked")
+        LinkedList<String> list1 = mock(LinkedList.class);
+        //Be sure the real implementation is 'safe'.
+        //If real implementation throws exceptions or depends on specific state of the object then you're in trouble.
+
+        when(list1.add("xx")).thenCallRealMethod();
+        when(list1.get(anyInt())).thenCallRealMethod();
+        when(list1.size()).thenCallRealMethod();
+        list1.add("aaa");
+        //assertEquals("aaa", list1.get(0));
+        //assertEquals(1, list1.size());
+    }
+}

src/test/java/tech/rongxing/devops/mockito/RealPartialMocks10.java

@@ -0,0 +1,28 @@
+package tech.rongxing.devops.mockito;
+
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ShorthandForMocksCreation07 {
+    @Mock List<String> mockedList;
+    //@Before
+    public void before(){
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void test(){
+        //using mocks
+        mockedList.add("one");
+        verify(mockedList).add("one");
+    }
+}

src/test/java/tech/rongxing/devops/mockito/ShorthandForMocksCreation07.java

@@ -0,0 +1,45 @@
+package tech.rongxing.devops.mockito;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import org.junit.Test;
+
+public class SpyingOnRealObjects08 {
+    @Test
+    public void test() {
+        List<String> list = new LinkedList<String>();
+        List<String> spy = spy(list);
+
+        // optionally, you can stub out some methods:
+        when(spy.size()).thenReturn(100);
+
+        // using the spy calls *real* methods
+        spy.add("one");
+        spy.add("two");
+
+        // prints "one" - the first element of a list
+        System.out.println(spy.get(0));
+
+        // size() method was stubbed - 100 is printed
+        int spySize =spy.size();
+        System.out.println("Spy size"+spySize);
+        int listSize = list.size();
+        System.out.println("list size"+listSize);
+
+        assertEquals(100,spySize);
+        assertEquals(0,listSize);
+
+        assertEquals(spy.get(0),"one");
+        //assertEquals(list.get(0),"one");
+
+        // optionally, you can verify
+        verify(spy).add("one");
+        verify(spy).add("two");
+    }
+}

src/test/java/tech/rongxing/devops/mockito/SpyingOnRealObjects08.java

@@ -0,0 +1,50 @@
+package tech.rongxing.devops.mockito;
+
+import java.util.List;
+import org.junit.Test;
+
+import static org.mockito.Mockito.*;
+import org.mockito.InOrder;
+
+public class VerificationInOrder04 {
+    @Test
+    public void test() {
+        // A. Single mock whose methods must be invoked in a particular order
+        @SuppressWarnings("unchecked")
+        List<String> singleMock = mock(List.class);
+
+        // using a single mock
+        singleMock.add("was added first");
+        singleMock.add("was added second");
+
+        // create an inOrder verifier for a single mock
+        InOrder inOrder = inOrder(singleMock);
+
+        // following will make sure that add is first called with
+        // "was added first, then with "was added second"
+
+        inOrder.verify(singleMock).add("was added first");
+        inOrder.verify(singleMock).add("was added second");
+
+        // B. Multiple mocks that must be used in a particular order
+        @SuppressWarnings("unchecked")
+        List<String> firstMock = mock(List.class);
+        @SuppressWarnings("unchecked")
+        List<String> secondMock = mock(List.class);
+
+        // using mocks
+        firstMock.add("was called first");
+        secondMock.add("was called second");
+
+        // create inOrder object passing any mocks that need to be verified in
+        // order
+        InOrder inOrder1= inOrder(firstMock, secondMock);
+
+        // following will make sure that firstMock was called before secondMock
+
+        inOrder1.verify(firstMock).add("was called first");
+        inOrder1.verify(secondMock).add("was called second");
+
+        // Oh, and A + B can be mixed together at will
+    }
+}