openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/orchestration/csar/validation/SOL004MetaDirectoryValidatorTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 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.vendorsoftwareproduct.impl.orchestration.csar.validation;
  22
  23 import static org.hamcrest.MatcherAssert.assertThat;
  24 import static org.hamcrest.Matchers.containsInAnyOrder;
  25 import static org.hamcrest.Matchers.hasSize;
  26 import static org.hamcrest.Matchers.is;
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertSame;
  29 import static org.junit.Assert.assertTrue;
  30 import static org.mockito.ArgumentMatchers.any;
  31 import static org.mockito.Mockito.mock;
  32 import static org.mockito.Mockito.when;
  33 import static org.openecomp.sdc.be.config.NonManoArtifactType.ONAP_PM_DICTIONARY;
  34 import static org.openecomp.sdc.be.config.NonManoArtifactType.ONAP_SW_INFORMATION;
  35 import static org.openecomp.sdc.be.config.NonManoArtifactType.ONAP_VES_EVENTS;
  36 import static org.openecomp.sdc.be.test.util.TestResourcesHandler.getResourceBytesOrFail;
  37 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.ATTRIBUTE_VALUE_SEPARATOR;
  38 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_ARCHIVE_VERSION;
  39 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_NAME;
  40 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.PNFD_RELEASE_DATE_TIME;
  41 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_PACKAGE_VERSION;
  42 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_PRODUCT_NAME;
  43 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_PROVIDER_ID;
  44 import static org.openecomp.sdc.tosca.csar.ManifestTokenType.VNF_RELEASE_DATE_TIME;
  45 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.CREATED_BY_ENTRY;
  46 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.CSAR_VERSION_ENTRY;
  47 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ENTRY_DEFINITIONS;
  48 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ENTRY_EVENTS;
  49 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_CERTIFICATE;
  50 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_CHANGE_LOG;
  51 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_LICENSES;
  52 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_MANIFEST;
  53 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.ETSI_ENTRY_TESTS;
  54 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.TOSCA_META_FILE_VERSION_ENTRY;
  55 import static org.openecomp.sdc.tosca.csar.ToscaMetaEntry.TOSCA_META_PATH_FILE_NAME;
  56 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.EMPTY_YAML_FILE_PATH;
  57 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.INVALID_YAML_FILE_PATH;
  58 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_DEFINITION_FILE_PATH;
  59 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_DEFINITION_IMPORT_FILE_PATH;
  60 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.SAMPLE_SOURCE;
  61 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_CHANGELOG_FILEPATH;
  62 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_DEFINITION_FILEPATH;
  63 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.TOSCA_MANIFEST_FILEPATH;
  64
  65 import java.nio.charset.StandardCharsets;
  66 import java.util.ArrayList;
  67 import java.util.Collections;
  68 import java.util.List;
  69 import java.util.Map;
  70 import java.util.stream.Collectors;
  71 import java.util.stream.Stream;
  72 import org.apache.commons.collections.CollectionUtils;
  73 import org.junit.Before;
  74 import org.junit.Test;
  75 import org.openecomp.sdc.common.errors.Messages;
  76 import org.openecomp.sdc.common.utils.SdcCommon;
  77 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  78 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  79 import org.openecomp.sdc.tosca.csar.ManifestTokenType;
  80 import org.openecomp.sdc.tosca.csar.ToscaMetaEntry;
  81 import org.openecomp.sdc.vendorsoftwareproduct.impl.onboarding.OnboardingPackageContentHandler;
  82 import org.openecomp.sdc.vendorsoftwareproduct.security.SecurityManager;
  83 import org.openecomp.sdc.vendorsoftwareproduct.security.SecurityManagerException;
  84
  85 public class SOL004MetaDirectoryValidatorTest {
  86
  87     private SOL004MetaDirectoryValidator sol004MetaDirectoryValidator;
  88     private OnboardingPackageContentHandler handler;
  89     private StringBuilder metaFileBuilder;
  90
  91     @Before
  92     public void setUp() {
  93         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator();
  94         handler = new OnboardingPackageContentHandler();
  95         metaFileBuilder = new StringBuilder()
  96             .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
  97                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
  98             .append(CSAR_VERSION_ENTRY.getName())
  99                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 100             .append(CREATED_BY_ENTRY.getName())
 101                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 102             .append(ENTRY_DEFINITIONS.getName())
 103                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 104             .append(ETSI_ENTRY_MANIFEST.getName())
 105                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_MANIFEST_FILEPATH).append("\n")
 106             .append(ETSI_ENTRY_CHANGE_LOG.getName())
 107                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 108     }
 109
 110     @Test
 111     public void testGivenTOSCAMetaFile_whenEntryHasNoValue_thenErrorIsReturned() {
 112         final String metaFileWithInvalidEntry = "TOSCA-Meta-File-Version: \n" +
 113                 "Entry-Definitions: " + TOSCA_DEFINITION_FILEPATH;
 114
 115         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileWithInvalidEntry.getBytes(StandardCharsets.UTF_8));
 116         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 117
 118         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 119         assertExpectedErrors("TOSCA Meta file with no entries", errors, 1);
 120     }
 121
 122     @Test
 123     public void testGivenTOSCAMeta_withAllSupportedEntries_thenNoErrorsReturned() {
 124
 125         final String entryTestFilePath = "Files/Tests";
 126         final String entryLicenseFilePath = "Files/Licenses";
 127
 128         handler.addFolder("Files/Tests/");
 129         handler.addFolder("Files/Licenses/");
 130         metaFileBuilder
 131             .append(ETSI_ENTRY_TESTS.getName())
 132                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(entryTestFilePath).append("\n")
 133             .append(ETSI_ENTRY_LICENSES.getName())
 134                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(entryLicenseFilePath).append("\n");
 135
 136         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 137         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 138         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 139
 140         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 141         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 142         handler.addFile(entryTestFilePath, "".getBytes());
 143         handler.addFile(entryLicenseFilePath, "".getBytes());
 144
 145         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 146             .withSource(TOSCA_META_PATH_FILE_NAME.getName())
 147             .withSource(TOSCA_DEFINITION_FILEPATH)
 148             .withSource(TOSCA_CHANGELOG_FILEPATH)
 149             .withSource(TOSCA_MANIFEST_FILEPATH).withSource(SAMPLE_SOURCE)
 150             .withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH)
 151             .withSource(entryTestFilePath)
 152             .withSource(entryLicenseFilePath);
 153
 154         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 155
 156         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 157         assertEquals(0, errors.size());
 158     }
 159
 160     @Test
 161     public void testGivenTOSCAMeta_withUnsupportedEntry_thenWarningIsReturned() {
 162         metaFileBuilder = new StringBuilder()
 163             .append(ENTRY_EVENTS.getName())
 164                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken())
 165                 .append(" Definitions/events.log");
 166
 167         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 168         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 169         List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 170         assertTrue(errors.size() == 1 && errorMessages.size() == 1);
 171         assertSame(ErrorLevel.ERROR, errorMessages.get(0).getLevel());
 172     }
 173
 174     /**
 175      * Tests if the meta file contains invalid versions in TOSCA-Meta-File-Version and CSAR-Version attributes.
 176      */
 177     @Test
 178     public void testGivenTOSCAMetaFile_withInvalidTOSCAMetaFileVersionAndCSARVersion_thenErrorIsReturned() {
 179         final StringBuilder metaFileBuilder = new StringBuilder()
 180             .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 181                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(Integer.MAX_VALUE).append("\n")
 182             .append(CSAR_VERSION_ENTRY.getName())
 183                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(Integer.MAX_VALUE).append("\n")
 184             .append(CREATED_BY_ENTRY.getName())
 185                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 186             .append(ENTRY_DEFINITIONS.getName())
 187                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 188             .append(ETSI_ENTRY_MANIFEST.getName())
 189                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_MANIFEST_FILEPATH).append("\n")
 190             .append(ETSI_ENTRY_CHANGE_LOG.getName())
 191                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH);
 192         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 193
 194         handler.addFile(ToscaMetaEntry.TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 195         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 196
 197         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 198         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 199
 200         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 201         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 202
 203         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 204         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 205
 206         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 207         assertExpectedErrors("Invalid TOSCA-Meta-File-Version and CSAR-Version attributes", errors, 2);
 208     }
 209
 210     @Test
 211     public void testGivenTOSCAMetaFile_withNonExistentFileReferenced_thenErrorsReturned() {
 212         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 213
 214         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 215         assertThat("Total of errors should be as expected", errors.size(), is(1));
 216         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 217         assertThat("Total of errors messages should be as expected", errorMessages.size(), is(3));
 218     }
 219
 220
 221     @Test
 222     public void testGivenDefinitionFile_whenValidImportStatementExist_thenNoErrorsReturned() {
 223         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 224
 225         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 226         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 227
 228         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 229         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 230
 231         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 232         manifestBuilder.withSource(SAMPLE_SOURCE);
 233
 234         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml",
 235             getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 236         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 237
 238         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithValidImports.yaml";
 239         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 240         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 241
 242         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 243         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 244
 245         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 246         assertEquals(0, errors.size());
 247     }
 248
 249     @Test
 250     public void testGivenDefinitionFile_whenMultipleDefinitionsImportStatementExist_thenNoErrorsReturned() {
 251         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 252
 253         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 254         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 255
 256         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 257         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 258
 259         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 260         manifestBuilder.withSource(SAMPLE_SOURCE);
 261
 262         final byte [] sampleDefinitionFile1 =
 263             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile1.yaml");
 264         handler.addFile(TOSCA_DEFINITION_FILEPATH, sampleDefinitionFile1);
 265         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 266
 267         final byte [] sampleDefinitionFile2 =
 268             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml");
 269         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", sampleDefinitionFile2);
 270         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 271
 272         final byte [] sampleDefinitionFile3 =
 273             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile1.yaml");
 274         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile3);
 275         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 276
 277         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 278         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 279
 280         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 281         assertEquals(0, errors.size());
 282     }
 283
 284     @Test
 285     public void testGivenDefinitionFile_whenInvalidImportStatementExist_thenErrorIsReturned() {
 286         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 287
 288         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 289         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 290
 291         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 292         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 293
 294         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 295         manifestBuilder.withSource(SAMPLE_SOURCE);
 296
 297         final String definitionFileWithInvalidImports =
 298             "validation.files/definition/definitionFileWithInvalidImport.yaml";
 299         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithInvalidImports));
 300         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 301
 302         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 303         String manifest = manifestBuilder.build();
 304         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifest.getBytes(StandardCharsets.UTF_8));
 305
 306         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 307         assertExpectedErrors("", errors, 1);
 308     }
 309
 310     /**
 311      * Manifest referenced import file missing
 312      */
 313     @Test
 314     public void testGivenDefinitionFile_whenReferencedImportDoesNotExist_thenErrorIsReturned() {
 315         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 316
 317         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 318         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 319
 320         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 321         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 322
 323         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 324         manifestBuilder.withSource(SAMPLE_SOURCE);
 325
 326         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", "".getBytes());
 327         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 328
 329         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 330         handler.addFile(TOSCA_DEFINITION_FILEPATH,
 331             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 332
 333         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 334         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 335
 336         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 337         assertExpectedErrors("Manifest referenced import file missing", errors, 1);
 338     }
 339
 340     /**
 341      * Reference with invalid YAML format.
 342      */
 343     @Test
 344     public void testGivenDefinitionFile_withInvalidYAML_thenErrorIsReturned() {
 345         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 346
 347         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 348         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 349
 350         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 351         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 352
 353         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 354         manifestBuilder.withSource(SAMPLE_SOURCE);
 355
 356         final String definitionFileWithInvalidYAML = "validation.files/definition/invalidDefinitionFile.yaml";
 357         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithInvalidYAML));
 358         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 359
 360         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 361         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 362
 363         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 364         assertExpectedErrors("Reference with invalid YAML format", errors, 1);
 365     }
 366
 367     @Test
 368     public void testGivenManifestFile_withValidSourceAndNonManoSources_thenNoErrorIsReturned() {
 369         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 370
 371         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 372         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 373
 374         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 375         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 376
 377         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 378         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 379
 380         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 381         manifestBuilder.withSource(SAMPLE_SOURCE);
 382
 383         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 384         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 385
 386         final String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 387         handler.addFile(nonManoSource, getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 388         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 389
 390         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 391         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 392
 393         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 394         assertEquals(0, errors.size());
 395     }
 396
 397     /**
 398      * Manifest with non existent source files should return error.
 399      */
 400     @Test
 401     public void testGivenManifestFile_withNonExistentSourceFile_thenErrorIsReturned() {
 402         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 403         //non existent reference
 404         manifestBuilder.withSource("Artifacts/Deployment/Events/RadioNode_pnf_v1.yaml");
 405
 406         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 407         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 408
 409         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 410         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 411
 412         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 413         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 414
 415         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 416         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 417
 418         String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 419         handler.addFile(nonManoSource, getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 420         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 421
 422         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 423         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 424
 425         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 426         assertExpectedErrors("Manifest with non existent source files", errors, 1);
 427     }
 428
 429     /**
 430      * Tests the validation for a TOSCA Manifest with invalid data.
 431      */
 432     @Test
 433     public void testGivenManifestFile_withInvalidData_thenErrorIsReturned() {
 434         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 435         handler.addFile(TOSCA_MANIFEST_FILEPATH, getResourceBytesOrFail("validation.files/manifest/invalidManifest.mf"));
 436         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 437         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 438         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 439
 440         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 441         assertExpectedErrors("TOSCA manifest with invalid data", errors, 1);
 442     }
 443
 444     @Test
 445     public void testGivenManifestAndDefinitionFile_withSameNames_thenNoErrorReturned()  {
 446         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 447
 448         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 449         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 450
 451         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 452         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 453
 454         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 455         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 456
 457         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 458         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 459
 460         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 461         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 462
 463         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 464         assertEquals(0, errors.size());
 465     }
 466
 467     /**
 468      * Main TOSCA definitions file and Manifest file with different name should return error.
 469      */
 470     @Test
 471     public void testGivenManifestAndMainDefinitionFile_withDifferentNames_thenErrorIsReturned() {
 472         metaFileBuilder = new StringBuilder()
 473             .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 474                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 475             .append(CSAR_VERSION_ENTRY.getName())
 476                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 477             .append(CREATED_BY_ENTRY.getName())
 478                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 479             .append(ENTRY_DEFINITIONS.getName())
 480                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 481             .append(ETSI_ENTRY_MANIFEST.getName())
 482                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Definitions/MainServiceTemplate2.mf\n")
 483             .append(ETSI_ENTRY_CHANGE_LOG.getName())
 484                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 485
 486         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 487
 488         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 489         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 490
 491         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 492         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 493
 494         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 495         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 496
 497         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 498         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 499
 500         manifestBuilder.withSource("Definitions/MainServiceTemplate2.mf");
 501         handler.addFile("Definitions/MainServiceTemplate2.mf", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 502
 503         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 504         assertExpectedErrors("Main TOSCA definitions file and Manifest file with different name should return error",
 505                errors, 1);
 506     }
 507
 508     @Test
 509     public void testGivenManifestFile_withDifferentExtension_thenErrorIsReturned() {
 510         metaFileBuilder = new StringBuilder()
 511             .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 512                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 513             .append(CSAR_VERSION_ENTRY.getName())
 514                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 515             .append(CREATED_BY_ENTRY.getName())
 516                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 517             .append(ENTRY_DEFINITIONS.getName())
 518                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 519             .append(ETSI_ENTRY_MANIFEST.getName())
 520                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Definitions/MainServiceTemplate.txt\n")
 521             .append(ETSI_ENTRY_CHANGE_LOG.getName())
 522                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 523
 524         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 525
 526         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 527         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 528
 529         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 530         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 531
 532         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 533         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 534
 535         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 536         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 537
 538         manifestBuilder.withSource("Definitions/MainServiceTemplate.txt");
 539         handler.addFile("Definitions/MainServiceTemplate.txt", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 540
 541         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 542         assertExpectedErrors("Manifest file with different extension than .mf should return error",
 543                 errors, 1);
 544     }
 545
 546     @Test
 547     public void testGivenManifestFile_withValidVnfMetadata_thenNoErrorsReturned() {
 548         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 549
 550         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 551         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 552         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 553         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 554         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 555         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 556
 557         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 558         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 559
 560         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 561         assertExpectedErrors("Manifest with valid vnf mandatory values should not return any errors", errors, 0);
 562     }
 563
 564     @Test
 565     public void testGivenManifestFile_withValidPnfMetadata_thenNoErrorsReturned() {
 566         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 567
 568         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 569         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 570
 571         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 572         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 573
 574         manifestBuilder.withSignedSource(TOSCA_DEFINITION_FILEPATH
 575             , "SHA-abc", "09e5a788acb180162c51679ae4c998039fa6644505db2415e35107d1ee213943");
 576         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 577
 578         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 579         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 580
 581         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 582         assertExpectedErrors("Manifest with valid pnf mandatory values should not return any errors", errors, 0);
 583     }
 584
 585     /**
 586      * Manifest with mixed metadata should return error.
 587      */
 588     @Test
 589     public void testGivenManifestFile_withMetadataContainingMixedPnfVnfMetadata_thenErrorIsReturned() {
 590         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 591             .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 592             .withMetaData(VNF_PROVIDER_ID.getToken(), "Bilal Iqbal")
 593             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 594             .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 595
 596         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 597         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 598         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 599         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 600         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 601         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 602
 603         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 604         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 605
 606         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 607         assertExpectedErrors("Manifest with mixed metadata should return error", errors, 1);
 608     }
 609
 610
 611     @Test
 612     public void testGivenManifestFile_withMetadataMissingPnfOrVnfMandatoryEntries_thenErrorIsReturned() {
 613         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 614             .withMetaData("invalid_product_name", "RadioNode")
 615             .withMetaData("invalid_provider_id", "Bilal Iqbal")
 616             .withMetaData("invalid_package_version", "1.0")
 617             .withMetaData("invalid_release_date_time", "2019-12-14T11:25:00+00:00");
 618
 619         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 620         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 621
 622         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 623         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 624
 625         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 626         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 627
 628         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 629         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 630
 631         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 632         assertExpectedErrors("Manifest with missing vnf or pnf mandatory entries should return error", errors, 1);
 633     }
 634
 635     @Test
 636     public void testGivenManifestFile_withMetadataMissingMandatoryPnfEntries_thenErrorIsReturned() {
 637         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 638
 639         manifestBuilder.withMetaData(PNFD_NAME.getToken(), "RadioNode");
 640         manifestBuilder.withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 641
 642         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 643         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 644
 645         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 646         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 647
 648         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 649         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 650
 651         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 652         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 653
 654         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 655         assertExpectedErrors("Manifest with metadata missing pnf mandatory entries should return error", errors, 1);
 656
 657     }
 658
 659     @Test
 660     public void testGivenManifestFile_withMetadataMissingMandatoryVnfEntries_thenErrorIsReturned() {
 661         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 662
 663         manifestBuilder.withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode");
 664
 665         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 666         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 667
 668         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 669         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 670
 671         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 672         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 673
 674         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 675         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 676
 677         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 678         assertExpectedErrors("Manifest with metadata missing vnf mandatory entries should return error", errors, 1);
 679
 680     }
 681
 682     /**
 683      * Manifest with more than 4 metadata entries should return error.
 684      */
 685     @Test
 686     public void testGivenManifestFile_withMetadataEntriesExceedingTheLimit_thenErrorIsReturned() {
 687         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 688             .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 689             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "Bilal Iqbal")
 690             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 691             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 692
 693         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 694         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 695
 696         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 697         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 698
 699         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 700         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 701
 702         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 703         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 704
 705         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 706         assertExpectedErrors("Manifest with more than 4 metadata entries should return error", errors, 1);
 707     }
 708
 709     @Test
 710     public void testGivenManifestFile_withPnfMetadataAndVfEntries_thenErrorIsReturned() {
 711         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 712         metaFileBuilder
 713             .append(ETSI_ENTRY_TESTS.getName())
 714                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Files/Tests").append("\n")
 715             .append(ETSI_ENTRY_LICENSES.getName())
 716                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Files/Licenses");
 717
 718         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 719         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 720
 721         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 722         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 723
 724         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 725         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 726
 727         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 728         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 729         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 730         assertExpectedErrors("Tosca.meta should not have entries applicable only to VF", errors, 2);
 731
 732     }
 733
 734     /**
 735      * Tests an imported descriptor with a missing imported file.
 736      */
 737     @Test
 738     public void testGivenDefinitionFileWithImportedDescriptor_whenImportedDescriptorImportsMissingFile_thenMissingImportErrorOccur() {
 739         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 740
 741         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 742         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 743
 744         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 745         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 746
 747         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 748         manifestBuilder.withSource(SAMPLE_SOURCE);
 749
 750         final String definitionImportOne = "Definitions/importOne.yaml";
 751         handler.addFile(definitionImportOne,
 752             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 753         manifestBuilder.withSource(definitionImportOne);
 754
 755         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithOneImport.yaml";
 756         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 757         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 758
 759         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 760         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 761
 762         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 763
 764         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 765         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 766             , Messages.MISSING_IMPORT_FILE.formatMessage("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml"))
 767         );
 768
 769         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 770     }
 771
 772     /**
 773      * Tests an imported descriptor with invalid import statement.
 774      */
 775     @Test
 776     public void testGivenDefinitionFileWithImportedDescriptor_whenInvalidImportStatementExistInImportedDescriptor_thenInvalidImportErrorOccur() {
 777         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 778
 779         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 780         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 781
 782         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 783         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 784
 785         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 786         manifestBuilder.withSource(SAMPLE_SOURCE);
 787
 788         final String definitionImportOne = "Definitions/importOne.yaml";
 789         handler.addFile(definitionImportOne,
 790             getResourceBytesOrFail("validation.files/definition/definitionFileWithInvalidImport.yaml"));
 791         manifestBuilder.withSource(definitionImportOne);
 792
 793         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithOneImport.yaml";
 794         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 795         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 796
 797         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 798         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 799
 800         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 801
 802         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 803         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 804             , Messages.INVALID_IMPORT_STATEMENT.formatMessage(definitionImportOne, "null"))
 805         );
 806
 807         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 808     }
 809
 810     @Test
 811     public void givenManifestWithNonManoPmAndVesArtifacts_whenNonManoArtifactsAreValid_thenNoErrorsOccur() {
 812         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 813
 814         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 815         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 816
 817         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 818         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 819
 820         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 821         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 822
 823         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 824         handler.addFile(nonManoPmEventsSource,
 825             getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 826         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 827
 828         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 829         handler.addFile(nonManoVesEventsSource,
 830             getResourceBytesOrFail("validation.files/events/vesEvents-valid.yaml"));
 831         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 832
 833         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 834         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 835
 836         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 837             .validateContent(handler);
 838
 839         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
 840     }
 841
 842     @Test
 843     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreInvalid_thenInvalidYamlErrorOccur() {
 844         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 845
 846         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 847         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 848
 849         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 850         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 851
 852         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 853         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 854
 855         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 856         handler.addFile(nonManoPmEventsSource, getResourceBytesOrFail(INVALID_YAML_FILE_PATH));
 857         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 858
 859         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 860         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 861
 862         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 863         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 864             , Messages.INVALID_YAML_FORMAT_1.formatMessage(nonManoPmEventsSource, "while scanning a simple key\n"
 865             + " in 'reader', line 2, column 1:\n"
 866             + "    key {}\n"
 867             + "    ^\n"
 868             + "could not find expected ':'\n"
 869             + " in 'reader', line 2, column 7:\n"
 870             + "    {}\n"
 871             + "      ^\n"))
 872         );
 873
 874         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 875             .validateContent(handler);
 876
 877         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 878     }
 879
 880     @Test
 881     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreEmpty_thenEmptyYamlErrorOccur() {
 882         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 883
 884         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 885         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 886
 887         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 888         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 889
 890         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 891         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 892
 893         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 894         handler.addFile(nonManoPmEventsSource, getResourceBytesOrFail(EMPTY_YAML_FILE_PATH));
 895         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 896
 897         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 898         handler.addFile(nonManoVesEventsSource, getResourceBytesOrFail(EMPTY_YAML_FILE_PATH));
 899         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 900
 901         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 902         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 903
 904         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 905         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 906             , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoPmEventsSource))
 907         );
 908         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 909             , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoVesEventsSource))
 910         );
 911
 912         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 913             .validateContent(handler);
 914
 915         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 916     }
 917
 918     @Test
 919     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsHaveNotYamlExtension_thenInvalidYamlExtensionErrorOccur() {
 920         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 921
 922         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 923         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 924
 925         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 926         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 927
 928         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 929         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 930
 931         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.y1";
 932         handler.addFile(nonManoPmEventsSource, "".getBytes());
 933         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 934
 935         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.y2";
 936         handler.addFile(nonManoVesEventsSource, "".getBytes());
 937         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 938
 939         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 940         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 941
 942         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 943         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 944             , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoPmEventsSource))
 945         );
 946         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 947             , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoVesEventsSource))
 948         );
 949
 950         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 951             .validateContent(handler);
 952
 953         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 954     }
 955
 956     @Test
 957     public void givenPackageWithValidSoftwareInformationNonMano_whenThePackageIsValidated_thenNoErrorsAreReturned() {
 958         //given a package with software information non-mano artifact
 959         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 960         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-valid.yaml";
 961         handler.addFile(nonManoSoftwareInformationPath,
 962             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
 963         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
 964         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString()
 965             .getBytes(StandardCharsets.UTF_8));
 966         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 967         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 968         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 969         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 970         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 971
 972         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 973         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 974         //when package is validated
 975         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 976         //then no errors
 977         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
 978     }
 979
 980     @Test
 981     public void givenPackageWithUnparsableSwInformationNonMano_whenThePackageIsValidated_thenInvalidErrorIsReturned() {
 982         //given a package with unparsable software information non-mano artifact
 983         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 984         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-valid.yaml";
 985         handler.addFile(nonManoSoftwareInformationPath,
 986             getResourceBytesOrFail("validation.files/invalid.yaml"));
 987         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
 988         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString()
 989             .getBytes(StandardCharsets.UTF_8));
 990         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
 991         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 992         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 993         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 994         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 995
 996         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 997         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 998         //when package is validated
 999         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1000         //then invalid error returned
1001         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1002         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1003             , Messages.INVALID_SW_INFORMATION_NON_MANO_ERROR.formatMessage(nonManoSoftwareInformationPath))
1004         );
1005         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1006     }
1007
1008     @Test
1009     public void givenPackageWithIncorrectSwInformationNonMano_whenThePackageIsValidated_thenInvalidErrorIsReturned() {
1010         //given a package with incorrect software information non-mano artifact
1011         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1012         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-invalid.yaml";
1013         handler.addFile(nonManoSoftwareInformationPath,
1014             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-invalid.yaml"));
1015         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1016         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString()
1017             .getBytes(StandardCharsets.UTF_8));
1018         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
1019         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1020         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1021         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1022         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1023
1024         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1025         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1026         //when package is validated
1027         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1028         //then incorrect error returned
1029         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1030         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1031             , Messages.INCORRECT_SW_INFORMATION_NON_MANO_ERROR.formatMessage(nonManoSoftwareInformationPath))
1032         );
1033         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1034     }
1035
1036     @Test
1037     public void givenPackageWithTwoSoftwareInformationNonMano_whenThePackageIsValidated_thenUniqueErrorIsReturned() {
1038         //given a package with two software information non-mano artifacts
1039         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1040         final String nonManoSoftwareInformation1Path = "Artifacts/software-information/pnf-sw-information-valid1.yaml";
1041         handler.addFile(nonManoSoftwareInformation1Path,
1042             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1043         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformation1Path);
1044         final String nonManoSoftwareInformation2Path = "Artifacts/software-information/pnf-sw-information-valid2.yaml";
1045         handler.addFile(nonManoSoftwareInformation2Path,
1046             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1047         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformation2Path);
1048         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(), metaFileBuilder.toString()
1049             .getBytes(StandardCharsets.UTF_8));
1050         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
1051         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1052         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1053         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1054         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1055
1056         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1057         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1058         //when package is validated
1059         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1060         //then unique error returned
1061         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1062         final String errorFiles = Stream.of(nonManoSoftwareInformation1Path, nonManoSoftwareInformation2Path)
1063             .map(s -> String.format("'%s'", s))
1064             .collect(Collectors.joining(", "));
1065         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1066             , Messages.UNIQUE_SW_INFORMATION_NON_MANO_ERROR.formatMessage(errorFiles))
1067         );
1068         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1069     }
1070
1071     @Test
1072     public void signedPackage() throws SecurityManagerException {
1073         //given
1074         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1075         final String fakeArtifactPath = "Artifacts/aArtifact.yaml";
1076         final String fakeArtifactCmsPath = "Artifacts/aArtifact.cms";
1077         final String fakeCertificatePath = "certificate.cert";
1078         handler.addFile(fakeArtifactPath, new byte[0]);
1079         manifestBuilder.withSource(fakeArtifactPath);
1080         handler.addFile(fakeArtifactCmsPath, new byte[0]);
1081         manifestBuilder.withSource(fakeArtifactCmsPath);
1082         handler.addFile(fakeCertificatePath, new byte[0]);
1083         manifestBuilder.withSource(fakeCertificatePath);
1084         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1085         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1086         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1087         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1088
1089         metaFileBuilder.append(ETSI_ENTRY_CERTIFICATE.getName())
1090             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(fakeCertificatePath).append("\n");
1091         handler.addFile(TOSCA_META_PATH_FILE_NAME.getName(),
1092             metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
1093         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME.getName());
1094
1095         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1096         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1097
1098         final SecurityManager securityManagerMock = mock(SecurityManager.class);
1099         when(securityManagerMock.verifySignedData(any(), any(), any())).thenReturn(true);
1100         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator(securityManagerMock);
1101
1102         //when
1103         Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1104         //then
1105         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
1106
1107         //given
1108         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator(securityManagerMock);
1109         when(securityManagerMock.verifySignedData(any(), any(), any())).thenReturn(false);
1110
1111         //when
1112         actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1113
1114         //then
1115         List<ErrorMessage> expectedErrorList = new ArrayList<>();
1116         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1117             , Messages.ARTIFACT_INVALID_SIGNATURE.formatMessage(fakeArtifactCmsPath, fakeArtifactPath))
1118         );
1119         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1120
1121         //given
1122         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator(securityManagerMock);
1123         when(securityManagerMock.verifySignedData(any(), any(), any()))
1124             .thenThrow(new SecurityManagerException("SecurityManagerException"));
1125         //when
1126         actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1127
1128         //then
1129         expectedErrorList = new ArrayList<>();
1130         expectedErrorList.add(
1131             new ErrorMessage(ErrorLevel.ERROR,
1132                 Messages.ARTIFACT_SIGNATURE_VALIDATION_ERROR.formatMessage(fakeArtifactCmsPath,
1133                     fakeArtifactPath, fakeCertificatePath, "SecurityManagerException")
1134             )
1135         );
1136         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1137     }
1138
1139
1140
1141
1142     private void assertExpectedErrors(final String testCase, final Map<String, List<ErrorMessage>> errors, final int expectedErrors){
1143         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
1144         printErrorMessages(errorMessages);
1145         if (expectedErrors > 0) {
1146             assertEquals(testCase, expectedErrors, errorMessages.size());
1147         } else {
1148             assertEquals(testCase, expectedErrors, errors.size());
1149         }
1150     }
1151
1152     private void printErrorMessages(final List<ErrorMessage> errorMessages) {
1153         if (CollectionUtils.isNotEmpty(errorMessages)) {
1154             errorMessages.forEach(errorMessage ->
1155                 System.out.println(String.format("%s: %s", errorMessage.getLevel(), errorMessage.getMessage()))
1156             );
1157         }
1158     }
1159
1160     private ManifestBuilder getPnfManifestSampleBuilder() {
1161         return new ManifestBuilder()
1162             .withMetaData(PNFD_NAME.getToken(), "myPnf")
1163             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "ACME")
1164             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
1165             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
1166     }
1167
1168     private ManifestBuilder getVnfManifestSampleBuilder() {
1169         return new ManifestBuilder()
1170             .withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode")
1171             .withMetaData(VNF_PROVIDER_ID.getToken(), "ACME")
1172             .withMetaData(VNF_PACKAGE_VERSION.getToken(), "1.0")
1173             .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
1174     }
1175
1176     private void assertExpectedErrors(List<ErrorMessage> actualErrorList, final List<ErrorMessage> expectedErrorList) {
1177         if (actualErrorList == null) {
1178             actualErrorList = new ArrayList<>();
1179         }
1180
1181         printErrorMessages(actualErrorList);
1182
1183         assertThat("The actual error list should have the same size as the expected error list"
1184             , actualErrorList, hasSize(expectedErrorList.size())
1185         );
1186
1187         assertThat("The actual error and expected error lists should be the same"
1188             , actualErrorList, containsInAnyOrder(expectedErrorList.toArray(new ErrorMessage[0]))
1189         );
1190     }
1191
1192 }