catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CsarUtilsTest.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  */
  20
  21 package org.openecomp.sdc.be.tosca;
  22
  23 import static org.junit.jupiter.api.Assertions.assertEquals;
  24 import static org.junit.jupiter.api.Assertions.assertFalse;
  25 import static org.junit.jupiter.api.Assertions.assertNotNull;
  26 import static org.junit.jupiter.api.Assertions.assertThrows;
  27 import static org.junit.jupiter.api.Assertions.assertTrue;
  28 import static org.junit.jupiter.api.Assertions.fail;
  29 import static org.openecomp.sdc.be.tosca.ComponentCache.MergeStrategy.overwriteIfSameVersions;
  30 import static org.openecomp.sdc.be.tosca.ComponentCache.entry;
  31
  32 import fj.data.Either;
  33 import java.io.File;
  34 import java.io.IOException;
  35 import java.io.InputStream;
  36 import java.nio.ByteBuffer;
  37 import java.nio.file.Files;
  38 import java.nio.file.Path;
  39 import java.nio.file.Paths;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.HashMap;
  43 import java.util.HashSet;
  44 import java.util.List;
  45 import java.util.Map;
  46 import java.util.Map.Entry;
  47 import java.util.Objects;
  48 import java.util.Optional;
  49 import java.util.Set;
  50 import java.util.zip.ZipEntry;
  51 import java.util.zip.ZipOutputStream;
  52 import mockit.Deencapsulation;
  53 import org.apache.commons.collections.CollectionUtils;
  54 import org.apache.commons.io.IOUtils;
  55 import org.apache.commons.io.output.ByteArrayOutputStream;
  56 import org.apache.commons.lang3.tuple.ImmutablePair;
  57 import org.apache.commons.lang3.tuple.ImmutableTriple;
  58 import org.apache.commons.lang3.tuple.Triple;
  59 import org.junit.jupiter.api.BeforeAll;
  60 import org.junit.jupiter.api.BeforeEach;
  61 import org.junit.jupiter.api.Test;
  62 import org.mockito.InjectMocks;
  63 import org.mockito.Mock;
  64 import org.mockito.Mockito;
  65 import org.mockito.MockitoAnnotations;
  66 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
  67 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
  68 import org.openecomp.sdc.be.config.ConfigurationManager;
  69 import org.openecomp.sdc.be.dao.api.ActionStatus;
  70 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  71 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  72 import org.openecomp.sdc.be.dao.cassandra.SdcSchemaFilesCassandraDao;
  73 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  74 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  75 import org.openecomp.sdc.be.impl.ComponentsUtils;
  76 import org.openecomp.sdc.be.model.ArtifactDefinition;
  77 import org.openecomp.sdc.be.model.Component;
  78 import org.openecomp.sdc.be.model.ComponentInstance;
  79 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  80 import org.openecomp.sdc.be.model.Resource;
  81 import org.openecomp.sdc.be.model.Service;
  82 import org.openecomp.sdc.be.model.User;
  83 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  84 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  85 import org.openecomp.sdc.be.resources.data.DAOArtifactData;
  86 import org.openecomp.sdc.be.resources.data.SdcSchemaFilesData;
  87 import org.openecomp.sdc.be.tosca.ComponentCache.CacheEntry;
  88 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
  89 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
  90 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  91 import org.openecomp.sdc.common.api.ConfigurationSource;
  92 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  93 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  94 import org.openecomp.sdc.common.test.BaseConfDependent;
  95 import org.openecomp.sdc.exception.ResponseFormat;
  96
  97 class CsarUtilsTest extends BaseConfDependent {
  98
  99     private final List<String> nodesFromPackage = Arrays.asList("tosca.nodes.Root", "tosca.nodes.Container.Application");
 100     private final byte[] contentData;
 101     @InjectMocks
 102     private CsarUtils testSubject;
 103     @InjectMocks
 104     private CommonCsarGenerator commonCsarGenerator;
 105     @Mock
 106     private ArtifactCassandraDao artifactCassandraDao;
 107     @Mock
 108     private ComponentsUtils componentsUtils;
 109     @Mock
 110     private ToscaExportHandler toscaExportUtils;
 111     @Mock
 112     private SdcSchemaFilesCassandraDao sdcSchemaFilesCassandraDao;
 113     @Mock
 114     private ToscaOperationFacade toscaOperationFacade;
 115     @Mock
 116     private ArtifactsBusinessLogic artifactsBusinessLogic;
 117
 118     public CsarUtilsTest() throws IOException {
 119         contentData = getFileResource("yamlValidation/resource-serviceTemplate.yml");
 120     }
 121
 122     @BeforeAll
 123     public static void setupBeforeClass() {
 124         componentName = "catalog-be";
 125         confPath = "src/test/resources/config";
 126         setUp();
 127     }
 128
 129     private static void initConfigurationManager() {
 130         final String confPath = new File(Objects
 131             .requireNonNull(
 132                 CsarUtilsTest.class.getClassLoader().getResource("config/catalog-be/configuration.yaml"))
 133             .getFile()).getParent();
 134         final ConfigurationSource confSource =
 135             new FSConfigurationSource(ExternalConfiguration.getChangeListener(), confPath);
 136         new ConfigurationManager(confSource);
 137     }
 138
 139     @BeforeEach
 140     public void setUpMock() {
 141         ExternalConfiguration.setAppName("catalog-be");
 142         MockitoAnnotations.openMocks(this);
 143         initConfigurationManager();
 144     }
 145
 146     @Test
 147     void testCreateCsar() throws IOException {
 148         Component component = new Resource();
 149         Map<String, ArtifactDefinition> artifactDefinitionHashMap = new HashMap<>();
 150         ArtifactDefinition artifact = new ArtifactDefinition();
 151         artifact.setArtifactName("artifactName");
 152         artifact.setEsId("esId");
 153         artifactDefinitionHashMap.put("assettoscatemplate", artifact);
 154
 155         component.setToscaArtifacts(artifactDefinitionHashMap);
 156         component.setArtifacts(artifactDefinitionHashMap);
 157         component.setDeploymentArtifacts(artifactDefinitionHashMap);
 158
 159         ByteArrayOutputStream out = new ByteArrayOutputStream();
 160         ZipOutputStream zip = new ZipOutputStream(out);
 161
 162         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class)))
 163             .thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
 164
 165         Mockito.when(componentsUtils.convertFromStorageResponse(Mockito.any(StorageOperationStatus.class)))
 166             .thenReturn(ActionStatus.GENERAL_ERROR);
 167
 168         assertNotNull(commonCsarGenerator.generateCsarZip(component, false, zip,
 169             false, true,
 170             "Definitions/", true, false).right());
 171     }
 172
 173     @Test
 174     void testCreateCsarWithGenerateCsarZipResponseIsLeft() throws IOException {
 175         Component component = new Resource();
 176         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 177         ArtifactDefinition artifact = new ArtifactDefinition();
 178         artifact.setArtifactName("artifactName");
 179         artifact.setEsId("esId");
 180         artifact.setArtifactUUID("artifactUUID");
 181         artifact.setArtifactType("YANG");
 182         toscaArtifacts.put("assettoscatemplate", artifact);
 183
 184         component.setToscaArtifacts(toscaArtifacts);
 185         component.setDeploymentArtifacts(toscaArtifacts);
 186         component.setArtifacts(toscaArtifacts);
 187         DAOArtifactData artifactData = new DAOArtifactData();
 188         byte[] data = "value".getBytes();
 189         ByteBuffer bufferData = ByteBuffer.wrap(data);
 190         artifactData.setData(bufferData);
 191
 192         ToscaTemplate toscaTemplate = new ToscaTemplate("version");
 193         List<Triple<String, String, Component>> dependencies = new ArrayList<>();
 194         toscaTemplate.setDependencies(dependencies);
 195
 196         List<SdcSchemaFilesData> filesData = new ArrayList<>();
 197         SdcSchemaFilesData filedata = new SdcSchemaFilesData();
 198         filedata.setPayloadAsArray(data);
 199         filesData.add(filedata);
 200
 201         ByteArrayOutputStream out = new ByteArrayOutputStream();
 202         ZipOutputStream zip = new ZipOutputStream(out);
 203
 204         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
 205
 206         Mockito.when(componentsUtils.convertFromStorageResponse(Mockito.any(StorageOperationStatus.class)))
 207             .thenReturn(ActionStatus.GENERAL_ERROR);
 208
 209         Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
 210             .thenReturn(Either.left(toscaTemplate));
 211
 212         Mockito.when(
 213                 sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
 214             .thenReturn(Either.left(filesData));
 215
 216         assertNotNull(commonCsarGenerator.generateCsarZip(component, false, zip,
 217             false, true,
 218             "Definitions/", true, false).right());
 219     }
 220
 221     @Test
 222     void testPopulateZipWhenGetDependenciesIsRight() {
 223         Component component = new Service();
 224         boolean getFromCS = false;
 225
 226         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 227         ArtifactDefinition artifact = new ArtifactDefinition();
 228         artifact.setArtifactName("artifactName");
 229         artifact.setEsId("esId");
 230         artifact.setArtifactUUID("artifactUUID");
 231         artifact.setArtifactType("YANG");
 232         toscaArtifacts.put("assettoscatemplate", artifact);
 233
 234         component.setToscaArtifacts(toscaArtifacts);
 235         component.setDeploymentArtifacts(toscaArtifacts);
 236         component.setArtifacts(toscaArtifacts);
 237         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 238         DAOArtifactData artifactData = new DAOArtifactData();
 239         byte[] data = "value".getBytes();
 240         ByteBuffer bufferData = ByteBuffer.wrap(data);
 241         artifactData.setData(bufferData);
 242
 243         ToscaRepresentation tosca = ToscaRepresentation.make("value".getBytes());
 244
 245         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
 246
 247         Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
 248
 249         Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
 250             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 251
 252         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
 253             Deencapsulation.invoke(commonCsarGenerator, "generateCsarZip", component, getFromCS, zip, true, true, "Definitions/", true, false);
 254         } catch (Exception e) {
 255             e.printStackTrace();
 256         }
 257     }
 258
 259     @Test
 260     void testPopulateZipWhenExportComponentIsRight() {
 261         Component component = new Resource();
 262         boolean getFromCS = false;
 263
 264         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 265         ArtifactDefinition artifact = new ArtifactDefinition();
 266         artifact.setArtifactName("artifactName");
 267         artifact.setEsId("esId");
 268         artifact.setArtifactUUID("artifactUUID");
 269         artifact.setArtifactType("YANG");
 270         toscaArtifacts.put("assettoscatemplate", artifact);
 271
 272         component.setToscaArtifacts(toscaArtifacts);
 273         component.setDeploymentArtifacts(toscaArtifacts);
 274         component.setArtifacts(toscaArtifacts);
 275         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 276         DAOArtifactData artifactData = new DAOArtifactData();
 277         byte[] data = "value".getBytes();
 278         ByteBuffer bufferData = ByteBuffer.wrap(data);
 279         artifactData.setData(bufferData);
 280
 281         Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class)))
 282             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 283
 284         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
 285             Deencapsulation.invoke(commonCsarGenerator, "generateCsarZip", component, getFromCS, zip, true, true, "Definitions/", true, false);
 286         } catch (Exception e) {
 287             e.printStackTrace();
 288         }
 289     }
 290
 291     @Test
 292     void testPopulateZipWhenComponentIsServiceAndCollectComponentCsarDefinitionIsRight() {
 293         Component component = new Service();
 294         boolean getFromCS = false;
 295
 296         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 297         ArtifactDefinition artifact = new ArtifactDefinition();
 298         artifact.setArtifactName("artifactName");
 299         artifact.setEsId("esId");
 300         artifact.setArtifactUUID("artifactUUID");
 301         artifact.setArtifactType("YANG");
 302         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 303         artifact.setDescription("description");
 304         artifact.setArtifactLabel("artifactLabel");
 305         toscaArtifacts.put("assettoscatemplate", artifact);
 306
 307         component.setToscaArtifacts(toscaArtifacts);
 308         component.setDeploymentArtifacts(toscaArtifacts);
 309         component.setArtifacts(toscaArtifacts);
 310         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 311         component.setVersion("1.0");
 312         component.setLastUpdaterUserId("userId");
 313         component.setUniqueId("uid");
 314         DAOArtifactData artifactData = new DAOArtifactData();
 315         ByteBuffer bufferData = ByteBuffer.wrap(contentData);
 316         artifactData.setData(bufferData);
 317
 318         List<SdcSchemaFilesData> filesData = new ArrayList<>();
 319         SdcSchemaFilesData filedata = new SdcSchemaFilesData();
 320         filedata.setPayloadAsArray(contentData);
 321         filesData.add(filedata);
 322
 323         ToscaTemplate toscaTemplate = new ToscaTemplate("version");
 324         List<Triple<String, String, Component>> dependencies = new ArrayList<>();
 325         Triple<String, String, Component> triple = Triple.of("fileName", "cassandraId", component);
 326         dependencies.add(triple);
 327         toscaTemplate.setDependencies(dependencies);
 328
 329         ToscaRepresentation tosca = ToscaRepresentation.make("value".getBytes());
 330
 331         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
 332
 333         Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
 334
 335         Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
 336             .thenReturn(Either.left(toscaTemplate));
 337
 338         Mockito.when(
 339                 sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
 340             .thenReturn(Either.left(filesData));
 341
 342         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class)))
 343             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 344
 345         Mockito.when(artifactsBusinessLogic.validateUserExists(Mockito.any(User.class))).thenReturn(new User());
 346
 347
 348         Mockito.when(artifactsBusinessLogic.validateAndHandleArtifact(Mockito.any(String.class),
 349                 Mockito.any(ComponentTypeEnum.class), Mockito.any(ArtifactOperationInfo.class), Mockito.isNull(),
 350                 Mockito.any(ArtifactDefinition.class), Mockito.any(String.class), Mockito.any(String.class),
 351                 Mockito.isNull(), Mockito.isNull(), Mockito.any(User.class), Mockito.any(Component.class),
 352                 Mockito.any(Boolean.class), Mockito.any(Boolean.class), Mockito.any(Boolean.class)))
 353             .thenReturn(Either.left(Mockito.any(ArtifactDefinition.class)));
 354
 355         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
 356             Deencapsulation.invoke(commonCsarGenerator, "generateCsarZip", component, getFromCS, zip, true, true, "/Definitions", true, false);
 357         } catch (Exception e) {
 358             e.printStackTrace();
 359         }
 360     }
 361
 362     @Test
 363     void testPopulateZipWhenGetEntryDataIsRight() {
 364         Component component = new Service();
 365         boolean getFromCS = true;
 366
 367         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 368         ArtifactDefinition artifact = new ArtifactDefinition();
 369         artifact.setArtifactName("artifactName");
 370         artifact.setEsId("esId");
 371         artifact.setArtifactUUID("artifactUUID");
 372         artifact.setArtifactType("YANG");
 373         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 374         artifact.setDescription("description");
 375         artifact.setArtifactLabel("artifactLabel");
 376         toscaArtifacts.put("assettoscatemplate", artifact);
 377
 378         component.setToscaArtifacts(toscaArtifacts);
 379         component.setDeploymentArtifacts(toscaArtifacts);
 380         component.setArtifacts(toscaArtifacts);
 381         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 382         component.setVersion("1.0");
 383         component.setLastUpdaterUserId("userId");
 384         component.setUniqueId("uid");
 385         DAOArtifactData artifactData = new DAOArtifactData();
 386         byte[] data = "value".getBytes();
 387         ByteBuffer bufferData = ByteBuffer.wrap(data);
 388         artifactData.setData(bufferData);
 389
 390         ToscaTemplate toscaTemplate = new ToscaTemplate("version");
 391         List<Triple<String, String, Component>> dependencies = new ArrayList<>();
 392         Triple<String, String, Component> triple = Triple.of("fileName", "", component);
 393         dependencies.add(triple);
 394         toscaTemplate.setDependencies(dependencies);
 395
 396         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
 397
 398         Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class)))
 399             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 400
 401         Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
 402             .thenReturn(Either.left(toscaTemplate));
 403
 404         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
 405             Deencapsulation.invoke(commonCsarGenerator, "generateCsarZip", component, getFromCS, zip, true, true, "Definitions/", true, false);
 406         } catch (Exception e) {
 407             e.printStackTrace();
 408         }
 409     }
 410
 411     @Test
 412     void testPopulateZipWhenGetEntryDataOfInnerComponentIsRight() {
 413         Component component = new Service();
 414         boolean getFromCS = false;
 415
 416         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 417         ArtifactDefinition artifact = new ArtifactDefinition();
 418         artifact.setArtifactName("artifactName");
 419         artifact.setEsId("esId");
 420         artifact.setArtifactUUID("artifactUUID");
 421         artifact.setArtifactType("YANG");
 422         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 423         artifact.setDescription("description");
 424         artifact.setArtifactLabel("artifactLabel");
 425         toscaArtifacts.put("assettoscatemplate", artifact);
 426
 427         component.setToscaArtifacts(toscaArtifacts);
 428         component.setDeploymentArtifacts(toscaArtifacts);
 429         component.setArtifacts(toscaArtifacts);
 430         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 431         component.setVersion("1.0");
 432         component.setLastUpdaterUserId("userId");
 433         component.setUniqueId("uid");
 434         DAOArtifactData artifactData = new DAOArtifactData();
 435         ByteBuffer bufferData = ByteBuffer.wrap(contentData);
 436         artifactData.setData(bufferData);
 437
 438         ToscaTemplate toscaTemplate = new ToscaTemplate("version");
 439         List<Triple<String, String, Component>> dependencies = new ArrayList<>();
 440         Triple<String, String, Component> triple = Triple.of("fileName", "", component);
 441         dependencies.add(triple);
 442         toscaTemplate.setDependencies(dependencies);
 443
 444         ToscaRepresentation tosca = ToscaRepresentation.make(contentData);
 445
 446         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
 447
 448         Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca),
 449             Either.left(tosca), Either.right(ToscaError.GENERAL_ERROR));
 450
 451         Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
 452             .thenReturn(Either.left(toscaTemplate));
 453
 454         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
 455             Deencapsulation.invoke(commonCsarGenerator, "generateCsarZip", component, getFromCS, zip, true, true, "Definitions/", true, false);
 456         } catch (Exception e) {
 457             e.printStackTrace();
 458         }
 459     }
 460
 461     @Test
 462     void testPopulateZipWhenLatestSchemaFilesFromCassandraIsRight() {
 463         Component component = new Service();
 464         boolean getFromCS = false;
 465
 466         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 467         ArtifactDefinition artifact = new ArtifactDefinition();
 468         artifact.setArtifactName("artifactName");
 469         artifact.setEsId("esId");
 470         artifact.setArtifactUUID("artifactUUID");
 471         artifact.setArtifactType("YANG");
 472         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 473         artifact.setDescription("description");
 474         artifact.setArtifactLabel("artifactLabel");
 475         toscaArtifacts.put("assettoscatemplate", artifact);
 476
 477         component.setToscaArtifacts(toscaArtifacts);
 478         component.setDeploymentArtifacts(toscaArtifacts);
 479         component.setArtifacts(toscaArtifacts);
 480         component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 481         component.setVersion("1.0");
 482         component.setLastUpdaterUserId("userId");
 483         component.setUniqueId("uid");
 484         DAOArtifactData artifactData = new DAOArtifactData();
 485         ByteBuffer bufferData = ByteBuffer.wrap(contentData);
 486         artifactData.setData(bufferData);
 487
 488         ToscaTemplate toscaTemplate = new ToscaTemplate("version");
 489         List<Triple<String, String, Component>> dependencies = new ArrayList<>();
 490         Triple<String, String, Component> triple = Triple.of("fileName", "", component);
 491         dependencies.add(triple);
 492         toscaTemplate.setDependencies(dependencies);
 493
 494         ToscaRepresentation tosca = ToscaRepresentation.make(contentData);
 495
 496         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
 497
 498         Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
 499
 500         Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
 501             .thenReturn(Either.left(toscaTemplate));
 502
 503         Mockito.when(
 504                 sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
 505             .thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
 506
 507         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
 508             Deencapsulation.invoke(commonCsarGenerator, "generateCsarZip", component, getFromCS, zip, true, "toscaMetaFileName", true, "Definitions/",
 509                 true, false);
 510         } catch (Exception e) {
 511             e.printStackTrace();
 512         }
 513     }
 514
 515     @Test
 516     void testAddInnerComponentsToCache() {
 517         ComponentCache componentCache = ComponentCache.overwritable(overwriteIfSameVersions());
 518         Component childComponent = new Resource();
 519         Component componentRI = new Service();
 520         List<ComponentInstance> componentInstances = new ArrayList<>();
 521         ComponentInstance instance = new ComponentInstance();
 522         instance.setComponentUid("resourceUid");
 523         componentInstances.add(instance);
 524         childComponent.setComponentInstances(componentInstances);
 525
 526         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 527         ArtifactDefinition artifact = new ArtifactDefinition();
 528         artifact.setArtifactName("artifactName");
 529         artifact.setEsId("esId");
 530         artifact.setArtifactUUID("artifactUUID");
 531         artifact.setArtifactType("YANG");
 532         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 533         artifact.setDescription("description");
 534         artifact.setArtifactLabel("artifactLabel");
 535         toscaArtifacts.put("assettoscatemplate", artifact);
 536
 537         componentRI.setToscaArtifacts(toscaArtifacts);
 538
 539         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class)))
 540             .thenReturn(Either.left(componentRI));
 541
 542         Deencapsulation.invoke(commonCsarGenerator, "addInnerComponentsToCache", componentCache, childComponent);
 543
 544         io.vavr.collection.List<CacheEntry> expected = io.vavr.collection.List.of(entry("esId", "artifactName", componentRI));
 545         assertEquals(expected, componentCache.all().toList());
 546     }
 547
 548     @Test
 549     void testAddInnerComponentsToCacheWhenGetToscaElementIsRight() {
 550         Map<String, ImmutableTriple<String, String, Component>> componentCache = new HashMap<>();
 551         Component childComponent = new Resource();
 552
 553         List<ComponentInstance> componentInstances = new ArrayList<>();
 554         ComponentInstance instance = new ComponentInstance();
 555         instance.setComponentUid("abc");
 556         componentInstances.add(instance);
 557         childComponent.setComponentInstances(componentInstances);
 558
 559         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 560         ArtifactDefinition artifact = new ArtifactDefinition();
 561         artifact.setArtifactName("artifactName");
 562         artifact.setEsId("esId");
 563         artifact.setArtifactUUID("artifactUUID");
 564         artifact.setArtifactType("YANG");
 565         artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
 566         artifact.setDescription("description");
 567         artifact.setArtifactLabel("artifactLabel");
 568         toscaArtifacts.put("assettoscatemplate", artifact);
 569
 570         Component componentRI = new Service();
 571
 572         componentRI.setToscaArtifacts(toscaArtifacts);
 573
 574         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class)))
 575             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 576
 577
 578         assertTrue(componentCache.isEmpty());
 579     }
 580
 581     @Test
 582     void testWriteComponentInterface() throws IOException {
 583         String fileName = "name.hello";
 584         ToscaRepresentation tosca = ToscaRepresentation.make("value".getBytes());
 585
 586         Mockito.when(toscaExportUtils.exportComponentInterface(Mockito.any(Component.class), Mockito.any(Boolean.class)))
 587             .thenReturn(Either.left(tosca));
 588
 589
 590         try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out)) {
 591             List<Triple<String, String, Component>> output = Deencapsulation.invoke(commonCsarGenerator, "writeComponentInterface", new Resource(),
 592                 zip, fileName, "Definitions/");
 593             assertNotNull(output);
 594         }
 595     }
 596
 597     @Test
 598     void testGetEntryData() {
 599         String cassandraId = "id";
 600         Component childComponent = new Resource();
 601
 602         Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class)))
 603             .thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
 604
 605         Either<byte[], ActionStatus> output = Deencapsulation.invoke(commonCsarGenerator, "getEntryData", cassandraId, childComponent);
 606
 607         assertNotNull(output);
 608         assertTrue(output.isRight());
 609     }
 610
 611     @Test
 612     void testGetLatestSchemaFilesFromCassandraWhenListOfSchemasIsEmpty() {
 613         List<SdcSchemaFilesData> filesData = new ArrayList<>();
 614
 615         Mockito.when(
 616                 sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
 617             .thenReturn(Either.left(filesData));
 618
 619         Either<byte[], ResponseFormat> output = Deencapsulation.invoke(commonCsarGenerator, "getLatestSchemaFilesFromCassandra");
 620
 621         assertNotNull(output);
 622         assertTrue(output.isRight());
 623     }
 624
 625     @Test
 626     void testExtractVfcsArtifactsFromCsar() {
 627         String key = "Artifacts/org.openecomp.resource.some/Deployment/to/resource";
 628         byte[] data = "value".getBytes();
 629
 630         Map<String, byte[]> csar = new HashMap<>();
 631         csar.put(key, data);
 632
 633         Map<String, List<ArtifactDefinition>> output = CsarUtils.extractVfcsArtifactsFromCsar(csar);
 634
 635         assertNotNull(output);
 636         assertTrue(output.containsKey("org.openecomp.resource.some"));
 637         assertEquals(1, output.get("org.openecomp.resource.some").size());
 638     }
 639
 640     @Test
 641     void testAddExtractedVfcArtifactWhenArtifactsContainsExtractedArtifactKey() {
 642         ImmutablePair<String, ArtifactDefinition> extractedVfcArtifact = new ImmutablePair<String, ArtifactDefinition>(
 643             "key", new ArtifactDefinition());
 644         Map<String, List<ArtifactDefinition>> artifacts = new HashMap<>();
 645         artifacts.put("key", new ArrayList<>());
 646
 647         Deencapsulation.invoke(testSubject, "addExtractedVfcArtifact", extractedVfcArtifact, artifacts);
 648
 649         assertEquals(1, artifacts.get("key").size());
 650     }
 651
 652     @Test
 653     void testAddExtractedVfcArtifactWhenArtifactsDoesntContainsExtractedArtifactKey() {
 654         ImmutablePair<String, ArtifactDefinition> extractedVfcArtifact = new ImmutablePair<String, ArtifactDefinition>(
 655             "key", new ArtifactDefinition());
 656         Map<String, List<ArtifactDefinition>> artifacts = new HashMap<>();
 657         artifacts.put("key1", new ArrayList<>());
 658
 659         Deencapsulation.invoke(testSubject, "addExtractedVfcArtifact", extractedVfcArtifact, artifacts);
 660
 661         assertEquals(0, artifacts.get("key1").size());
 662         assertEquals(1, artifacts.get("key").size());
 663         assertEquals(2, artifacts.size());
 664     }
 665
 666     @Test
 667     void testExtractVfcArtifact() {
 668         String path = "path/to/informational/artificat";
 669         Map<String, byte[]> map = new HashMap<>();
 670         map.put(path, "value".getBytes());
 671         Entry<String, byte[]> entry = map.entrySet().iterator().next();
 672
 673         Optional<ImmutablePair<String, ArtifactDefinition>> output =
 674             Deencapsulation.invoke(testSubject, "extractVfcArtifact", entry, new HashMap<>());
 675
 676         if (output.isPresent()) {
 677             assertEquals("to", output.get().left);
 678         } else {
 679             fail("`output` is empty!");
 680         }
 681     }
 682
 683     @Test
 684     void testDetectArtifactGroupTypeWithExceptionBeingCaught() {
 685         Either<ArtifactGroupTypeEnum, Boolean> output = Deencapsulation.invoke(testSubject, "detectArtifactGroupType", "type", Map.class);
 686
 687         assertNotNull(output);
 688         assertTrue(output.isRight());
 689         assertFalse(output.right().value());
 690     }
 691
 692     @Test
 693     void testDetectArtifactGroupTypeWWhenCollectedWarningMessagesContainesKey() {
 694         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
 695
 696         collectedWarningMessages.put("Warning - unrecognized artifact group type {} was received.", new HashSet<>());
 697         Either<ArtifactGroupTypeEnum, Boolean> output =
 698             Deencapsulation.invoke(testSubject, "detectArtifactGroupType", "type", collectedWarningMessages);
 699
 700         assertNotNull(output);
 701         assertTrue(output.isRight());
 702         assertFalse(output.right().value());
 703     }
 704
 705     @Test
 706     void testValidateNonMetaArtifactWithExceptionCaught() {
 707         CsarUtils.validateNonMetaArtifact("", new byte[0], new HashMap<>());
 708     }
 709
 710     @Test
 711     void testCollectComponentCsarDefinitionWhenComponentIsServiceAndGetToscaElementIsLeft() {
 712         Component component = new Service();
 713         component.setUniqueId("uniqueId");
 714         List<ComponentInstance> resourceInstances = new ArrayList<>();
 715         ComponentInstance instance = new ComponentInstance();
 716         instance.setComponentUid("resourceUid");
 717         instance.setOriginType(OriginTypeEnum.SERVICE);
 718         resourceInstances.add(instance);
 719         component.setComponentInstances(resourceInstances);
 720
 721         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 722         ArtifactDefinition artifact = new ArtifactDefinition();
 723         artifact.setArtifactName("artifactName");
 724         artifact.setEsId("esId");
 725         artifact.setArtifactUUID("artifactUUID");
 726         artifact.setArtifactType("YANG");
 727         toscaArtifacts.put("assettoscatemplate", artifact);
 728
 729         component.setToscaArtifacts(toscaArtifacts);
 730         component.setDeploymentArtifacts(toscaArtifacts);
 731         component.setArtifacts(toscaArtifacts);
 732
 733         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class))).thenReturn(Either.left(component),
 734             Either.right(StorageOperationStatus.BAD_REQUEST));
 735
 736         Either<Object, ResponseFormat> output = Deencapsulation.invoke(testSubject, "collectComponentCsarDefinition", component);
 737
 738         assertNotNull(output);
 739         assertTrue(output.isRight());
 740     }
 741
 742     @Test
 743     void testCollectComponentTypeArtifactsWhenFetchedComponentHasComponentInstances() {
 744         Component component = new Service();
 745         Component fetchedComponent = new Resource();
 746         component.setUniqueId("uniqueId");
 747         List<ComponentInstance> resourceInstances = new ArrayList<>();
 748         ComponentInstance instance = new ComponentInstance();
 749         instance.setComponentUid("resourceUid");
 750         instance.setOriginType(OriginTypeEnum.SERVICE);
 751         resourceInstances.add(instance);
 752         component.setComponentInstances(resourceInstances);
 753         fetchedComponent.setComponentInstances(resourceInstances);
 754
 755         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 756         ArtifactDefinition artifact = new ArtifactDefinition();
 757         artifact.setArtifactName("artifactName");
 758         artifact.setEsId("esId");
 759         artifact.setArtifactUUID("artifactUUID");
 760         artifact.setArtifactType("YANG");
 761         toscaArtifacts.put("assettoscatemplate", artifact);
 762
 763         component.setToscaArtifacts(toscaArtifacts);
 764         component.setDeploymentArtifacts(toscaArtifacts);
 765         component.setArtifacts(toscaArtifacts);
 766
 767         fetchedComponent.setToscaArtifacts(toscaArtifacts);
 768         fetchedComponent.setDeploymentArtifacts(toscaArtifacts);
 769         fetchedComponent.setArtifacts(toscaArtifacts);
 770
 771         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class))).thenReturn(Either.left(component),
 772             Either.left(fetchedComponent), Either.right(StorageOperationStatus.BAD_REQUEST));
 773
 774         Either<Object, ResponseFormat> output = Deencapsulation.invoke(testSubject, "collectComponentCsarDefinition", component);
 775
 776         assertNotNull(output);
 777         assertTrue(output.isRight());
 778     }
 779
 780     @Test
 781     void testCollectComponentTypeArtifactsWhenFetchedComponentDontHaveComponentInstances() {
 782         Component component = new Service();
 783         Component fetchedComponent = new Resource();
 784         component.setUniqueId("uniqueId");
 785         List<ComponentInstance> resourceInstances = new ArrayList<>();
 786         ComponentInstance instance = new ComponentInstance();
 787         instance.setComponentUid("resourceUid");
 788         instance.setOriginType(OriginTypeEnum.SERVICE);
 789
 790         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 791         ArtifactDefinition artifact = new ArtifactDefinition();
 792         artifact.setArtifactName("artifactName");
 793         artifact.setEsId("esId");
 794         artifact.setArtifactUUID("artifactUUID");
 795         artifact.setArtifactType("PLAN");
 796         toscaArtifacts.put("assettoscatemplate", artifact);
 797
 798         instance.setDeploymentArtifacts(toscaArtifacts);
 799
 800         resourceInstances.add(instance);
 801         component.setComponentInstances(resourceInstances);
 802
 803         component.setToscaArtifacts(toscaArtifacts);
 804         component.setDeploymentArtifacts(toscaArtifacts);
 805         component.setArtifacts(toscaArtifacts);
 806
 807         fetchedComponent.setToscaArtifacts(toscaArtifacts);
 808         fetchedComponent.setDeploymentArtifacts(toscaArtifacts);
 809         fetchedComponent.setArtifacts(toscaArtifacts);
 810
 811         Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class))).thenReturn(Either.left(component),
 812             Either.left(fetchedComponent));
 813
 814         Either<Object, ResponseFormat> output = Deencapsulation.invoke(testSubject, "collectComponentCsarDefinition", component);
 815
 816         assertNotNull(output);
 817         assertTrue(output.isLeft());
 818     }
 819
 820     @Test
 821     void testValidateNonMetaArtifactHappyScenario() {
 822         String artifactPath = "Artifacts/Deployment/YANG_XML/myYang.xml";
 823         byte[] payloadData = "some payload data".getBytes();
 824         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
 825         Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath,
 826             payloadData, collectedWarningMessages);
 827         assertTrue(eitherNonMetaArtifact.isLeft());
 828         assertTrue(collectedWarningMessages.isEmpty());
 829
 830         artifactPath = "Artifacts/Informational/OTHER/someArtifact.xml";
 831         eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
 832         assertTrue(eitherNonMetaArtifact.isLeft());
 833         assertTrue(collectedWarningMessages.isEmpty());
 834     }
 835
 836     @Test
 837     void testValidateNonMetaArtifactScenarioWithWarnnings() {
 838         String artifactPath = "Artifacts/Deployment/Buga/myYang.xml";
 839         byte[] payloadData = "some payload data".getBytes();
 840         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
 841         Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath,
 842             payloadData, collectedWarningMessages);
 843         assertTrue(eitherNonMetaArtifact.isLeft());
 844
 845         artifactPath = "Artifacts/Informational/Buga2/someArtifact.xml";
 846         eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
 847         assertTrue(eitherNonMetaArtifact.isLeft());
 848
 849         assertEquals(1, collectedWarningMessages.size());
 850         assertEquals(2, collectedWarningMessages.values().iterator().next().size());
 851     }
 852
 853     @Test
 854     void testValidateNonMetaArtifactUnhappyScenario() {
 855         String artifactPath = "Artifacts/Buga/YANG_XML/myYang.xml";
 856         byte[] payloadData = "some payload data".getBytes();
 857         Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
 858         Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath,
 859             payloadData, collectedWarningMessages);
 860         assertTrue(eitherNonMetaArtifact.isRight());
 861         assertFalse(collectedWarningMessages.isEmpty());
 862     }
 863
 864     @Test
 865     void testAddSchemaFilesFromCassandraAddingDuplicatedEntry() throws IOException {
 866         final String rootPath = System.getProperty("user.dir");
 867         final Path path = Paths.get(rootPath + "/src/test/resources/sdc.zip");
 868         final byte[] data = Files.readAllBytes(path);
 869         try (final ByteArrayOutputStream out = new ByteArrayOutputStream(); final ZipOutputStream zip = new ZipOutputStream(out)) {
 870             Deencapsulation.invoke(commonCsarGenerator, "addSchemaFilesFromCassandra", zip, data, nodesFromPackage, "Definitions/");
 871             final IOException actualException = assertThrows(IOException.class, () -> zip.putNextEntry(new ZipEntry("Definitions/nodes.yml")));
 872             assertEquals("duplicate entry: Definitions/nodes.yml", actualException.getMessage());
 873         }
 874     }
 875
 876     @Test
 877     void testFindNonRootNodesFromPackage() {
 878         final Resource resource = new Resource();
 879         resource.setDerivedList(nodesFromPackage);
 880         final Component component = resource;
 881         final List<Triple<String, String, Component>> dependencies = new ArrayList<>();
 882         final Triple<String, String, Component> triple = Triple.of("fileName", "cassandraId", component);
 883         dependencies.add(triple);
 884         final List<String> expectedResult = Arrays.asList("tosca.nodes.Container.Application");
 885         final List<String> result = Deencapsulation.invoke(commonCsarGenerator,
 886             "findNonRootNodesFromPackage", dependencies);
 887         assertTrue(CollectionUtils.isNotEmpty(result));
 888         assertEquals(expectedResult, result);
 889     }
 890
 891     private byte[] getFileResource(final String filePath) throws IOException {
 892         try (final InputStream inputStream = getFileResourceAsInputStream(filePath)) {
 893             return IOUtils.toByteArray(inputStream);
 894         }
 895     }
 896
 897     private InputStream getFileResourceAsInputStream(final String filePath) {
 898         return Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
 899     }
 900
 901 }