New unit test format

testing-modules/mockito-2/.gitignore

@@ -0,0 +1,14 @@
+*.class
+
+.settings
+.project
+
+#folders#
+/target
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

testing-modules/mockito-2/README.md

@@ -0,0 +1,5 @@
+### Relevant articles
+
+- [Mockito’s Java 8 Features](http://www.baeldung.com/mockito-2-java-8)
+- [Lazy Verification with Mockito 2](http://www.baeldung.com/mockito-2-lazy-verification)
+- [Mockito Strict Stubbing and The UnnecessaryStubbingException](https://www.baeldung.com/mockito-unnecessary-stubbing-exception)

testing-modules/mockito-2/pom.xml

@@ -0,0 +1,20 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>mockito-2</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>mockito-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../</relativePath>
+    </parent>
+
+    <properties>
+        <mockito.version>2.21.0</mockito.version>
+    </properties>
+</project>

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/JobPosition.java

@@ -0,0 +1,20 @@
+package com.baeldung.mockito.java8;
+
+public class JobPosition {
+    private String title;
+    
+    public JobPosition() {}
+    
+    public JobPosition(String title) {
+        super();
+        this.title = title;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/JobService.java

@@ -0,0 +1,20 @@
+package com.baeldung.mockito.java8;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public interface JobService {
+    Optional<JobPosition> findCurrentJobPosition(Person person);
+
+    default boolean assignJobPosition(Person person, JobPosition jobPosition) {
+        if (!findCurrentJobPosition(person).isPresent()) {
+            person.setCurrentJobPosition(jobPosition);
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    Stream<JobPosition> listJobs(Person person);
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/Person.java

@@ -0,0 +1,28 @@
+package com.baeldung.mockito.java8;
+
+public class Person {
+    private String name;
+    private JobPosition currentJobPosition;
+    
+    public Person() {}
+    
+    public Person(String name) {
+        this.name = name;
+    }
+
+    public JobPosition getCurrentJobPosition() {
+        return currentJobPosition;
+    }
+
+    public void setCurrentJobPosition(JobPosition currentJobPosition) {
+        this.currentJobPosition = currentJobPosition;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/UnemploymentService.java

@@ -0,0 +1,11 @@
+package com.baeldung.mockito.java8;
+
+import java.util.Optional;
+
+public interface UnemploymentService {
+
+    boolean personIsEntitledToUnemploymentSupport(Person person);
+
+    Optional<JobPosition> searchJob(Person person, String searchString); 
+
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/UnemploymentServiceImpl.java

@@ -0,0 +1,26 @@
+package com.baeldung.mockito.java8;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class UnemploymentServiceImpl implements UnemploymentService {
+    private final JobService jobService;
+    
+    public UnemploymentServiceImpl(JobService jobService) {
+        this.jobService = jobService;
+    }
+
+    @Override
+    public boolean personIsEntitledToUnemploymentSupport(Person person) {
+        Optional<JobPosition> optional = jobService.findCurrentJobPosition(person);
+        
+        return !optional.isPresent();
+    }
+
+    @Override
+    public Optional<JobPosition> searchJob(Person person, String searchString) {
+        Stream<JobPosition> stream = jobService.listJobs(person);
+        
+        return stream.filter((j) -> j.getTitle().contains(searchString)).findFirst();
+    }
+}

testing-modules/mockito-2/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/ArgumentMatcherWithLambdaUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+
+public class ArgumentMatcherWithLambdaUnitTest {
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+    
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJob_thenIsNotEntitled() {
+        Person peter = new Person("Peter");
+        Person linda = new Person("Linda");
+        
+        JobPosition teacher = new JobPosition("Teacher");
+
+        when(jobService.findCurrentJobPosition(
+                ArgumentMatchers.argThat((p) -> p.getName().equals("Peter")))
+             ).thenReturn(Optional.of(teacher));
+        
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(linda));
+        assertFalse(unemploymentService.personIsEntitledToUnemploymentSupport(peter));
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/ArgumentMatcherWithoutLambdaUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.mockito.java8;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.*;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+
+public class ArgumentMatcherWithoutLambdaUnitTest {
+
+    private class PeterArgumentMatcher implements ArgumentMatcher<Person> {
+
+        @Override
+        public boolean matches(Person p) {
+            return p
+              .getName()
+              .equals("Peter");
+        }
+    }
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+    
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJob_thenIsNotEntitled() {
+        Person peter = new Person("Peter");
+        Person linda = new Person("Linda");
+        
+        JobPosition teacher = new JobPosition("Teacher");
+
+        when(jobService.findCurrentJobPosition(
+                ArgumentMatchers.argThat(new PeterArgumentMatcher()))
+             ).thenReturn(Optional.of(teacher));
+        
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(linda));
+        assertFalse(unemploymentService.personIsEntitledToUnemploymentSupport(peter));
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/CustomAnswerWithLambdaUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.mockito.java8;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+public class CustomAnswerWithLambdaUnitTest {
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJobHistory_thenSearchReturnsValue() {
+        Person peter = new Person("Peter");
+
+        assertEquals("Teacher", unemploymentService.searchJob(peter, "").get().getTitle());
+    }
+
+    @Test
+    public void whenPersonWithNoJobHistory_thenSearchReturnsEmpty() {
+        Person linda = new Person("Linda");
+
+        assertFalse(unemploymentService.searchJob(linda, "").isPresent());
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+
+        when(jobService.listJobs(any(Person.class))).then((i) ->
+          Stream.of(new JobPosition("Teacher"))
+          .filter(p -> ((Person) i.getArgument(0)).getName().equals("Peter")));
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/CustomAnswerWithoutLambdaUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.mockito.java8;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+
+public class CustomAnswerWithoutLambdaUnitTest {
+    
+    private class PersonAnswer implements Answer<Stream<JobPosition>> {
+
+        @Override
+        public Stream<JobPosition> answer(InvocationOnMock invocation) throws Throwable {
+            Person person = invocation.getArgument(0);
+            
+            if(person.getName().equals("Peter")) {
+                return Stream.<JobPosition>builder().add(new JobPosition("Teacher")).build();
+            } 
+            
+            return Stream.empty();
+        }
+    }
+    
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+    
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJobHistory_thenSearchReturnsValue() {
+        Person peter = new Person("Peter");
+        
+        assertEquals("Teacher", unemploymentService.searchJob(peter, "").get().getTitle());
+    }
+
+    @Test
+    public void whenPersonWithNoJobHistory_thenSearchReturnsEmpty() {
+        Person linda = new Person("Linda");
+
+        assertFalse(unemploymentService.searchJob(linda, "").isPresent());
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+        
+        when(jobService.listJobs(any(Person.class))).then(new PersonAnswer());
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/JobServiceUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+public class JobServiceUnitTest {
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void givenDefaultMethod_whenCallRealMethod_thenNoExceptionIsRaised() {
+        Person person = new Person();
+
+        when(jobService.findCurrentJobPosition(person)).thenReturn(Optional.of(new JobPosition()));
+        doCallRealMethod().when(jobService).assignJobPosition(Mockito.any(Person.class), Mockito.any(JobPosition.class));
+
+        assertFalse(jobService.assignJobPosition(person, new JobPosition()));
+    }
+
+    @Test
+    public void givenReturnIsOfTypeOptional_whenDefaultValueIsReturned_thenValueIsEmpty() {
+        Person person = new Person();
+
+        when(jobService.findCurrentJobPosition(person)).thenReturn(Optional.empty());
+        doCallRealMethod().when(jobService).assignJobPosition(Mockito.any(Person.class), Mockito.any(JobPosition.class));
+
+        assertTrue(jobService.assignJobPosition(person, new JobPosition()));
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/LazyVerificationUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.VerificationCollector;
+
+public class LazyVerificationUnitTest {
+
+    @Test
+    public void whenLazilyVerified_thenReportsMultipleFailures() {
+        VerificationCollector collector = MockitoJUnit.collector()
+            .assertLazily();
+
+        List mockList = mock(List.class);
+        verify(mockList).add("one");
+        verify(mockList).clear();
+
+        try {
+            collector.collectAndReport();
+        } catch (MockitoAssertionError error) {
+            assertTrue(error.getMessage()
+                .contains("1. Wanted but not invoked:"));
+            assertTrue(error.getMessage()
+                .contains("2. Wanted but not invoked:"));
+        }
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/UnemploymentServiceImplUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class UnemploymentServiceImplUnitTest {
+    @Mock
+    private JobService jobService;
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+
+    @Test
+    public void givenReturnIsOfTypeOptional_whenMocked_thenValueIsEmpty() {
+        Person person = new Person();
+
+        when(jobService.findCurrentJobPosition(any(Person.class))).thenReturn(Optional.empty());
+
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(person));
+    }
+
+    @Test
+    public void givenReturnIsOfTypeOptional_whenDefaultValueIsReturned_thenValueIsEmpty() {
+        Person person = new Person();
+
+        // This will fail when Mockito 1 is used
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(person));
+    }
+
+    @Test
+    public void givenReturnIsOfTypeStream_whenMocked_thenValueIsEmpty() {
+        Person person = new Person();
+
+        when(jobService.listJobs(any(Person.class))).thenReturn(Stream.empty());
+
+        assertFalse(unemploymentService.searchJob(person, "").isPresent());
+    }
+
+    @Test
+    public void givenReturnIsOfTypeStream_whenDefaultValueIsReturned_thenValueIsEmpty() {
+        Person person = new Person();
+
+        // This will fail when Mockito 1 is used
+        assertFalse(unemploymentService.searchJob(person, "").isPresent());
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/misusing/ExpectedTestFailureRule.java

@@ -0,0 +1,51 @@
+package com.baeldung.mockito.misusing;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class ExpectedTestFailureRule implements MethodRule {
+
+    private final MethodRule testedRule;
+    private FailureAssert failureAssert = null;
+
+    public ExpectedTestFailureRule(MethodRule testedRule) {
+        this.testedRule = testedRule;
+    }
+
+    @Override
+    public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
+        return new Statement() {
+            public void evaluate() throws Throwable {
+                try {
+                    testedRule.apply(base, method, target)
+                        .evaluate();
+                } catch (Throwable t) {
+                    if (failureAssert == null) {
+                        throw t;
+                    }
+                    failureAssert.doAssert(t);
+                    return;
+                }
+            }
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    public void expectedFailure(final Class<? extends Throwable> expected) {
+        FailureAssert assertion = t -> Assert.assertThat(t, Matchers.isA((Class<Throwable>) expected));
+        this.expectedFailure(assertion);
+    }
+
+    private void expectedFailure(FailureAssert failureAssert) {
+        this.failureAssert = failureAssert;
+    }
+
+    @FunctionalInterface
+    private interface FailureAssert {
+        abstract void doAssert(Throwable t);
+    }
+
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/misusing/MockitoUnecessaryStubUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.mockito.misusing;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
+
+public class MockitoUnecessaryStubUnitTest {
+
+    @Rule
+    public ExpectedTestFailureRule rule = new ExpectedTestFailureRule(MockitoJUnit.rule()
+        .strictness(Strictness.STRICT_STUBS));
+
+    @Mock
+    private ArrayList<String> mockList;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException() {
+        rule.expectedFailure(UnnecessaryStubbingException.class);
+
+        when(mockList.add("one")).thenReturn(true);
+        when(mockList.get(anyInt())).thenReturn("hello");
+
+        assertEquals("List should contain hello", "hello", mockList.get(1));
+    }
+
+    @Test
+    public void givenLenientdStub_whenInvokingGetThenDontThrowUnnecessaryStubbingException() {
+        lenient().when(mockList.add("one"))
+            .thenReturn(true);
+        when(mockList.get(anyInt())).thenReturn("hello");
+
+        assertEquals("List should contain hello", "hello", mockList.get(1));
+    }
+
+}