catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicTest.java

   1 package org.openecomp.sdc.be.user;
   2
   3 import fj.data.Either;
   4 import mockit.Deencapsulation;
   5 import org.apache.tinkerpop.gremlin.structure.Edge;
   6 import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedEdge;
   7 import org.javatuples.Pair;
   8 import org.junit.Before;
   9 import org.junit.Test;
  10 import org.mockito.InjectMocks;
  11 import org.mockito.Mock;
  12 import org.mockito.Mockito;
  13 import org.mockito.MockitoAnnotations;
  14 import org.openecomp.sdc.be.dao.api.ActionStatus;
  15 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  16 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  17 import org.openecomp.sdc.be.impl.ComponentsUtils;
  18 import org.openecomp.sdc.be.model.User;
  19 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  20 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  21 import org.openecomp.sdc.common.api.UserRoleEnum;
  22 import org.openecomp.sdc.exception.ResponseFormat;
  23
  24 import javax.servlet.ServletContext;
  25 import java.util.HashMap;
  26 import java.util.LinkedList;
  27 import java.util.List;
  28
  29 public class UserBusinessLogicTest {
  30
  31         @InjectMocks
  32         UserBusinessLogic testSubject;
  33         @Mock
  34         private IUserAdminOperation userAdminOperation;
  35         @Mock
  36         private ComponentsUtils componentsUtils;
  37         @Mock
  38         private JanusGraphGenericDao janusGraphDao;
  39
  40         @Before
  41         public void setUp() {
  42                 MockitoAnnotations.initMocks(this);
  43         }
  44
  45         @Test
  46         public void testGetUser() throws Exception {
  47                 String userId = "";
  48                 boolean inTransaction = false;
  49                 Either<User, ActionStatus> result;
  50
  51                 // default test
  52                 result = testSubject.getUser(userId, inTransaction);
  53         }
  54
  55         @Test
  56         public void testCreateUser() throws Exception {
  57                 User modifier = new User();
  58                 User newUser = new User();
  59                 Either<User, ResponseFormat> result;
  60
  61                 // default test
  62                 result = testSubject.createUser(modifier, newUser);
  63         }
  64
  65         @Test
  66         public void testCreateUserErrorGetUser() throws Exception {
  67                 User modifier = new User();
  68                 User newUser = new User();
  69                 Either<User, ResponseFormat> result;
  70
  71                 Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
  72                 Mockito.when(userAdminOperation.getUserData(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(value);
  73
  74                 // default test
  75                 modifier.setUserId("mock");
  76                 result = testSubject.createUser(modifier, newUser);
  77         }
  78
  79         @Test
  80         public void testCreateUserErrorUserNotAdmin() throws Exception {
  81                 User modifier = new User();
  82                 User newUser = new User();
  83                 Either<User, ResponseFormat> result;
  84
  85                 User userFromDb = new User();
  86                 userFromDb.setRole(UserRoleEnum.DESIGNER.getName());
  87                 Either<User, ActionStatus> value = Either.left(userFromDb);
  88                 Mockito.when(userAdminOperation.getUserData(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(value);
  89
  90                 // default test
  91                 modifier.setUserId("mock");
  92                 result = testSubject.createUser(modifier, newUser);
  93         }
  94
  95         @Test
  96         public void testCreateErrorCheckingNewUser() throws Exception {
  97                 User modifier = new User();
  98                 User newUser = new User();
  99                 Either<User, ResponseFormat> result;
 100
 101                 User userFromDb = new User();
 102                 userFromDb.setRole(UserRoleEnum.ADMIN.getName());
 103                 Either<User, ActionStatus> value = Either.left(userFromDb);
 104                 Either<User, ActionStatus> value2 = Either.right(ActionStatus.AUTH_REQUIRED);
 105                 Mockito.when(userAdminOperation.getUserData("mockModif", false)).thenReturn(value);
 106                 Mockito.when(userAdminOperation.getUserData("mockNewUs", false)).thenReturn(value2);
 107
 108                 // default test
 109                 modifier.setUserId("mockModif");
 110                 newUser.setUserId("mockNewUs");
 111                 result = testSubject.createUser(modifier, newUser);
 112         }
 113
 114         @Test
 115         public void testCreateErrorCheckingNewUser2() throws Exception {
 116                 User modifier = new User();
 117                 User newUser = new User();
 118                 Either<User, ResponseFormat> result;
 119
 120                 User userFromDb = new User();
 121                 userFromDb.setRole(UserRoleEnum.ADMIN.getName());
 122                 Either<User, ActionStatus> value = Either.left(userFromDb);
 123                 Either<User, ActionStatus> value2 = Either.right(ActionStatus.USER_ALREADY_EXIST);
 124                 Mockito.when(userAdminOperation.getUserData("mockModif", false)).thenReturn(value);
 125                 Mockito.when(userAdminOperation.getUserData("mockNewUs", false)).thenReturn(value2);
 126
 127                 // default test
 128                 modifier.setUserId("mockModif");
 129                 newUser.setUserId("mockNewUs");
 130                 result = testSubject.createUser(modifier, newUser);
 131         }
 132
 133         @Test
 134         public void testCreate2() throws Exception {
 135                 User modifier = new User();
 136                 User newUser = new User();
 137                 Either<User, ResponseFormat> result;
 138
 139                 modifier.setUserId("mockModif");
 140                 newUser.setUserId("mockNewUs");
 141
 142                 User userFromDb = new User();
 143                 userFromDb.setRole(UserRoleEnum.ADMIN.getName());
 144                 Either<User, ActionStatus> value = Either.left(userFromDb);
 145
 146                 User userFromDb2 = new User();
 147                 Either<User, ActionStatus> value2 = Either.left(userFromDb2);
 148                 Mockito.when(userAdminOperation.getUserData("mockModif", false)).thenReturn(value);
 149                 Mockito.when(userAdminOperation.getUserData("mockNewUs", false)).thenReturn(value2);
 150
 151                 // default test
 152                 result = testSubject.createUser(modifier, newUser);
 153         }
 154
 155         @Test
 156         public void testCreateInvalidMail() throws Exception {
 157                 User modifier = new User();
 158                 User newUser = new User();
 159                 Either<User, ResponseFormat> result;
 160
 161                 modifier.setUserId("mockModif");
 162                 newUser.setUserId("mockNewUs");
 163                 newUser.setEmail("mock");
 164
 165                 User userFromDbAdmin = new User();
 166                 userFromDbAdmin.setRole(UserRoleEnum.ADMIN.getName());
 167                 Either<User, ActionStatus> value = Either.left(userFromDbAdmin);
 168
 169                 User userFromDbNew = new User();
 170                 userFromDbNew.setStatus(UserStatusEnum.INACTIVE);
 171                 Either<User, ActionStatus> value2 = Either.left(userFromDbNew);
 172                 Mockito.when(userAdminOperation.getUserData("mockModif", false)).thenReturn(value);
 173                 Mockito.when(userAdminOperation.getUserData("mockNewUs", false)).thenReturn(value2);
 174
 175                 // default test
 176                 result = testSubject.createUser(modifier, newUser);
 177         }
 178
 179         @Test
 180         public void testCreateInvalidRole() throws Exception {
 181                 User modifier = new User();
 182                 User newUser = new User();
 183                 Either<User, ResponseFormat> result;
 184
 185                 modifier.setUserId("mockModif");
 186                 newUser.setUserId("mockNewUs");
 187                 newUser.setEmail("mock@mock.mock");
 188                 newUser.setRole("mock");
 189
 190                 User userFromDbAdmin = new User();
 191                 userFromDbAdmin.setRole(UserRoleEnum.ADMIN.getName());
 192                 Either<User, ActionStatus> value = Either.left(userFromDbAdmin);
 193
 194                 User userFromDbNew = new User();
 195                 userFromDbNew.setStatus(UserStatusEnum.INACTIVE);
 196                 Either<User, ActionStatus> value2 = Either.left(userFromDbNew);
 197                 Mockito.when(userAdminOperation.getUserData("mockModif", false)).thenReturn(value);
 198                 Mockito.when(userAdminOperation.getUserData("mockNewUs", false)).thenReturn(value2);
 199
 200                 // default test
 201                 result = testSubject.createUser(modifier, newUser);
 202         }
 203
 204         @Test
 205         public void testUpdateUserRoleNoId() throws Exception {
 206                 User modifier = new User();
 207                 String userIdToUpdate = "";
 208                 String userRole = "";
 209                 Either<User, ResponseFormat> result;
 210
 211                 // default test
 212                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 213         }
 214
 215         @Test
 216         public void testUpdateUserRoleNotFound() throws Exception {
 217                 User modifier = new User();
 218                 modifier.setUserId("mock");
 219                 String userIdToUpdate = "";
 220                 String userRole = "";
 221                 Either<User, ResponseFormat> result;
 222
 223                 Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
 224                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 225
 226                 // default test
 227                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 228         }
 229
 230         @Test
 231         public void testUpdateUserRoleModifWrongRole() throws Exception {
 232                 User modifier = new User();
 233                 modifier.setUserId("mock");
 234                 modifier.setRole(UserRoleEnum.DESIGNER.getName());
 235                 String userIdToUpdate = "";
 236                 String userRole = "";
 237                 Either<User, ResponseFormat> result;
 238
 239                 Either<User, ActionStatus> value = Either.left(modifier);
 240                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 241
 242                 // default test
 243                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 244         }
 245
 246         @Test
 247         public void testUpdateUserRoleSameId() throws Exception {
 248                 User modifier = new User();
 249                 modifier.setUserId("mock");
 250                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 251                 String userIdToUpdate = "mock";
 252                 String userRole = "";
 253                 Either<User, ResponseFormat> result;
 254
 255                 Either<User, ActionStatus> value = Either.left(modifier);
 256                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 257
 258                 // default test
 259                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 260         }
 261
 262         @Test
 263         public void testUpdateUserRoleUpdatedNotFound() throws Exception {
 264                 User modifier = new User();
 265                 modifier.setUserId("mock");
 266                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 267                 String userIdToUpdate = "mock1";
 268                 String userRole = "";
 269                 Either<User, ResponseFormat> result;
 270
 271                 Either<User, ActionStatus> value = Either.left(modifier);
 272                 Either<User, ActionStatus> value2 = Either.right(ActionStatus.ECOMP_USER_NOT_FOUND);
 273                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 274                 Mockito.when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(value2);
 275
 276                 // default test
 277                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 278         }
 279
 280         @Test
 281         public void testUpdateUserRoleUpdatedToInvalidRole() throws Exception {
 282                 User modifier = new User();
 283                 modifier.setUserId("mock");
 284                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 285                 String userIdToUpdate = "mock1";
 286                 String userRole = "";
 287                 Either<User, ResponseFormat> result;
 288
 289                 Either<User, ActionStatus> value = Either.left(modifier);
 290                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 291                 Mockito.when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(value);
 292
 293                 // default test
 294                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 295         }
 296
 297         @Test
 298         public void testUpdateUserRolePendingTaskFailed() throws Exception {
 299                 User modifier = new User();
 300                 modifier.setUserId("mock");
 301                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 302                 String userIdToUpdate = "mock1";
 303                 String userRole = UserRoleEnum.DESIGNER.getName();
 304                 Either<User, ResponseFormat> result;
 305
 306                 User updatedUser = new User();
 307                 updatedUser.setUserId(userIdToUpdate);
 308                 updatedUser.setRole(UserRoleEnum.TESTER.getName());
 309
 310                 Either<User, ActionStatus> value = Either.left(modifier);
 311                 Either<User, ActionStatus> value2 = Either.left(updatedUser);
 312                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 313                 Mockito.when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(value2);
 314
 315                 Either<List<Edge>, StorageOperationStatus> value3 = Either.right(StorageOperationStatus.INCONSISTENCY);
 316                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 317
 318                 // default test
 319                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 320         }
 321
 322         @Test
 323         public void testUpdateUserRoleListOfTasksNotEmpty() throws Exception {
 324                 User modifier = new User();
 325                 modifier.setUserId("mock");
 326                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 327                 String userIdToUpdate = "mock1";
 328                 String userRole = UserRoleEnum.DESIGNER.getName();
 329                 Either<User, ResponseFormat> result;
 330
 331                 User updatedUser = new User();
 332                 updatedUser.setUserId(userIdToUpdate);
 333                 updatedUser.setRole(UserRoleEnum.TESTER.getName());
 334
 335                 Either<User, ActionStatus> value = Either.left(modifier);
 336                 Either<User, ActionStatus> value2 = Either.left(updatedUser);
 337                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 338                 Mockito.when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(value2);
 339                 List<Edge> list = new LinkedList<>();
 340
 341                 list.add(new DetachedEdge("sdas", "fdfs", new HashMap<>(),"sadas","sadasd",
 342                                 "sadas","sadasd" ));
 343                 Either<List<Edge>, StorageOperationStatus> value3 = Either.left(list);
 344                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 345
 346                 // default test
 347                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 348         }
 349
 350         @Test
 351         public void testUpdateUserRoleFailToUpdate() throws Exception {
 352                 User modifier = new User();
 353                 modifier.setUserId("mock");
 354                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 355                 String userIdToUpdate = "mock1";
 356                 String userRole = UserRoleEnum.DESIGNER.getName();
 357                 Either<User, ResponseFormat> result;
 358
 359                 User updatedUser = new User();
 360                 updatedUser.setUserId(userIdToUpdate);
 361                 updatedUser.setRole(UserRoleEnum.TESTER.getName());
 362
 363                 Either<User, ActionStatus> value = Either.left(modifier);
 364                 Either<User, ActionStatus> value2 = Either.left(updatedUser);
 365                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 366                 Mockito.when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(value2);
 367                 List<Edge> list = new LinkedList<>();
 368
 369                 Either<List<Edge>, StorageOperationStatus> value3 = Either.left(list);
 370                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 371                 Either<User, StorageOperationStatus> value4 = Either.right(StorageOperationStatus.INCONSISTENCY);
 372                 Mockito.when(userAdminOperation.updateUserData(Mockito.any())).thenReturn(value4);
 373                 // default test
 374                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 375         }
 376
 377         @Test
 378         public void testUpdateUserRole() throws Exception {
 379                 User modifier = new User();
 380                 modifier.setUserId("mock");
 381                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 382                 String userIdToUpdate = "mock1";
 383                 String userRole = UserRoleEnum.DESIGNER.getName();
 384                 Either<User, ResponseFormat> result;
 385
 386                 User updatedUser = new User();
 387                 updatedUser.setUserId(userIdToUpdate);
 388                 updatedUser.setRole(UserRoleEnum.TESTER.getName());
 389
 390                 Either<User, ActionStatus> value = Either.left(modifier);
 391                 Either<User, ActionStatus> value2 = Either.left(updatedUser);
 392                 Mockito.when(userAdminOperation.getUserData(modifier.getUserId(), false)).thenReturn(value);
 393                 Mockito.when(userAdminOperation.getUserData(userIdToUpdate, false)).thenReturn(value2);
 394                 List<Edge> list = new LinkedList<>();
 395
 396                 Either<List<Edge>, StorageOperationStatus> value3 = Either.left(list);
 397                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 398                 Either<User, StorageOperationStatus> value4 = Either.left(updatedUser);
 399                 Mockito.when(userAdminOperation.updateUserData(Mockito.any())).thenReturn(value4);
 400                 // default test
 401                 result = testSubject.updateUserRole(modifier, userIdToUpdate, userRole);
 402         }
 403
 404         @Test
 405         public void testGetAllAdminUsers() throws Exception {
 406                 ServletContext context = null;
 407                 Either<List<User>, ResponseFormat> result;
 408
 409                 Either<List<User>, ActionStatus> response = Either.left(new LinkedList<>());
 410                 Mockito.when(userAdminOperation.getAllUsersWithRole(Mockito.anyString(), Mockito.nullable(String.class)))
 411                                 .thenReturn(response);
 412                 // default test
 413                 result = testSubject.getAllAdminUsers();
 414         }
 415
 416         @Test
 417         public void testGetAllAdminUsersFail() throws Exception {
 418                 ServletContext context = null;
 419                 Either<List<User>, ResponseFormat> result;
 420
 421                 Either<List<User>, ActionStatus> response = Either.right(ActionStatus.NOT_ALLOWED);
 422                 Mockito.when(userAdminOperation.getAllUsersWithRole(Mockito.anyString(), Mockito.nullable(String.class)))
 423                                 .thenReturn(response);
 424                 // default test
 425                 result = testSubject.getAllAdminUsers();
 426         }
 427
 428         @Test
 429         public void testGetUsersList1() throws Exception {
 430                 String modifierAttId = "";
 431                 List<String> roles = null;
 432                 String rolesStr = "";
 433                 Either<List<User>, ResponseFormat> result;
 434
 435                 // test 1
 436                 modifierAttId = null;
 437                 result = testSubject.getUsersList(modifierAttId, roles, rolesStr);
 438         }
 439
 440         @Test
 441         public void testGetUsersListFail() throws Exception {
 442                 String modifierAttId = "mockMod";
 443                 List<String> roles = null;
 444                 String rolesStr = "";
 445                 Either<List<User>, ResponseFormat> result;
 446
 447                 Either<User, ActionStatus> value3 = Either.right(ActionStatus.ILLEGAL_COMPONENT_STATE);
 448                 Mockito.when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 449
 450                 result = testSubject.getUsersList(modifierAttId, roles, rolesStr);
 451         }
 452
 453         @Test
 454         public void testGetUsersListFail2() throws Exception {
 455                 String modifierAttId = "mockMod";
 456                 List<String> roles = null;
 457                 String rolesStr = "";
 458                 Either<List<User>, ResponseFormat> result;
 459
 460                 Either<User, ActionStatus> value3 = Either.right(ActionStatus.USER_NOT_FOUND);
 461                 Mockito.when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 462
 463                 result = testSubject.getUsersList(modifierAttId, roles, rolesStr);
 464         }
 465
 466
 467         @Test
 468         public void testGetUsersList() throws Exception {
 469                 String modifierAttId = "mockMod";
 470                 List<String> roles = new LinkedList<>();
 471                 String rolesStr = "";
 472                 Either<List<User>, ResponseFormat> result;
 473
 474                 User a = new User();
 475                 Either<User, ActionStatus> value3 = Either.left(a);
 476                 Mockito.when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 477                 Either<List<User>, ActionStatus> value = Either.left(new LinkedList<>());
 478                 Mockito.when(userAdminOperation.getAllUsersWithRole(Mockito.nullable(String.class), Mockito.anyString()))
 479                                 .thenReturn(value);
 480
 481                 result = testSubject.getUsersList(modifierAttId, roles, rolesStr);
 482         }
 483
 484         @Test
 485         public void testGetUsersListInvalidRole() throws Exception {
 486                 String modifierAttId = "mockMod";
 487                 List<String> roles = new LinkedList<>();
 488                 roles.add("mock");
 489                 String rolesStr = "";
 490                 Either<List<User>, ResponseFormat> result;
 491
 492                 User a = new User();
 493                 Either<User, ActionStatus> value3 = Either.left(a);
 494                 Mockito.when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 495                 Either<List<User>, ActionStatus> value = Either.left(new LinkedList<>());
 496                 Mockito.when(userAdminOperation.getAllUsersWithRole(Mockito.nullable(String.class), Mockito.anyString()))
 497                                 .thenReturn(value);
 498
 499                 result = testSubject.getUsersList(modifierAttId, roles, rolesStr);
 500         }
 501
 502         @Test
 503         public void testGetUsersList2() throws Exception {
 504                 String modifierAttId = "mockMod";
 505                 List<String> roles = new LinkedList<>();
 506                 roles.add(UserRoleEnum.DESIGNER.name());
 507                 String rolesStr = "";
 508                 Either<List<User>, ResponseFormat> result;
 509
 510                 User a = new User();
 511                 Either<User, ActionStatus> value3 = Either.left(a);
 512                 Mockito.when(userAdminOperation.getUserData(modifierAttId, false)).thenReturn(value3);
 513                 Either<List<User>, ActionStatus> value = Either.left(new LinkedList<>());
 514                 Mockito.when(userAdminOperation.getAllUsersWithRole(Mockito.nullable(String.class), Mockito.anyString()))
 515                                 .thenReturn(value);
 516
 517                 result = testSubject.getUsersList(modifierAttId, roles, rolesStr);
 518         }
 519
 520
 521         @Test
 522         public void testDeActivateUserMissingID() throws Exception {
 523                 User modifier = new User();
 524                 modifier.setUserId(null);
 525                 String userUniuqeIdToDeactive = "";
 526                 Either<User, ResponseFormat> result;
 527
 528                 // default test
 529                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 530         }
 531
 532         @Test
 533         public void testDeActivateUserModifierNotFound() throws Exception {
 534                 User modifier = new User();
 535                 modifier.setUserId("mockMod");
 536                 String userUniuqeIdToDeactive = "";
 537                 Either<User, ResponseFormat> result;
 538
 539                 Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
 540                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 541
 542                 // default test
 543                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 544         }
 545
 546         @Test
 547         public void testDeActivateUserModNotAdmin() throws Exception {
 548
 549                 User modifier = new User();
 550                 modifier.setUserId("mockMod");
 551                 modifier.setRole(UserRoleEnum.DESIGNER.getName());
 552                 String userUniuqeIdToDeactive = "";
 553                 Either<User, ResponseFormat> result;
 554
 555                 Either<User, ActionStatus> value = Either.left(modifier);
 556                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 557
 558                 // default test
 559                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 560         }
 561
 562         @Test
 563         public void testDeActivateUserDeacUserNotFound() throws Exception {
 564
 565                 User modifier = new User();
 566                 modifier.setUserId("mockMod");
 567                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 568                 String userUniuqeIdToDeactive = "mockDU";
 569                 Either<User, ResponseFormat> result;
 570
 571                 Either<User, ActionStatus> value = Either.left(modifier);
 572                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 573                 Either<User, ActionStatus> value2 = Either.right(ActionStatus.USER_NOT_FOUND);
 574                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 575
 576                 // default test
 577                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 578         }
 579
 580         @Test
 581         public void testDeActivateUserDeacAndModSame() throws Exception {
 582
 583                 User modifier = new User();
 584                 modifier.setUserId("mockMod");
 585                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 586                 String userUniuqeIdToDeactive = "mockMod";
 587                 Either<User, ResponseFormat> result;
 588
 589                 Either<User, ActionStatus> value = Either.left(modifier);
 590                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 591                 Either<User, ActionStatus> value2 = Either.left(modifier);
 592                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 593
 594                 // default test
 595                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 596         }
 597
 598         @Test
 599         public void testDeActivateUserAlreadyInactive() throws Exception {
 600
 601                 User modifier = new User();
 602                 modifier.setUserId("mockMod");
 603                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 604                 String userUniuqeIdToDeactive = "mockDU";
 605                 User deacUser = new User();
 606                 deacUser.setStatus(UserStatusEnum.INACTIVE);
 607                 Either<User, ResponseFormat> result;
 608
 609                 Either<User, ActionStatus> value = Either.left(modifier);
 610                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 611                 Either<User, ActionStatus> value2 = Either.left(deacUser);
 612                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 613
 614                 // default test
 615                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 616         }
 617
 618         @Test
 619         public void testDeActivateUserFailToGetTasks() throws Exception {
 620
 621                 User modifier = new User();
 622                 modifier.setUserId("mockMod");
 623                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 624                 String userUniuqeIdToDeactive = "mockDU";
 625                 User deacUser = new User();
 626                 deacUser.setStatus(UserStatusEnum.ACTIVE);
 627                 deacUser.setRole(UserRoleEnum.DESIGNER.name());
 628                 Either<User, ResponseFormat> result;
 629
 630                 Either<User, ActionStatus> value = Either.left(modifier);
 631                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 632                 Either<User, ActionStatus> value2 = Either.left(deacUser);
 633                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 634                 Either<List<Edge>, StorageOperationStatus> value3 = Either.right(StorageOperationStatus.INCONSISTENCY);
 635                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 636
 637                 // default test
 638                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 639         }
 640
 641         @Test
 642         public void testDeActivateUserWithPendingTasks() throws Exception {
 643
 644                 User modifier = new User();
 645                 modifier.setUserId("mockMod");
 646                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 647                 String userUniuqeIdToDeactive = "mockDU";
 648                 User deacUser = new User();
 649                 deacUser.setStatus(UserStatusEnum.ACTIVE);
 650                 deacUser.setRole(UserRoleEnum.DESIGNER.name());
 651                 Either<User, ResponseFormat> result;
 652
 653                 Either<User, ActionStatus> value = Either.left(modifier);
 654                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 655                 Either<User, ActionStatus> value2 = Either.left(deacUser);
 656                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 657                 LinkedList<Edge> a = new LinkedList<>();
 658                 a.add(new DetachedEdge(userUniuqeIdToDeactive, userUniuqeIdToDeactive, new HashMap<>(),
 659                                 "dsfds","dsfds", "dsfds", "dsfds"));
 660                 Either<List<Edge>, StorageOperationStatus> value3 = Either.left(a);
 661                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 662
 663                 // default test
 664                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 665         }
 666
 667         @Test
 668         public void testDeActivateUserDeacFail() throws Exception {
 669
 670                 User modifier = new User();
 671                 modifier.setUserId("mockMod");
 672                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 673                 String userUniuqeIdToDeactive = "mockDU";
 674                 User deacUser = new User();
 675                 deacUser.setStatus(UserStatusEnum.ACTIVE);
 676                 deacUser.setRole(UserRoleEnum.DESIGNER.name());
 677                 Either<User, ResponseFormat> result;
 678
 679                 Either<User, ActionStatus> value = Either.left(modifier);
 680                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 681                 Either<User, ActionStatus> value2 = Either.left(deacUser);
 682                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 683                 Either<List<Edge>, StorageOperationStatus> value3 = Either.left(new LinkedList<>());
 684                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 685                 Either<User, StorageOperationStatus> value4 = Either.right(StorageOperationStatus.BAD_REQUEST);
 686                 Mockito.when(userAdminOperation.deActivateUser(deacUser)).thenReturn(value4);
 687                 // default test
 688                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 689         }
 690
 691         @Test
 692         public void testDeActivateUser() throws Exception {
 693
 694                 User modifier = new User();
 695                 modifier.setUserId("mockMod");
 696                 modifier.setRole(UserRoleEnum.ADMIN.getName());
 697                 String userUniuqeIdToDeactive = "mockDU";
 698                 User deacUser = new User();
 699                 deacUser.setStatus(UserStatusEnum.ACTIVE);
 700                 deacUser.setRole(UserRoleEnum.DESIGNER.name());
 701                 Either<User, ResponseFormat> result;
 702
 703                 Either<User, ActionStatus> value = Either.left(modifier);
 704                 Mockito.when(userAdminOperation.getUserData("mockMod", false)).thenReturn(value);
 705                 Either<User, ActionStatus> value2 = Either.left(deacUser);
 706                 Mockito.when(userAdminOperation.getUserData("mockDU", false)).thenReturn(value2);
 707                 Either<List<Edge>, StorageOperationStatus> value3 = Either.left(new LinkedList<>());
 708                 Mockito.when(userAdminOperation.getUserPendingTasksList(Mockito.any(), Mockito.any())).thenReturn(value3);
 709                 Either<User, StorageOperationStatus> value4 = Either.left(deacUser);
 710                 Mockito.when(userAdminOperation.deActivateUser(deacUser)).thenReturn(value4);
 711                 // default test
 712                 result = testSubject.deActivateUser(modifier, userUniuqeIdToDeactive);
 713         }
 714
 715         @Test
 716         public void testAuthorizeMissingId() throws Exception {
 717                 User authUser = new User();
 718                 Either<User, ResponseFormat> result;
 719
 720                 // default test
 721                 result = testSubject.authorize(authUser);
 722         }
 723
 724         @Test
 725         public void testAuthorizeFail1() throws Exception {
 726                 User authUser = new User();
 727                 authUser.setUserId("mockAU");
 728                 Either<User, ResponseFormat> result;
 729
 730                 Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
 731                 Mockito.when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 732                 // default test
 733                 result = testSubject.authorize(authUser);
 734         }
 735
 736         @Test
 737         public void testAuthorizeFail2() throws Exception {
 738                 User authUser = new User();
 739                 authUser.setUserId("mockAU");
 740                 Either<User, ResponseFormat> result;
 741
 742                 Either<User, ActionStatus> value = Either.right(ActionStatus.AAI_ARTIFACT_GENERATION_FAILED);
 743                 Mockito.when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 744                 // default test
 745                 result = testSubject.authorize(authUser);
 746         }
 747
 748         @Test
 749         public void testAuthorizeFail3() throws Exception {
 750                 User authUser = new User();
 751                 authUser.setUserId("mockAU");
 752                 Either<User, ResponseFormat> result;
 753
 754                 Either<User, ActionStatus> value = Either.left(null);
 755                 Mockito.when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 756                 // default test
 757                 result = testSubject.authorize(authUser);
 758         }
 759
 760
 761         @Test
 762         public void testAuthorize5() throws Exception {
 763                 User authUser = new User();
 764                 authUser.setUserId("mockAU");
 765                 Either<User, ResponseFormat> result;
 766
 767                 Either<User, ActionStatus> value = Either.left(authUser);
 768                 Mockito.when(userAdminOperation.getUserData("mockAU", false)).thenReturn(value);
 769                 Either<User, StorageOperationStatus> value2 = Either.left(authUser);
 770                 Mockito.when(userAdminOperation.updateUserData(Mockito.any(User.class))).thenReturn(value2);
 771                 // default test
 772                 result = testSubject.authorize(authUser);
 773         }
 774
 775         @Test
 776         public void testUpdateUserCredentialsMissingId() throws Exception {
 777                 User updatedUserCred = new User();
 778                 updatedUserCred.setUserId(null);
 779                 Either<User, ResponseFormat> result;
 780
 781                 // default test
 782                 result = testSubject.updateUserCredentials(updatedUserCred);
 783         }
 784
 785         @Test
 786         public void testUpdateUserCredentialsFailedToGet() throws Exception {
 787                 User updatedUserCred = new User();
 788                 updatedUserCred.setUserId("mock");
 789                 Either<User, ResponseFormat> result;
 790
 791                 Either<User, ActionStatus> value = Either.right(ActionStatus.USER_NOT_FOUND);
 792                 Mockito.when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 793
 794                 // default test
 795                 result = testSubject.updateUserCredentials(updatedUserCred);
 796         }
 797
 798         @Test
 799         public void testUpdateUserCredentialsFailedToGet2() throws Exception {
 800                 User updatedUserCred = new User();
 801                 updatedUserCred.setUserId("mock");
 802                 Either<User, ResponseFormat> result;
 803
 804                 Either<User, ActionStatus> value = Either.right(ActionStatus.ADDITIONAL_INFORMATION_ALREADY_EXISTS);
 805                 Mockito.when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 806
 807                 // default test
 808                 result = testSubject.updateUserCredentials(updatedUserCred);
 809         }
 810
 811         @Test
 812         public void testUpdateUserCredentialsFailedToGet3() throws Exception {
 813                 User updatedUserCred = new User();
 814                 updatedUserCred.setUserId("mock");
 815                 Either<User, ResponseFormat> result;
 816
 817                 Either<User, ActionStatus> value = Either.left(null);
 818                 Mockito.when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 819
 820                 // default test
 821                 result = testSubject.updateUserCredentials(updatedUserCred);
 822         }
 823
 824         @Test
 825         public void testUpdateUserCredentials() throws Exception {
 826                 User updatedUserCred = new User();
 827                 updatedUserCred.setUserId("mock");
 828                 Either<User, ResponseFormat> result;
 829
 830                 Either<User, ActionStatus> value = Either.left(updatedUserCred);
 831                 Mockito.when(userAdminOperation.getUserData("mock", false)).thenReturn(value);
 832
 833                 Either<User, StorageOperationStatus> value2 = Either.left(updatedUserCred);
 834                 Mockito.when(userAdminOperation.updateUserData(Mockito.any(User.class))).thenReturn(value2);
 835
 836                 // default test
 837                 result = testSubject.updateUserCredentials(updatedUserCred);
 838         }
 839
 840         @Test
 841         public void testGetPendingUserPendingTasksWithCommit() throws Exception {
 842                 Either<List<Edge>, StorageOperationStatus> result;
 843                 User user = new User();
 844                 for (UserRoleEnum iterable_element : UserRoleEnum.values()) {
 845                         user.setRole(iterable_element.name());
 846                         result = Deencapsulation.invoke(testSubject, "getPendingUserPendingTasksWithCommit", user);
 847                 }
 848
 849         }
 850
 851         @Test
 852         public void testGetUserPendingTaskStatusByRole() throws Exception {
 853                 String result;
 854                 for (UserRoleEnum iterable_element : UserRoleEnum.values()) {
 855                         result = Deencapsulation.invoke(testSubject, "getUserPendingTaskStatusByRole", iterable_element);
 856                 }
 857         }
 858 }