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