Merge branch 'add-user-domain-test-cases' into 'feature-domain-implement'

add-user-domain-test-cases

See merge request crowd-2019/crowd-test-service-backend!10

core/src/test/java/com/mooctest/crowd/domain/repository/UserRepoTest.java

@@ -1,35 +1,184 @@
-//package com.mooctest.crowd.domain.repository;
-//
-//import com.mooctest.crowd.domain.dao.UserDao;
-//import com.mooctest.crowd.domain.domainobject.User;
-//import org.junit.Before;
-//import org.junit.Test;
-//import org.junit.runner.RunWith;
-//import org.mockito.InjectMocks;
-//import org.mockito.Mock;
-//import org.mockito.MockitoAnnotations;
-//import org.mockito.runners.MockitoJUnitRunner;
-//
-//@RunWith(MockitoJUnitRunner.class)
-//public class UserRepoTest {
-//    @InjectMocks
-//    private UserRepo userRepo = new UserRepo();
-//
-//    @Mock
-//    private UserDao userDao;
-//
-//    private User user =  new User();
-//
-//    @Before
-//    public void before() {
-//        MockitoAnnotations.initMocks(this);
-//    }
-//
-//    @Test
-//    public void test_getByMobileNum() {
-//    }
-//
-//    @Test
-//    public void test_save() {
-//    }
-//}
+package com.mooctest.crowd.domain.repository;
+
+import com.mooctest.crowd.domain.dao.*;
+import com.mooctest.crowd.domain.domainobject.Role;
+import com.mooctest.crowd.domain.domainobject.User;
+import com.mooctest.crowd.domain.exception.UserNotExistException;
+import com.mooctest.crowd.domain.model.*;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UserRepoTest {
+    @InjectMocks
+    private UserRepo userRepo = new UserRepo();
+
+    @Mock
+    private UserDao userDao;
+    @Mock
+    private UserToRoleDao userToRoleDao;
+    @Mock
+    private RoleDao roleDao;
+    @Mock
+    private RoleToPermissionDao roleToPermissionDao;
+    @Mock
+    private PermissionDao permissionDao;
+
+    private UserPO expectUserPO;
+    private RolePO expectRolePO;
+    private PermissionPO expectPermission;
+    private List<UserToRolePO> expectUserToRolePOList;
+    private List<RoleToPermissionPO> expectRoleToPermissionPOList;
+    private UserToRolePO expectUserToRolePO;
+    private RoleToPermissionPO expectRoleToPermissionPO;
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+
+        expectUserPO = new UserPO();
+        expectRolePO = new RolePO();
+        expectUserToRolePO = new UserToRolePO();
+        expectRoleToPermissionPO = new RoleToPermissionPO();
+        expectPermission = new PermissionPO();
+        expectUserToRolePOList = new LinkedList<>();
+        expectRoleToPermissionPOList = new LinkedList<>();
+        expectRoleToPermissionPOList.add(expectRoleToPermissionPO);
+        expectUserToRolePOList.add(expectUserToRolePO);
+    }
+
+    @Test
+    public void should_return_user_optional_when_get_by_id_success() {
+        //arrange
+        when(userDao.findById(anyLong())).thenReturn(Optional.of(expectUserPO));
+        when(userToRoleDao.findByUserId(anyLong())).thenReturn(expectUserToRolePOList);
+        when(roleDao.findById(anyLong())).thenReturn(Optional.of(expectRolePO));
+        when(roleToPermissionDao.findAllByRoleId(anyLong())).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.of(expectPermission));
+        //action
+        User user = userRepo.getByID(0L);
+        //assert
+        Assert.assertNotNull(user);
+    }
+
+    @Test(expected = UserNotExistException.class)
+    public void should_throw_exception_when_get_by_id_get_null() {
+        //arrange
+        when(userDao.findById(anyLong())).thenReturn(Optional.empty());
+        //action
+        userRepo.getByID(0L);
+        //assert
+    }
+
+    @Test
+    public void should_return_user_optional_when_get_by_mobile_number_success() {
+        //arrange
+        when(userDao.findByMobile(anyString())).thenReturn(expectUserPO);
+        when(userToRoleDao.findByUserId(anyLong())).thenReturn(expectUserToRolePOList);
+        when(roleDao.findById(anyLong())).thenReturn(Optional.of(expectRolePO));
+        when(roleToPermissionDao.findAllByRoleId(anyLong())).thenReturn(expectRoleToPermissionPOList);
+        when(permissionDao.findById(anyLong())).thenReturn(Optional.of(expectPermission));
+        //action
+        User user = userRepo.getByMobileNum("123");
+        //assert
+        Assert.assertNotNull(user);
+    }
+
+    @Test(expected = UserNotExistException.class)
+    public void should_throw_exception_when_get_by_mobile_number_get_null() {
+        //arrange
+        when(userDao.findByMobile(anyString())).thenReturn(null);
+        //action
+        userRepo.getByMobileNum("123");
+        //assert
+    }
+
+    @Test
+    public void should_return_user_when_save_user_and_role(){
+        //arrange
+        Role expectRole = new Role();
+        List<Role> roleList = new LinkedList<>();
+        roleList.add(expectRole);
+        User user = new User();
+        user.setRoleList(roleList);
+        when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
+        when(roleDao.findByName(anyString())).thenReturn(expectRolePO);
+        when(userToRoleDao.save(any(UserToRolePO.class))).thenReturn(expectUserToRolePO);
+        //action
+        User resultUser = userRepo.saveUserAndRole(user);
+        //assert
+        Assert.assertNotNull(resultUser);
+    }
+
+    @Test
+    public void should_return_user_when_save_user(){
+        //arrange
+        User user = new User();
+        when(userDao.save(any(UserPO.class))).thenReturn(expectUserPO);
+        //action
+        User resultUser = userRepo.saveUser(user);
+        //assert
+        Assert.assertNotNull(resultUser);
+    }
+    @Test
+    public void should_return_user_list_when_get_by_id_list(){
+        //arrange
+        List<UserPO> expectUserPOList = new LinkedList<>();
+        expectUserPOList.add(new UserPO());
+        expectUserPOList.add(new UserPO());
+        when(userDao.findAllById(anyListOf(Long.class))).thenReturn(expectUserPOList);
+        //action
+        List<User> userList = userRepo.getByIdList(new LinkedList<>());
+        //assert
+        Assert.assertNotNull(userList);
+    }
+
+    @Test
+    public void should_return_user_list_when_get_all_user(){
+        //arrange
+        List<UserPO> expectUserPOList = new LinkedList<>();
+        expectUserPOList.add(new UserPO());
+        expectUserPOList.add(new UserPO());
+        when(userDao.findAll()).thenReturn(expectUserPOList);
+        //action
+        List<User> userList = userRepo.getAllUser();
+        //assert
+        Assert.assertNotNull(userList);
+    }
+
+    @Test
+    public void should_return_void_when_remove_user(){
+        //arrange
+        User user = new User();
+        //action
+        userRepo.removeUser(user);
+        //assert
+        Assert.assertNull(null);
+    }
+
+    @Test
+    public void should_return_void_when_remove_user_list(){
+        //arrange
+        List<User> userList = new LinkedList<>();
+        userList.add(new User());
+        //action
+        userRepo.removeUserList(userList);
+        //assert
+        Assert.assertNull(null);
+    }
+
+
+}