gerrit.onap Code Review - sdc.git/blob

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