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