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

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