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