gerrit.onap Code Review - sdc.git/blob

   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  */
  20
  21 package org.openecomp.sdc.be.components.impl;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertNotNull;
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertTrue;
  27
  28 import java.util.ArrayList;
  29 import java.util.EnumMap;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.mockito.InjectMocks;
  37 import org.mockito.Mockito;
  38 import org.mockito.MockitoAnnotations;
  39 import org.openecomp.sdc.be.config.ConfigurationManager;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  42 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  43 import org.openecomp.sdc.be.impl.ComponentsUtils;
  44 import org.openecomp.sdc.be.model.ArtifactDefinition;
  45 import org.openecomp.sdc.be.model.Component;
  46 import org.openecomp.sdc.be.model.ComponentInstance;
  47 import org.openecomp.sdc.be.model.HeatParameterDefinition;
  48 import org.openecomp.sdc.be.model.Service;
  49 import org.openecomp.sdc.be.model.User;
  50 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  51 import org.openecomp.sdc.be.model.operations.impl.ServiceOperation;
  52 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
  53 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  54 import org.openecomp.sdc.be.user.UserBusinessLogic;
  55 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  56 import org.openecomp.sdc.common.api.ConfigurationSource;
  57 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  58 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  59 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  60 import org.openecomp.sdc.exception.ResponseFormat;
  61
  62 import fj.data.Either;
  63
  64 public class ResourceInstanceBusinessLogicTest {
  65
  66         private static final String RESOURCE_ID_WITH_HEAT_PARAMS = "MyResourceId";
  67         private static final String RESOURCE_ID_NO_PAYLOAD = "NoHeatPayload";
  68         private static final String RESOURCE_ID_NO_HEAT_PARAMS = "NoHeatParams";
  69         private static final String RESOURCE_INSTANCE_ID = "MyResourceInstanceId";
  70         private static final String SERVICE_ID = "MyServiceId";
  71         private static final String HEAT_LABEL = "myHeat";
  72         private static final String HEAT_ENV_LABEL = HEAT_LABEL + "Env";
  73         private static final String USER_ID = "jh0003";
  74         private static final long ARTIFACT_CREATION_TIME = System.currentTimeMillis();
  75
  76         static User adminUser = new User("John", "Doh", USER_ID, "", "ADMIN", null);
  77
  78         @InjectMocks
  79         static ServiceComponentInstanceBusinessLogic bl = new ServiceComponentInstanceBusinessLogic();
  80
  81         public static final ArtifactsBusinessLogic artifactBusinessLogic = Mockito.mock(ArtifactsBusinessLogic.class);
  82         public static final UserBusinessLogic userAdminManager = Mockito.mock(UserBusinessLogic.class);
  83         public static final ServiceOperation serviceOperation = Mockito.mock(ServiceOperation.class);
  84         public static final ComponentsUtils componentsUtils = Mockito.mock(ComponentsUtils.class);
  85
  86         static ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
  87         static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  88
  89         // @BeforeClass
  90         public static void setup() {
  91
  92                 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager().getConfiguration().getDeploymentResourceInstanceArtifacts();
  93                 Map<String, Object> placeHolderData = (Map<String, Object>) deploymentResourceArtifacts.get(ComponentInstanceBusinessLogic.HEAT_ENV_NAME);
  94
  95                 ArtifactDefinition heatArtifact = getHeatArtifactDefinition(USER_ID, RESOURCE_ID_WITH_HEAT_PARAMS, HEAT_LABEL, ARTIFACT_CREATION_TIME, false, true);
  96                 Map<String, ArtifactDefinition> artifacts = new HashMap<String, ArtifactDefinition>();
  97                 artifacts.put(HEAT_LABEL.toLowerCase(), heatArtifact);
  98                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> eitherGetResourceArtifact = Either.left(artifacts);
  99                 Mockito.when(artifactBusinessLogic.getArtifacts(RESOURCE_ID_WITH_HEAT_PARAMS, NodeTypeEnum.Resource, true, ArtifactGroupTypeEnum.DEPLOYMENT)).thenReturn(eitherGetResourceArtifact);
 100
 101                 ArtifactDefinition heatArtifactNoPayload = getHeatArtifactDefinition(USER_ID, RESOURCE_ID_NO_PAYLOAD, HEAT_LABEL, ARTIFACT_CREATION_TIME, true, false);
 102                 Map<String, ArtifactDefinition> artifactsNoPayload = new HashMap<String, ArtifactDefinition>();
 103                 artifactsNoPayload.put(HEAT_LABEL.toLowerCase(), heatArtifactNoPayload);
 104                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> eitherGetResourceArtifactNoPayload = Either.left(artifactsNoPayload);
 105                 Mockito.when(artifactBusinessLogic.getArtifacts(RESOURCE_ID_NO_PAYLOAD, NodeTypeEnum.Resource, true, ArtifactGroupTypeEnum.DEPLOYMENT)).thenReturn(eitherGetResourceArtifactNoPayload);
 106
 107                 ArtifactDefinition heatArtifactNoParams = getHeatArtifactDefinition(USER_ID, RESOURCE_ID_NO_HEAT_PARAMS, HEAT_LABEL, ARTIFACT_CREATION_TIME, false, false);
 108                 Map<String, ArtifactDefinition> artifactsNoParams = new HashMap<String, ArtifactDefinition>();
 109                 artifactsNoParams.put(HEAT_LABEL.toLowerCase(), heatArtifactNoParams);
 110                 Either<Map<String, ArtifactDefinition>, StorageOperationStatus> eitherGetResourceArtifactNoParams = Either.left(artifactsNoParams);
 111                 Mockito.when(artifactBusinessLogic.getArtifacts(RESOURCE_ID_NO_HEAT_PARAMS, NodeTypeEnum.Resource, true, ArtifactGroupTypeEnum.DEPLOYMENT)).thenReturn(eitherGetResourceArtifactNoParams);
 112
 113                 Either<ArtifactDefinition, ResponseFormat> eitherPlaceHolder = Either.left(getArtifactPlaceHolder(RESOURCE_INSTANCE_ID, HEAT_ENV_LABEL));
 114                 Mockito.when(artifactBusinessLogic.createArtifactPlaceHolderInfo(RESOURCE_INSTANCE_ID, HEAT_ENV_LABEL.toLowerCase(), placeHolderData, USER_ID, ArtifactGroupTypeEnum.DEPLOYMENT, false)).thenReturn(eitherPlaceHolder);
 115
 116                 Mockito.when(artifactBusinessLogic.createArtifactAuditingFields(Mockito.any(ArtifactDefinition.class), Mockito.anyString(), Mockito.anyString())).thenReturn(new EnumMap<AuditingFieldsKeysEnum, Object>(AuditingFieldsKeysEnum.class));
 117
 118                 Either<ArtifactDefinition, StorageOperationStatus> eitherArtifact = Either.left(getHeatArtifactDefinition(USER_ID, RESOURCE_INSTANCE_ID, HEAT_ENV_LABEL, ARTIFACT_CREATION_TIME, true, false));
 119                 Mockito.when(artifactBusinessLogic.addHeatEnvArtifact(Mockito.any(ArtifactDefinition.class), Mockito.any(ArtifactDefinition.class), Mockito.anyString(), Mockito.any(NodeTypeEnum.class), Mockito.anyBoolean())).thenReturn(eitherArtifact);
 120
 121                 Either<User, ActionStatus> eitherUser = Either.left(adminUser);
 122                 Mockito.when(userAdminManager.getUser(USER_ID, false)).thenReturn(eitherUser);
 123
 124                 Object lightService = new Service();
 125                 Either<Object, StorageOperationStatus> eitherLightService = Either.left(lightService);
 126                 Mockito.when(serviceOperation.getLightComponent(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherLightService);
 127
 128                 Mockito.doNothing().when(componentsUtils).auditComponent(Mockito.any(ResponseFormat.class), Mockito.any(User.class), Mockito.any(Component.class), Mockito.anyString(), Mockito.anyString(), Mockito.any(AuditingActionEnum.class),
 129                                 Mockito.any(ComponentTypeEnum.class), Mockito.any(EnumMap.class));
 130
 131         }
 132
 133         @Before
 134         public void initMocks() {
 135                 MockitoAnnotations.initMocks(this);
 136                 Mockito.reset(artifactBusinessLogic, serviceOperation, componentsUtils, userAdminManager);
 137                 setup();
 138         }
 139
 140         @Test
 141         public void testAddResourceInstanceArtifacts() throws Exception {
 142                 ComponentInstance resourceInstance = new ComponentInstance();
 143                 resourceInstance.setName(RESOURCE_INSTANCE_ID);
 144                 resourceInstance.setComponentUid(RESOURCE_ID_WITH_HEAT_PARAMS);
 145                 resourceInstance.setUniqueId(RESOURCE_INSTANCE_ID);
 146                 Service service = new Service();
 147                 service.setUniqueId(SERVICE_ID);
 148
 149                 Either<ActionStatus, ResponseFormat> addArtifactsRes = bl.addComponentInstanceArtifacts(service, resourceInstance, USER_ID, false, null);
 150                 assertTrue(addArtifactsRes.isLeft());
 151
 152                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceInstance.getDeploymentArtifacts();
 153                 assertNotNull(deploymentArtifacts);
 154                 assertTrue(deploymentArtifacts.size() == 2);
 155
 156                 ArtifactDefinition heatDefinition = deploymentArtifacts.get(HEAT_LABEL.toLowerCase());
 157                 assertNotNull(heatDefinition);
 158                 assertEquals(getHeatArtifactDefinition(USER_ID, RESOURCE_ID_WITH_HEAT_PARAMS, HEAT_LABEL, ARTIFACT_CREATION_TIME, false, true), heatDefinition);
 159
 160                 ArtifactDefinition heatEnvDefinition = deploymentArtifacts.get(HEAT_ENV_LABEL.toLowerCase());
 161                 assertNotNull(heatEnvDefinition);
 162
 163                 List<HeatParameterDefinition> heatParameters = heatDefinition.getHeatParameters();
 164                 assertNotNull(heatParameters);
 165
 166                 List<HeatParameterDefinition> heatEnvParameters = heatEnvDefinition.getHeatParameters();
 167                 assertNotNull(heatEnvParameters);
 168
 169                 assertEquals(heatParameters.size(), heatEnvParameters.size());
 170
 171                 int index = 0;
 172                 for (HeatParameterDefinition heatEnvParameter : heatEnvParameters) {
 173                         HeatParameterDefinition heatParameterDefinition = heatParameters.get(index);
 174                         assertEquals(heatEnvParameter.getUniqueId(), heatParameterDefinition.getUniqueId());
 175                         assertEquals(heatEnvParameter.getType(), heatParameterDefinition.getType());
 176                         assertEquals(heatEnvParameter.getName(), heatParameterDefinition.getName());
 177                         assertEquals(heatEnvParameter.getDescription(), heatParameterDefinition.getDescription());
 178                         assertEquals(heatEnvParameter.getCurrentValue(), heatParameterDefinition.getCurrentValue());
 179                         // current of heat parameter should be the default for heat env
 180                         // parameter
 181                         assertEquals(heatEnvParameter.getDefaultValue(), heatParameterDefinition.getCurrentValue());
 182
 183                         index++;
 184                 }
 185         }
 186
 187         @Test
 188         public void testAddResourceInstanceArtifactsNoParams() throws Exception {
 189                 ComponentInstance resourceInstance = new ComponentInstance();
 190                 resourceInstance.setName(RESOURCE_INSTANCE_ID);
 191                 resourceInstance.setComponentUid(RESOURCE_ID_NO_HEAT_PARAMS);
 192                 resourceInstance.setUniqueId(RESOURCE_INSTANCE_ID);
 193                 Service service = new Service();
 194                 service.setUniqueId(SERVICE_ID);
 195
 196                 Either<ActionStatus, ResponseFormat> addArtifactsRes = bl.addComponentInstanceArtifacts(service, resourceInstance, USER_ID, false, null);
 197                 assertTrue(addArtifactsRes.isLeft());
 198
 199                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceInstance.getDeploymentArtifacts();
 200                 assertNotNull(deploymentArtifacts);
 201                 assertTrue(deploymentArtifacts.size() == 2);
 202
 203                 ArtifactDefinition heatDefinition = deploymentArtifacts.get(HEAT_LABEL.toLowerCase());
 204                 assertNotNull(heatDefinition);
 205                 assertEquals(getHeatArtifactDefinition(USER_ID, RESOURCE_ID_NO_HEAT_PARAMS, HEAT_LABEL, ARTIFACT_CREATION_TIME, false, false), heatDefinition);
 206
 207                 ArtifactDefinition heatEnvDefinition = deploymentArtifacts.get(HEAT_ENV_LABEL.toLowerCase());
 208                 assertNotNull(heatEnvDefinition);
 209
 210                 List<HeatParameterDefinition> heatParameters = heatDefinition.getHeatParameters();
 211                 assertNull(heatParameters);
 212
 213                 List<HeatParameterDefinition> heatEnvParameters = heatEnvDefinition.getHeatParameters();
 214                 assertNull(heatEnvParameters);
 215
 216         }
 217
 218         @Test
 219         public void testAddResourceInstanceArtifactsNoArtifacts() throws Exception {
 220                 ComponentInstance resourceInstance = new ComponentInstance();
 221                 resourceInstance.setName(RESOURCE_INSTANCE_ID);
 222                 resourceInstance.setComponentUid(RESOURCE_ID_NO_PAYLOAD);
 223                 resourceInstance.setUniqueId(RESOURCE_INSTANCE_ID);
 224                 Service service = new Service();
 225                 service.setUniqueId(SERVICE_ID);
 226
 227                 Either<ActionStatus, ResponseFormat> addArtifactsRes = bl.addComponentInstanceArtifacts(service, resourceInstance, USER_ID, false, null);
 228                 assertTrue(addArtifactsRes.isLeft());
 229
 230                 Map<String, ArtifactDefinition> deploymentArtifacts = resourceInstance.getDeploymentArtifacts();
 231                 assertNotNull(deploymentArtifacts);
 232                 assertTrue(deploymentArtifacts.size() == 0);
 233
 234                 Mockito.verify(artifactBusinessLogic, Mockito.times(0)).addHeatEnvArtifact(Mockito.any(ArtifactDefinition.class), Mockito.any(ArtifactDefinition.class), Mockito.anyString(), Mockito.any(NodeTypeEnum.class), Mockito.anyBoolean());
 235         }
 236
 237         private static ArtifactDefinition getHeatArtifactDefinition(String userId, String resourceId, String artifactName, long time, boolean placeholderOnly, boolean withHeatParams) {
 238                 ArtifactDefinition artifactInfo = new ArtifactDefinition();
 239
 240                 artifactInfo.setArtifactName(artifactName + ".yml");
 241                 artifactInfo.setArtifactType("HEAT");
 242                 artifactInfo.setDescription("hdkfhskdfgh");
 243                 artifactInfo.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 244
 245                 artifactInfo.setUserIdCreator(userId);
 246                 String fullName = "Jim H";
 247                 artifactInfo.setUpdaterFullName(fullName);
 248                 // long time = System.currentTimeMillis();
 249                 artifactInfo.setCreatorFullName(fullName);
 250                 artifactInfo.setCreationDate(time);
 251                 artifactInfo.setLastUpdateDate(time);
 252                 artifactInfo.setUserIdLastUpdater(userId);
 253                 artifactInfo.setArtifactLabel(HEAT_LABEL.toLowerCase());
 254                 artifactInfo.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, artifactInfo.getArtifactLabel()));
 255
 256                 if (!placeholderOnly) {
 257                         artifactInfo.setEsId(artifactInfo.getUniqueId());
 258                         artifactInfo.setArtifactChecksum("UEsDBAoAAAAIAAeLb0bDQz");
 259
 260                         if (withHeatParams) {
 261                                 List<HeatParameterDefinition> heatParams = new ArrayList<HeatParameterDefinition>();
 262                                 HeatParameterDefinition heatParam = new HeatParameterDefinition();
 263                                 heatParam.setCurrentValue("11");
 264                                 heatParam.setDefaultValue("22");
 265                                 heatParam.setDescription("desc");
 266                                 heatParam.setName("myParam");
 267                                 heatParam.setType("number");
 268                                 heatParams.add(heatParam);
 269                                 artifactInfo.setHeatParameters(heatParams);
 270                         }
 271                 }
 272
 273                 return artifactInfo;
 274         }
 275
 276         private static ArtifactDefinition getArtifactPlaceHolder(String resourceId, String logicalName) {
 277                 ArtifactDefinition artifact = new ArtifactDefinition();
 278
 279                 artifact.setUniqueId(UniqueIdBuilder.buildPropertyUniqueId(resourceId, logicalName.toLowerCase()));
 280                 artifact.setArtifactLabel(logicalName.toLowerCase());
 281
 282                 return artifact;
 283         }
 284 }