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     private static final String ANSWER = "yes";
  99     private static final String UUID = "123";
 100     private static final String UNIQUE_ID = "321";
 101     private static final String PAYLOAD = "testPayload";
 102     private static final String TEMPLATE_LABEL = "TEMPLATE_LABEL";
 103     private static final String CSAR_LABEL = "CSAR_LABEL";
 104
 105     private PrintStream systemOut;
 106     private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 107     private final ByteArrayInputStream inContent = new ByteArrayInputStream(ANSWER.getBytes());
 108
 109     private final Map<GraphPropertyEnum, Object> service = new EnumMap<>(GraphPropertyEnum.class);
 110     private final Map<String, ArtifactDefinition> toscaArtifact = new HashMap<>();
 111
 112     private final Scanner scanner = new Scanner(inContent);
 113     private final List<GraphVertex> criteria = new ArrayList<>();
 114     private final GraphVertex graphVertex = new GraphVertex();
 115
 116     @BeforeClass
 117     public static void setup() {
 118         initConfigurationManager();
 119     }
 120
 121     @Before
 122     public void setupSystemOut() {
 123         systemOut = System.out;
 124         System.setOut(new PrintStream(outContent));
 125     }
 126
 127     @After
 128     public void revertSystemOut() {
 129         System.setOut(systemOut);
 130     }
 131
 132     @Test
 133     public void testGenerateCsar() {
 134         // given
 135         graphVertex.setUniqueId(UNIQUE_ID);
 136         criteria.add(graphVertex);
 137
 138         service.put(GraphPropertyEnum.UUID, UUID);
 139         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 140         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 141         graphVertex.setMetadataProperties(service);
 142
 143         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 144             .thenReturn(Either.left(criteria));
 145         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 146             .thenReturn(Either.left(component));
 147         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.TOSCA_ARTIFACTS,
 148             JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(graphVertex));
 149
 150         // when
 151         test.generateCsar(UUID, scanner);
 152         String[] consoleOutput = getOutputAsStringArray();
 153
 154         // then
 155         checkBasicInformation(consoleOutput);
 156         assertEquals("", consoleOutput[8]);
 157     }
 158
 159     @Test
 160     public void testGenerateCsarWithBadService() {
 161         // given
 162         graphVertex.setUniqueId(UNIQUE_ID);
 163         criteria.add(graphVertex);
 164
 165         service.put(GraphPropertyEnum.UUID, UUID);
 166         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 167         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 168         graphVertex.setMetadataProperties(service);
 169
 170         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 171             .thenReturn(Either.left(criteria));
 172         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 173             .thenReturn(Either.right(StorageOperationStatus.MATCH_NOT_FOUND));
 174
 175         // when
 176         test.generateCsar(UUID, scanner);
 177         String[] consoleOutput = getOutputAsStringArray();
 178
 179         // then
 180         checkBasicInformation(consoleOutput);
 181         assertEquals("Failed to fetch certified service with UUID " + UUID, consoleOutput[8]);
 182         assertEquals("", consoleOutput[9]);
 183     }
 184
 185     @Test
 186     public void testGenerateCsarWithNoCertifiedUUI() {
 187         // given
 188         service.put(GraphPropertyEnum.UUID, UUID);
 189         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 190         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 191
 192         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 193             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 194
 195         // when
 196         test.generateCsar(UUID, scanner);
 197         String[] consoleOutput = getOutputAsStringArray();
 198
 199         // then
 200         assertEquals("No certified service with UUID " + UUID, consoleOutput[0]);
 201         assertEquals("", consoleOutput[1]);
 202     }
 203
 204     @Test
 205     public void testFullFlow() {
 206         // given
 207         graphVertex.setUniqueId(UNIQUE_ID);
 208         criteria.add(graphVertex);
 209
 210         service.put(GraphPropertyEnum.UUID, UUID);
 211         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 212         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 213         graphVertex.setMetadataProperties(service);
 214
 215         when(toscaTemplate.getArtifactLabel()).thenReturn(TEMPLATE_LABEL);
 216         when(toscaTemplate.getPayloadData()).thenReturn(PAYLOAD.getBytes());
 217         when(toscaTemplate.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 218         toscaArtifact.put("toscaTemplate", toscaTemplate);
 219
 220         when(toscaCsar.getArtifactLabel()).thenReturn(CSAR_LABEL);
 221         when(toscaCsar.getPayloadData()).thenReturn(PAYLOAD.getBytes());
 222         when(toscaCsar.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_CSAR.getType());
 223         toscaArtifact.put("toscaCsar", toscaCsar);
 224
 225         when(component.getUniqueId()).thenReturn(UNIQUE_ID);
 226         when(component.getToscaArtifacts()).thenReturn(toscaArtifact);
 227
 228         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 229             .thenReturn(Either.left(criteria));
 230         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 231             .thenReturn(Either.left(component));
 232         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.TOSCA_ARTIFACTS,
 233             JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(graphVertex));
 234
 235         when(toscaExportHandler.exportComponent(component))
 236             .thenReturn(Either.left(ToscaRepresentation.make(PAYLOAD.getBytes())));
 237
 238         when(csarUtils.createCsar(component, true, true))
 239             .thenReturn(Either.left(PAYLOAD.getBytes()));
 240
 241         // when
 242         test.generateCsar(UUID, scanner);
 243         String[] consoleOutput = getOutputAsStringArray();
 244
 245         // then
 246         checkBasicInformation(consoleOutput);
 247         assertEquals("create artifact  success " + TEMPLATE_LABEL, consoleOutput[8]);
 248         assertEquals("create artifact unique id " + UNIQUE_ID + "." + TEMPLATE_LABEL,
 249             consoleOutput[9]);
 250         assertEquals("Artifact generated and saved into Cassandra " + TEMPLATE_LABEL,
 251             consoleOutput[10]);
 252
 253         assertEquals("create artifact  success " + CSAR_LABEL, consoleOutput[11]);
 254         assertEquals("create artifact unique id " + UNIQUE_ID + "." + CSAR_LABEL,
 255             consoleOutput[12]);
 256         assertEquals("Artifact generated and saved into Cassandra " + CSAR_LABEL,
 257             consoleOutput[13]);
 258         assertEquals("", consoleOutput[14]);
 259     }
 260
 261     @Test
 262     public void testFullFlowWithBadPayload() {
 263         // given
 264         graphVertex.setUniqueId(UNIQUE_ID);
 265         criteria.add(graphVertex);
 266
 267         service.put(GraphPropertyEnum.UUID, UUID);
 268         service.put(GraphPropertyEnum.STATE, LifecycleStateEnum.CERTIFIED.name());
 269         service.put(GraphPropertyEnum.COMPONENT_TYPE, ComponentTypeEnum.SERVICE.name());
 270         graphVertex.setMetadataProperties(service);
 271
 272         when(toscaTemplate.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_TEMPLATE.getType());
 273         toscaArtifact.put("toscaTemplate", toscaTemplate);
 274
 275         when(toscaCsar.getArtifactType()).thenReturn(ArtifactTypeEnum.TOSCA_CSAR.getType());
 276         toscaArtifact.put("toscaCsar", toscaCsar);
 277
 278         when(component.getToscaArtifacts()).thenReturn(toscaArtifact);
 279
 280         when(janusGraphDao.getByCriteria(VertexTypeEnum.TOPOLOGY_TEMPLATE, service))
 281             .thenReturn(Either.left(criteria));
 282         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 283             .thenReturn(Either.left(component));
 284         when(janusGraphDao.getChildVertex(graphVertex, EdgeLabelEnum.TOSCA_ARTIFACTS,
 285             JsonParseFlagEnum.ParseJson)).thenReturn(Either.left(graphVertex));
 286
 287         when(toscaExportHandler.exportComponent(component)).thenReturn(Either.right(null));
 288         when(csarUtils.createCsar(component, true, true)).thenReturn(Either.right(null));
 289
 290         // when
 291         test.generateCsar(UUID, scanner);
 292         String[] consoleOutput = getOutputAsStringArray();
 293
 294         // then
 295         checkBasicInformation(consoleOutput);
 296         assertEquals("create artifact failed ", consoleOutput[8]);
 297         assertEquals("create artifact failed ", consoleOutput[9]);
 298         assertEquals("", consoleOutput[10]);
 299     }
 300
 301     private void checkBasicInformation(String[] consoleOutput) {
 302         assertEquals("component from type\t" + ComponentTypeEnum.SERVICE.name(), consoleOutput[0]);
 303         assertEquals("component name", consoleOutput[1]);
 304         assertEquals("component version", consoleOutput[2]);
 305         assertEquals("component state\t" + LifecycleStateEnum.CERTIFIED.name(), consoleOutput[3]);
 306         assertEquals("component is highest", consoleOutput[4]);
 307         assertEquals("component is archived", consoleOutput[5]);
 308         assertEquals("", consoleOutput[6]);
 309         assertEquals("Generate CSAR (yes/no)?", consoleOutput[7]);
 310     }
 311
 312     private String[] getOutputAsStringArray() {
 313         return outContent.toString()
 314                 .replace("\t\t\n", "\n")
 315                 .replace("\t\n", "\n")
 316                 .replace("\t\t", "\t")
 317                 .replace("\t\r", "")
 318                 .replace("\r", "")
 319                 .split("\n", -1);
 320     }
 321
 322     private static void initConfigurationManager() {
 323         String confPath = new File(Objects
 324             .requireNonNull(
 325                 CsarGenerator.class.getClassLoader().getResource("config/configuration.yaml"))
 326             .getFile()).getParent();
 327         ConfigurationSource confSource =
 328             new FSConfigurationSource(ExternalConfiguration.getChangeListener(), confPath);
 329         new ConfigurationManager(confSource);
 330     }
 331 }