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

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