catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ConsumerBusinessLogicTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 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  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.components.impl;
  23
  24 import org.apache.commons.lang3.RandomStringUtils;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.mockito.InjectMocks;
  28 import org.mockito.Mock;
  29 import org.mockito.Mockito;
  30 import org.mockito.MockitoAnnotations;
  31 import org.openecomp.sdc.be.dao.api.ActionStatus;
  32 import org.openecomp.sdc.be.datatypes.elements.ConsumerDataDefinition;
  33 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  34 import org.openecomp.sdc.be.impl.ComponentsUtils;
  35 import org.openecomp.sdc.be.model.ConsumerDefinition;
  36 import org.openecomp.sdc.be.model.User;
  37 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
  38 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
  39 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
  40 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
  41 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
  42 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
  43 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  44 import org.openecomp.sdc.be.model.operations.impl.ConsumerOperation;
  45 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
  46 import org.openecomp.sdc.be.resources.data.ConsumerData;
  47 import org.openecomp.sdc.be.user.IUserBusinessLogic;
  48 import org.openecomp.sdc.exception.ResponseFormat;
  49 import fj.data.Either;
  50 import java.util.HashMap;
  51 import java.util.Map;
  52
  53 import static org.junit.Assert.assertEquals;
  54 import static org.junit.Assert.assertTrue;
  55 import static org.mockito.ArgumentMatchers.any;
  56 import static org.mockito.ArgumentMatchers.anyString;
  57
  58 public class ConsumerBusinessLogicTest extends BaseBusinessLogicMock {
  59
  60         private User user;
  61         private ConsumerDefinition consumer;
  62         private ConsumerDataDefinition consumerDataDefinition;
  63
  64         @InjectMocks
  65         private ConsumerBusinessLogic consumerBusinessLogic;
  66
  67         @Mock
  68         private ComponentsUtils componentsUtils;
  69
  70         @Mock
  71         private IUserBusinessLogic iUserBusinessLogic;
  72
  73         @Mock
  74         private IGraphLockOperation iGraphLockOperation;
  75
  76         @Mock
  77         private ConsumerOperation consumerOperation;
  78
  79         @Mock
  80         private ConsumerData consumerData;
  81
  82         @Before
  83         public void setUp(){
  84                 consumerBusinessLogic = new ConsumerBusinessLogic(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation,
  85                         interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation);
  86                 consumerDataDefinition = new ConsumerDataDefinition();
  87                 consumer = new ConsumerDefinition();
  88                 MockitoAnnotations.initMocks(this);
  89                 user = new User("Stan", "Lee", "stan.lee",
  90                                 "stan.lee@marvel.com", "ADMIN", 1542024000L);
  91         }
  92
  93         @Test
  94         public void testCreateConsumer_givenMissingUser_thenReturnsError() {
  95                 User user = new User();
  96                 ConsumerDefinition consumerDefinition = new ConsumerDefinition();
  97                 Mockito.when(componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION))
  98                                 .thenReturn(new ResponseFormat());
  99                 assertTrue(consumerBusinessLogic.createConsumer(user, consumerDefinition).isRight());
 100         }
 101
 102         @Test
 103         public void testCreateConsumer_givenNonListedUser_thenReturnsError() {
 104                 ConsumerDefinition consumerDefinition = new ConsumerDefinition();
 105                 Mockito.when(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_ACCESS))
 106                                 .thenReturn(new ResponseFormat());
 107                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 108                                 .thenReturn(Either.right(ActionStatus.RESTRICTED_OPERATION));
 109                 assertTrue(consumerBusinessLogic.createConsumer(user, consumerDefinition).isRight());
 110         }
 111
 112         @Test
 113         public void testCreateConsumer_givenNonAdminUser_thenReturnsError() {
 114                 user.setRole("DESIGNER");
 115                 Mockito.when(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION))
 116                                 .thenReturn(new ResponseFormat());
 117                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 118                                 .thenReturn(Either.left(user));
 119                 assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isRight());
 120         }
 121
 122         @Test
 123         public void testCreateConsumer_givenInvalidConsumerNames_thenReturnsError() {
 124                 Map<String, ActionStatus> invalidConsumerNames = new HashMap<>();
 125                 invalidConsumerNames.put(null, ActionStatus.MISSING_DATA);
 126                 invalidConsumerNames.put(".#()", ActionStatus.INVALID_CONTENT);
 127                 invalidConsumerNames.put(RandomStringUtils.random(256, true, false), ActionStatus.EXCEEDS_LIMIT);
 128                 for(Map.Entry<String, ActionStatus> e: invalidConsumerNames.entrySet()){
 129                         consumer.setConsumerName(e.getKey());
 130                         Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 131                                         .thenReturn(Either.left(user));
 132                         Mockito.when(componentsUtils.getResponseFormat(e.getValue(), "Consumer name"))
 133                                         .thenReturn(new ResponseFormat());
 134                         assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isRight());
 135                 }
 136         }
 137
 138         @Test
 139         public void testCreateConsumer_givenInvalidConsumerPasswords_thenReturnsError() {
 140                 Map<String, ActionStatus> invalidPasswordResults = new HashMap<>();
 141                 invalidPasswordResults.put(null, ActionStatus.MISSING_DATA);
 142                 invalidPasswordResults.put(RandomStringUtils.random(64, '*' ), ActionStatus.INVALID_CONTENT_PARAM);
 143                 invalidPasswordResults.put("password", ActionStatus.INVALID_LENGTH);
 144                 for(Map.Entry<String, ActionStatus> e: invalidPasswordResults.entrySet()){
 145                         consumer.setConsumerName("_marvel");
 146                         consumer.setConsumerPassword(e.getKey());
 147                         Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 148                                         .thenReturn(Either.left(user));
 149                         Mockito.when(componentsUtils.getResponseFormat(e.getValue(), "Consumer password"))
 150                                         .thenReturn(new ResponseFormat());
 151                         assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isRight());
 152                 }
 153         }
 154
 155         @Test
 156         public void testCreateConsumer_givenInvalidConsumerSalts_thenReturnsError() {
 157                 consumer.setConsumerPassword(RandomStringUtils.random(64, true,true));
 158                 Map<String, ActionStatus> invalidPasswordSalts = new HashMap<>();
 159                 invalidPasswordSalts.put(null, ActionStatus.MISSING_DATA);
 160                 invalidPasswordSalts.put(RandomStringUtils.random(32, "*" ), ActionStatus.INVALID_CONTENT_PARAM);
 161                 invalidPasswordSalts.put("password", ActionStatus.INVALID_LENGTH);
 162                 for(Map.Entry<String, ActionStatus> e: invalidPasswordSalts.entrySet()){
 163                         consumer.setConsumerName("_marvel");
 164                         consumer.setConsumerSalt(e.getKey());
 165                         Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 166                                         .thenReturn(Either.left(user));
 167                         Mockito.when(componentsUtils.getResponseFormat(e.getValue(), "Consumer salt"))
 168                                         .thenReturn(new ResponseFormat());
 169                         assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isRight());
 170                 }
 171         }
 172
 173         @Test
 174         public void testCreateConsumer_givenConsumerNotLocked_thenReturnsError() {
 175                 consumer.setConsumerName("_marvel");
 176                 consumer.setConsumerPassword(RandomStringUtils.random(64, true,true));
 177                 consumer.setConsumerSalt(RandomStringUtils.random(32, 'a'));
 178                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 179                                 .thenReturn(Either.left(user));
 180                 Mockito.when(iGraphLockOperation.lockComponent(anyString(), any(NodeTypeEnum.class)))
 181                                 .thenReturn(StorageOperationStatus.GENERAL_ERROR);
 182                 assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isRight());
 183         }
 184
 185         @Test
 186         public void testCreateConsumer_givenUnableToCreateCredentials_thenReturnsError() {
 187                 ConsumerDataDefinition consumerDataDefinition = new ConsumerDataDefinition();
 188                 consumerDataDefinition.setConsumerName("_marvel");
 189                 consumerDataDefinition.setConsumerPassword(RandomStringUtils.random(64, true,true));
 190                 consumerDataDefinition.setConsumerSalt(RandomStringUtils.random(32, 'a'));
 191                 ConsumerDefinition consumer = new ConsumerDefinition(consumerDataDefinition);
 192                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 193                                 .thenReturn(Either.left(user));
 194                 Mockito.when(iGraphLockOperation.lockComponent(anyString(), any(NodeTypeEnum.class)))
 195                                 .thenReturn(StorageOperationStatus.OK);
 196                 Mockito.when(consumerOperation.getCredentials(anyString()))
 197                                 .thenReturn(Either.right(StorageOperationStatus.OK));
 198                 Mockito.when(consumerOperation.createCredentials(any(ConsumerData.class)))
 199                                 .thenReturn(Either.right(StorageOperationStatus.USER_NOT_FOUND));
 200                 assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isRight());
 201         }
 202
 203         @Test
 204         public void testCreateConsumer_givenValidUserAndConsumer_thenReturnsConsumer() {
 205                 ConsumerDataDefinition consumerDataDefinition = new ConsumerDataDefinition();
 206                 consumerDataDefinition.setConsumerName("_marvel");
 207                 consumerDataDefinition.setConsumerPassword(RandomStringUtils.random(64, true,true));
 208                 consumerDataDefinition.setConsumerSalt(RandomStringUtils.random(32, 'a'));
 209                 ConsumerDefinition consumer = new ConsumerDefinition(consumerDataDefinition);
 210                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 211                                 .thenReturn(Either.left(user));
 212                 Mockito.when(iGraphLockOperation.lockComponent(anyString(), any(NodeTypeEnum.class)))
 213                                 .thenReturn(StorageOperationStatus.OK);
 214                 Mockito.when(consumerOperation.getCredentials(anyString()))
 215                                 .thenReturn(Either.right(StorageOperationStatus.OK));
 216                 Mockito.when(consumerOperation.createCredentials(any(ConsumerData.class)))
 217                                 .thenReturn(Either.left(new ConsumerData(consumerDataDefinition)));
 218                 assertTrue(consumerBusinessLogic.createConsumer(user, consumer).isLeft());
 219         }
 220
 221         @Test
 222         public void testGetConsumer_givenNullUser_thenReturnsError() {
 223                 Mockito.when(consumerOperation.getCredentials("marvel123"))
 224                                 .thenReturn(Either.right(StorageOperationStatus.USER_NOT_FOUND));
 225                 assertTrue(consumerBusinessLogic.getConsumer("marvel123", null).isRight());
 226         }
 227
 228         @Test
 229         public void testGetConsumer_givenValidUserAndConsumerId_thenReturnsConsumer() {
 230                 Mockito.when(consumerOperation.getCredentials("marvel123"))
 231                                 .thenReturn(Either.left(new ConsumerData()));
 232                 Mockito.when(consumerData.getConsumerDataDefinition())
 233                                 .thenReturn(consumerDataDefinition);
 234                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 235                                 .thenReturn(Either.left(user));
 236                 assertTrue(consumerBusinessLogic.getConsumer("marvel123", user).isLeft());
 237         }
 238
 239         @Test
 240         public void testUpdateConsumer_givenValidConsumer_thenReturnsUpdatedConsumer() {
 241                 ConsumerDefinition updatedConsumer = new ConsumerDefinition(consumerDataDefinition);
 242                 updatedConsumer.setConsumerName("marvel2");
 243                 ConsumerDataDefinition updatedConsumerDataDef = new ConsumerDataDefinition();
 244                 updatedConsumerDataDef.setConsumerName("marvel2");
 245                 ConsumerData consumerData = new ConsumerData(updatedConsumerDataDef);
 246                 Mockito.when(consumerOperation.updateCredentials(any(ConsumerData.class)))
 247                                 .thenReturn(Either.left(consumerData));
 248                 assertEquals(updatedConsumer.getConsumerName(), consumerBusinessLogic.updateConsumer(consumer).left().value().getConsumerName());
 249         }
 250
 251         @Test
 252         public void testUpdateConsumer_givenUpdateFailure_thenReturnsError() {
 253                 Mockito.when(consumerOperation.updateCredentials(any(ConsumerData.class)))
 254                                 .thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR));
 255                 assertTrue(consumerBusinessLogic.updateConsumer(consumer).isRight());
 256         }
 257
 258         @Test
 259         public void testDeleteConsumer_givenValidUserAndConsumerId_thenReturnsSuccessful() {
 260                 ConsumerData consumerData = new ConsumerData(new ConsumerDataDefinition());
 261                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 262                                 .thenReturn(Either.left(user));
 263                 Mockito.when(consumerOperation.deleteCredentials("marvel123"))
 264                                 .thenReturn(Either.left(consumerData));
 265                 assertTrue(consumerBusinessLogic.deleteConsumer("marvel123", user).isLeft());
 266         }
 267
 268         @Test
 269         public void testDeleteConsumer_givenInvalidUser_thenReturnsError() {
 270                 Mockito.when(iUserBusinessLogic.getUser(user.getUserId(), false))
 271                                 .thenReturn(Either.left(user));
 272                 Mockito.when(consumerOperation.deleteCredentials("marvel123"))
 273                                 .thenReturn(Either.right(StorageOperationStatus.USER_NOT_FOUND));
 274                 assertTrue(consumerBusinessLogic.deleteConsumer("marvel123", user).isRight());
 275         }
 276 }