Group testing modules (#3014)

* move security content from spring-security-rest-full * swagger update * move query language to new module * rename spring-security-rest-full to spring-rest-full * group persistence modules * group testing modules * try fix conflict
2017-11-12 11:16:46 +01:00
parent b383d83bf4
commit 776a01429e
236 changed files with 37 additions and 18 deletions
@@ -0,0 +1,29 @@
+package org.baeldung.mocks.testCase;
+
+public class LoginController {
+
+    public LoginService loginService;
+
+    public String login(UserForm userForm) {
+        if (null == userForm) {
+            return "ERROR";
+        } else {
+            boolean logged;
+
+            try {
+                logged = loginService.login(userForm);
+            } catch (Exception e) {
+                return "ERROR";
+            }
+
+            if (logged) {
+                loginService.setCurrentUser(userForm.getUsername());
+                return "OK";
+            } else {
+                return "KO";
+            }
+        }
+    }
+
+    // standard setters and getters
+}
@@ -0,0 +1,9 @@
+package org.baeldung.mocks.testCase;
+
+public class LoginDao {
+
+    public int login(UserForm userForm) {
+        //actual call to a third party library
+        return 0;
+    }
+}
@@ -0,0 +1,33 @@
+package org.baeldung.mocks.testCase;
+
+public class LoginService {
+
+    private LoginDao loginDao;
+
+    private String currentUser;
+
+    public boolean login(UserForm userForm) {
+        assert null != userForm;
+
+        int loginResults = loginDao.login(userForm);
+
+        switch (loginResults) {
+            case 1:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public void setCurrentUser(String username) {
+        if (null != username) {
+            this.currentUser = username;
+        }
+    }
+
+    public void setLoginDao(LoginDao loginDao) {
+        this.loginDao = loginDao;
+    }
+
+    // standard setters and getters
+}
@@ -0,0 +1,15 @@
+package org.baeldung.mocks.testCase;
+
+public class UserForm {
+
+    // public access modifiers as only for testing
+
+    public String password;
+
+    public String username;
+
+    public String getUsername() {
+        return username;
+    }
+
+}
@@ -0,0 +1,143 @@
+package org.baeldung.mocks.easymock;
+
+import org.baeldung.mocks.testCase.LoginController;
+import org.baeldung.mocks.testCase.LoginDao;
+import org.baeldung.mocks.testCase.LoginService;
+import org.baeldung.mocks.testCase.UserForm;
+import org.easymock.*;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(EasyMockRunner.class)
+public class LoginControllerIntegrationTest {
+
+    @Mock
+    private LoginDao loginDao;
+
+    @Mock
+    private LoginService loginService;
+
+    @TestSubject
+    private LoginController loginController = new LoginController();
+
+    @Test
+    public void assertThatNoMethodHasBeenCalled() {
+        EasyMock.replay(loginService);
+        loginController.login(null);
+
+        // no method called
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void assertTwoMethodsHaveBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        EasyMock.expect(loginService.login(userForm)).andReturn(true);
+        loginService.setCurrentUser("foo");
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void assertOnlyOneMethodHasBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        EasyMock.expect(loginService.login(userForm)).andReturn(false);
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("KO", login);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void mockExceptionThrowing() {
+        UserForm userForm = new UserForm();
+        EasyMock.expect(loginService.login(userForm)).andThrow(new IllegalArgumentException());
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("ERROR", login);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void mockAnObjectToPassAround() {
+        UserForm userForm = EasyMock.mock(UserForm.class);
+        EasyMock.expect(userForm.getUsername()).andReturn("foo");
+        EasyMock.expect(loginService.login(userForm)).andReturn(true);
+        loginService.setCurrentUser("foo");
+        EasyMock.replay(userForm);
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        EasyMock.verify(userForm);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void argumentMatching() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // default matcher
+        EasyMock.expect(loginService.login(EasyMock.isA(UserForm.class))).andReturn(true);
+        // complex matcher
+        loginService.setCurrentUser(specificArgumentMatching("foo"));
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        EasyMock.verify(loginService);
+    }
+
+    private static String specificArgumentMatching(final String expected) {
+        EasyMock.reportMatcher(new IArgumentMatcher() {
+            @Override
+            public boolean matches(Object argument) {
+                return argument instanceof String && ((String) argument).startsWith(expected);
+            }
+
+            @Override
+            public void appendTo(StringBuffer buffer) {
+                //NOOP
+            }
+        });
+        return null;
+    }
+
+    @Test
+    public void partialMocking() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // use partial mock
+        LoginService loginServicePartial = EasyMock.partialMockBuilder(LoginService.class).
+                addMockedMethod("setCurrentUser").createMock();
+        loginServicePartial.setCurrentUser("foo");
+        // let service's login use implementation so let's mock DAO call
+        EasyMock.expect(loginDao.login(userForm)).andReturn(1);
+
+        loginServicePartial.setLoginDao(loginDao);
+        loginController.loginService = loginServicePartial;
+
+        EasyMock.replay(loginDao);
+        EasyMock.replay(loginServicePartial);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        // verify mocked call
+        EasyMock.verify(loginServicePartial);
+        EasyMock.verify(loginDao);
+    }
+}
@@ -0,0 +1,159 @@
+package org.baeldung.mocks.jmockit;
+
+import mockit.*;
+import mockit.integration.junit4.JMockit;
+import org.baeldung.mocks.testCase.LoginController;
+import org.baeldung.mocks.testCase.LoginDao;
+import org.baeldung.mocks.testCase.LoginService;
+import org.baeldung.mocks.testCase.UserForm;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(JMockit.class)
+public class LoginControllerIntegrationTest {
+
+    @Injectable
+    private LoginDao loginDao;
+
+    @Injectable
+    private LoginService loginService;
+
+    @Tested
+    private LoginController loginController;
+
+    @Test
+    public void assertThatNoMethodHasBeenCalled() {
+        loginController.login(null);
+        // no method called
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void assertTwoMethodsHaveBeenCalled() {
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        new Expectations() {{
+            loginService.login(userForm);
+            result = true;
+            loginService.setCurrentUser("foo");
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void assertOnlyOneMethodHasBeenCalled() {
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        new Expectations() {{
+            loginService.login(userForm);
+            result = false;
+            // no expectation for setCurrentUser
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("KO", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void mockExceptionThrowing() {
+        final UserForm userForm = new UserForm();
+        new Expectations() {{
+            loginService.login(userForm);
+            result = new IllegalArgumentException();
+            // no expectation for setCurrentUser
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("ERROR", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void mockAnObjectToPassAround(@Mocked final UserForm userForm) {
+        new Expectations() {{
+            userForm.getUsername();
+            result = "foo";
+            loginService.login(userForm);
+            result = true;
+            loginService.setCurrentUser("foo");
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        new FullVerifications(loginService) {
+        };
+        new FullVerifications(userForm) {
+        };
+    }
+
+    @Test
+    public void argumentMatching() {
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // default matcher
+        new Expectations() {{
+            loginService.login((UserForm) any);
+            result = true;
+            // complex matcher
+            loginService.setCurrentUser(withArgThat(new BaseMatcher<String>() {
+                @Override
+                public boolean matches(Object item) {
+                    return item instanceof String && ((String) item).startsWith("foo");
+                }
+
+                @Override
+                public void describeTo(Description description) {
+                    //NOOP
+                }
+            }));
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void partialMocking() {
+        // use partial mock
+        final LoginService partialLoginService = new LoginService();
+        partialLoginService.setLoginDao(loginDao);
+        loginController.loginService = partialLoginService;
+
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // let service's login use implementation so let's mock DAO call
+        new Expectations() {{
+            loginDao.login(userForm);
+            result = 1;
+            // no expectation for loginService.login
+            partialLoginService.setCurrentUser("foo");
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        // verify mocked call
+        new FullVerifications(partialLoginService) {
+        };
+        new FullVerifications(loginDao) {
+        };
+    }
+}
@@ -0,0 +1,149 @@
+package org.baeldung.mocks.mockito;
+
+import org.baeldung.mocks.testCase.LoginController;
+import org.baeldung.mocks.testCase.LoginDao;
+import org.baeldung.mocks.testCase.LoginService;
+import org.baeldung.mocks.testCase.UserForm;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+public class LoginControllerIntegrationTest {
+
+    @Mock
+    private LoginDao loginDao;
+
+    @Spy
+    @InjectMocks
+    private LoginService spiedLoginService;
+
+    @Mock
+    private LoginService loginService;
+
+    @InjectMocks
+    private LoginController loginController;
+
+    @Before
+    public void setUp() {
+        loginController = new LoginController();
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void assertThatNoMethodHasBeenCalled() {
+        loginController.login(null);
+        // no method called
+        Mockito.verifyZeroInteractions(loginService);
+    }
+
+    @Test
+    public void assertTwoMethodsHaveBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        Mockito.when(loginService.login(userForm))
+            .thenReturn(true);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verify(loginService)
+            .setCurrentUser("foo");
+    }
+
+    @Test
+    public void assertOnlyOneMethodHasBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        Mockito.when(loginService.login(userForm))
+            .thenReturn(false);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("KO", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verifyNoMoreInteractions(loginService);
+    }
+
+    @Test
+    public void mockExceptionThrowing() {
+        UserForm userForm = new UserForm();
+        Mockito.when(loginService.login(userForm))
+            .thenThrow(IllegalArgumentException.class);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("ERROR", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verifyZeroInteractions(loginService);
+    }
+
+    @Test
+    public void mockAnObjectToPassAround() {
+        UserForm userForm = Mockito.when(Mockito.mock(UserForm.class)
+            .getUsername())
+            .thenReturn("foo")
+            .getMock();
+        Mockito.when(loginService.login(userForm))
+            .thenReturn(true);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verify(loginService)
+            .setCurrentUser("foo");
+    }
+
+    @Test
+    public void argumentMatching() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // default matcher
+        Mockito.when(loginService.login(Mockito.any(UserForm.class)))
+            .thenReturn(true);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        // complex matcher
+        Mockito.verify(loginService)
+            .setCurrentUser(ArgumentMatchers.argThat(new ArgumentMatcher<String>() {
+                @Override
+                public boolean matches(String argument) {
+                    return argument.startsWith("foo");
+                }
+            }));
+    }
+
+    @Test
+    public void partialMocking() {
+        // use partial mock
+        loginController.loginService = spiedLoginService;
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // let service's login use implementation so let's mock DAO call
+        Mockito.when(loginDao.login(userForm))
+            .thenReturn(1);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        // verify mocked call
+        Mockito.verify(spiedLoginService)
+            .setCurrentUser("foo");
+    }
+}