asdctool/src/test/java/org/openecomp/sdc/asdctool/impl/internal/tool/CsarGeneratorTest.java

   1 /*
   2  * Copyright (c) 2018 Huawei Intellectual Property.
   3  * Modifications Copyright (c) 2019 Samsung
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.openecomp.sdc.asdctool.impl.internal.tool;
  19
  20 import fj.data.Either;
  21 import org.junit.After;
  22 import org.junit.Before;
  23 import org.junit.BeforeClass;
  24 import org.junit.Test;
  25 import org.junit.runner.RunWith;
  26 import org.mockito.InjectMocks;
  27 import org.mockito.Mock;
  28 import org.mockito.junit.MockitoJUnitRunner;
  29 import org.openecomp.sdc.be.config.ConfigurationManager;
  30 import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
  31 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  32 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  33 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  34 import org.openecomp.sdc.be.dao.jsongraph.types.EdgeLabelEnum;
  35 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  36 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  37 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  38 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  39 import org.openecomp.sdc.be.model.ArtifactDefinition;
  40 import org.openecomp.sdc.be.model.Component;
  41 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  42 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  43 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  44 import org.openecomp.sdc.be.tosca.CsarUtils;
  45 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
  46 import org.openecomp.sdc.be.tosca.ToscaRepresentation;
  47 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
  48 import org.openecomp.sdc.common.api.ConfigurationSource;
  49 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  50 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  51
  52 import java.io.ByteArrayInputStream;
  53 import java.io.ByteArrayOutputStream;
  54 import java.io.File;
  55 import java.io.PrintStream;
  56 import java.util.ArrayList;
  57 import java.util.EnumMap;
  58 import java.util.HashMap;
  59 import java.util.List;
  60 import java.util.Map;
  61 import java.util.Objects;
  62 import java.util.Scanner;
  63
  64 import static org.junit.Assert.assertEquals;
  65 import static org.mockito.ArgumentMatchers.any;
  66 import static org.mockito.Mockito.when;
  67
  68 @RunWith(MockitoJUnitRunner.class)
  69 public class CsarGeneratorTest {
  70
  71     @InjectMocks
  72     private CsarGenerator test;
  73
  74     @Mock
  75     private JanusGraphDao janusGraphDao;
  76
  77     @Mock
  78     private Component component;
  79
  80     @Mock
  81     private ToscaOperationFacade toscaOperationFacade;
  82
  83     @Mock
  84     private ArtifactCassandraDao artifactCassandraDao;
  85
  86     @Mock
  87     private ToscaExportHandler toscaExportHandler;
  88
  89     @Mock
  90     CsarUtils csarUtils;
  91
  92     @Mock
  93     private ArtifactDefinition toscaTemplate;
  94
  95     @Mock
  96     private ArtifactDefinition toscaCsar;
  97
  98     @Mock
  99     ToscaRepresentation toscaRepresentation;
 100
 101     private static final String ANSWER = "yes";
 102     private static final String UUID = "123";
 103     private static final String UNIQUE_ID = "321";
 104     private static final String PAYLOAD = "testPayload";
 105     private static final String TEMPLATE_LABEL = "TEMPLATE_LABEL";
 106     private static final String CSAR_LABEL = "CSAR_LABEL";
 107
 108     private PrintStream systemOut;
 109     private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 110     private final ByteArrayInputStream inContent = new ByteArrayInputStream(ANSWER.getBytes());
 111
 112     private final Map<GraphPropertyEnum, Object> service = new EnumMap<>(GraphPropertyEnum.class);
 113     private final Map<String, ArtifactDefinition> toscaArtifact = new HashMap<>();
 114
 115     private final Scanner scanner = new Scanner(inContent);
 116     private final List<GraphVertex> criteria = new ArrayList<>();
 117     private final GraphVertex graphVertex = new GraphVertex();
 118
 119     @BeforeClass
 120     public static void setup() {
 121         initConfigurationManager();
 122     }
 123
 124     @Before
 125     public void setupSystemOut() {
 126         systemOut = System.out;
 127         System.setOut(new PrintStream(outContent));
 128     }
 129
 130     @After
 131     public void revertSystemOut() {
 132         System.setOut(systemOut);
 133     }
 134
 135     @Test
 136     public void testGenerateCsar() {
 137         // given
 138         graphVertex.setUniqueId(UNIQUE_ID);
 139         criteria.add(graphVertex);
 140
 141         service.put(GraphPropertyEnum.UUID, UUID);
 142         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 143         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 144         graphVertex.setMetadataProperties(service);
 145
 146         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 147             .thenReturn(Either.left(criteria));
 148         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 149             .thenReturn(Either.left(component));
 150         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.TOSCA_ARTIFACTS,
 151             JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(graphVertex));
 152
 153         // when
 154         test.generateCsar(UUID, scanner);
 155         String[] consoleOutput = getOutputAsStringArray();
 156
 157         // then
 158         checkBasicInformation(consoleOutput);
 159         assertEquals("", consoleOutput[8]);
 160     }
 161
 162     @Test
 163     public void testGenerateCsarWithBadService() {
 164         // given
 165         graphVertex.setUniqueId(UNIQUE_ID);
 166         criteria.add(graphVertex);
 167
 168         service.put(GraphPropertyEnum.UUID, UUID);
 169         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 170         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 171         graphVertex.setMetadataProperties(service);
 172
 173         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 174             .thenReturn(Either.left(criteria));
 175         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 176             .thenReturn(Either.right(StorageOperationStatus.MATCH_NOT_FOUND));
 177
 178         // when
 179         test.generateCsar(UUID, scanner);
 180         String[] consoleOutput = getOutputAsStringArray();
 181
 182         // then
 183         checkBasicInformation(consoleOutput);
 184         assertEquals("Failed to fetch certified service with UUID " + UUID, consoleOutput[8]);
 185         assertEquals("", consoleOutput[9]);
 186     }
 187
 188     @Test
 189     public void testGenerateCsarWithNoCertifiedUUI() {
 190         // given
 191         service.put(GraphPropertyEnum.UUID, UUID);
 192         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 193         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 194
 195         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 196             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 197
 198         // when
 199         test.generateCsar(UUID, scanner);
 200         String[] consoleOutput = getOutputAsStringArray();
 201
 202         // then
 203         assertEquals("No certified service with UUID " + UUID, consoleOutput[0]);
 204         assertEquals("", consoleOutput[1]);
 205     }
 206
 207     @Test
 208     public void testFullFlow() {
 209         // given
 210         graphVertex.setUniqueId(UNIQUE_ID);
 211         criteria.add(graphVertex);
 212
 213         service.put(GraphPropertyEnum.UUID, UUID);
 214         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 215         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 216         graphVertex.setMetadataProperties(service);
 217
 218         when(toscaTemplate.getArtifactLabel()).thenReturn(TEMPLATE_LABEL);
 219         when(toscaTemplate.getPayloadData()).thenReturn(PAYLOAD.getBytes());
 220         when(toscaTemplate.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 221         toscaArtifact.put("toscaTemplate", toscaTemplate);
 222
 223         when(toscaCsar.getArtifactLabel()).thenReturn(CSAR_LABEL);
 224         when(toscaCsar.getPayloadData()).thenReturn(PAYLOAD.getBytes());
 225         when(toscaCsar.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_CSAR.getType());
 226         toscaArtifact.put("toscaCsar", toscaCsar);
 227
 228         when(component.getUniqueId()).thenReturn(UNIQUE_ID);
 229         when(component.getToscaArtifacts()).thenReturn(toscaArtifact);
 230
 231         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 232             .thenReturn(Either.left(criteria));
 233         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 234             .thenReturn(Either.left(component));
 235         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.TOSCA_ARTIFACTS,
 236             JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(graphVertex));
 237
 238         when(toscaRepresentation.getMainYaml()).thenReturn(PAYLOAD);
 239         when(toscaExportHandler.exportComponent(component))
 240             .thenReturn(Either.left(toscaRepresentation));
 241
 242         when(csarUtils.createCsar(component, true, true))
 243             .thenReturn(Either.left(PAYLOAD.getBytes()));
 244
 245         // when
 246         test.generateCsar(UUID, scanner);
 247         String[] consoleOutput = getOutputAsStringArray();
 248
 249         // then
 250         checkBasicInformation(consoleOutput);
 251         assertEquals("create artifact  success " + TEMPLATE_LABEL, consoleOutput[8]);
 252         assertEquals("create artifact unique id " + UNIQUE_ID + "." + TEMPLATE_LABEL,
 253             consoleOutput[9]);
 254         assertEquals("Artifact generated and saved into Cassandra " + TEMPLATE_LABEL,
 255             consoleOutput[10]);
 256
 257         assertEquals("create artifact  success " + CSAR_LABEL, consoleOutput[11]);
 258         assertEquals("create artifact unique id " + UNIQUE_ID + "." + CSAR_LABEL,
 259             consoleOutput[12]);
 260         assertEquals("Artifact generated and saved into Cassandra " + CSAR_LABEL,
 261             consoleOutput[13]);
 262         assertEquals("", consoleOutput[14]);
 263     }
 264
 265     @Test
 266     public void testFullFlowWithBadPayload() {
 267         // given
 268         graphVertex.setUniqueId(UNIQUE_ID);
 269         criteria.add(graphVertex);
 270
 271         service.put(GraphPropertyEnum.UUID, UUID);
 272         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 273         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 274         graphVertex.setMetadataProperties(service);
 275
 276         when(toscaTemplate.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 277         toscaArtifact.put("toscaTemplate", toscaTemplate);
 278
 279         when(toscaCsar.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_CSAR.getType());
 280         toscaArtifact.put("toscaCsar", toscaCsar);
 281
 282         when(component.getToscaArtifacts()).thenReturn(toscaArtifact);
 283
 284         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 285             .thenReturn(Either.left(criteria));
 286         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 287             .thenReturn(Either.left(component));
 288         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.TOSCA_ARTIFACTS,
 289             JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(graphVertex));
 290
 291         when(toscaExportHandler.exportComponent(component)).thenReturn(Either.right(null));
 292         when(csarUtils.createCsar(component, true, true)).thenReturn(Either.right(null));
 293
 294         // when
 295         test.generateCsar(UUID, scanner);
 296         String[] consoleOutput = getOutputAsStringArray();
 297
 298         // then
 299         checkBasicInformation(consoleOutput);
 300         assertEquals("create artifact failed ", consoleOutput[8]);
 301         assertEquals("create artifact failed ", consoleOutput[9]);
 302         assertEquals("", consoleOutput[10]);
 303     }
 304
 305     private void checkBasicInformation(String[] consoleOutput) {
 306         assertEquals("component from type\t" + ComponentTypeEnum.SERVICE.name(), consoleOutput[0]);
 307         assertEquals("component name", consoleOutput[1]);
 308         assertEquals("component version", consoleOutput[2]);
 309         assertEquals("component state\t" + LifecycleStateEnum.CERTIFIED.name(), consoleOutput[3]);
 310         assertEquals("component is highest", consoleOutput[4]);
 311         assertEquals("component is archived", consoleOutput[5]);
 312         assertEquals("", consoleOutput[6]);
 313         assertEquals("Generate CSAR (yes/no)?", consoleOutput[7]);
 314     }
 315
 316     private String[] getOutputAsStringArray() {
 317         return outContent.toString()
 318                 .replace("\t\t\n", "\n")
 319                 .replace("\t\n", "\n")
 320                 .replace("\t\t", "\t")
 321                 .replace("\t\r", "")
 322                 .replace("\r", "")
 323                 .split("\n", -1);
 324     }
 325
 326     private static void initConfigurationManager() {
 327         String confPath = new File(Objects
 328             .requireNonNull(
 329                 CsarGenerator.class.getClassLoader().getResource("config/configuration.yaml"))
 330             .getFile()).getParent();
 331         ConfigurationSource confSource =
 332             new FSConfigurationSource(ExternalConfiguration.getChangeListener(), confPath);
 333         new ConfigurationManager(confSource);
 334     }
 335 }