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     @Test
 345     public void testGivenDefinitionFile_whenFileInPackageNotInManifest_thenErrorIsReturned() {
 346         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 347
 348         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 349         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 350
 351         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 352         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 353
 354         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 355
 356         final byte [] sampleDefinitionFile =
 357             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml");
 358         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile);
 359         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 360
 361         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 362         handler.addFile(TOSCA_DEFINITION_FILEPATH,
 363             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 364
 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("Artifact is not being referenced in manifest file", errors, 1);
 369     }
 370
 371     @Test
 372     public void testGivenDefinitionFile_whenManifestNotreferencedInManifest_thenNoErrorIsReturned() {
 373         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 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(StandardCharsets.UTF_8));
 379         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 380
 381         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 382         manifestBuilder.withSource(SAMPLE_SOURCE);
 383
 384         final byte [] sampleDefinitionFile =
 385             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml");
 386         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile);
 387         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 388
 389         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 390         handler.addFile(TOSCA_DEFINITION_FILEPATH,
 391             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 392
 393         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 394
 395         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 396         assertEquals(0, errors.size());
 397     }
 398
 399     /**
 400      * Reference with invalid YAML format.
 401      */
 402     @Test
 403     public void testGivenDefinitionFile_withInvalidYAML_thenErrorIsReturned() {
 404         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 405
 406         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 407         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 408
 409         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 410         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 411
 412         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 413         manifestBuilder.withSource(SAMPLE_SOURCE);
 414
 415         final String definitionFileWithInvalidYAML = "validation.files/definition/invalidDefinitionFile.yaml";
 416         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithInvalidYAML));
 417         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 418
 419         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 420         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 421
 422         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 423         assertExpectedErrors("Reference with invalid YAML format", errors, 1);
 424     }
 425
 426     @Test
 427     public void testGivenManifestFile_withValidSourceAndNonManoSources_thenNoErrorIsReturned() {
 428         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 429
 430         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 431         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 432
 433         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 434         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 435
 436         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 437         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 438
 439         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 440         manifestBuilder.withSource(SAMPLE_SOURCE);
 441
 442         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 443         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 444
 445         final String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 446         handler.addFile(nonManoSource, getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 447         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 448
 449         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 450         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 451
 452         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 453         assertEquals(0, errors.size());
 454     }
 455
 456     /**
 457      * Manifest with non existent source files should return error.
 458      */
 459     @Test
 460     public void testGivenManifestFile_withNonExistentSourceFile_thenErrorIsReturned() {
 461         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 462         //non existent reference
 463         manifestBuilder.withSource("Artifacts/Deployment/Events/RadioNode_pnf_v1.yaml");
 464
 465         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 466         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 467
 468         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 469         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 470
 471         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 472         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 473
 474         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 475         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 476
 477         String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 478         handler.addFile(nonManoSource, getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 479         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoSource);
 480
 481         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 482         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 483
 484         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 485         assertExpectedErrors("Manifest with non existent source files", errors, 1);
 486     }
 487
 488     /**
 489      * Tests the validation for a TOSCA Manifest with invalid data.
 490      */
 491     @Test
 492     public void testGivenManifestFile_withInvalidData_thenErrorIsReturned() {
 493         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 494         handler.addFile(TOSCA_MANIFEST_FILEPATH, getResourceBytesOrFail("validation.files/manifest/invalidManifest.mf"));
 495         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 496         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 497         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 498
 499         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 500         assertExpectedErrors("TOSCA manifest with invalid data", errors, 1);
 501     }
 502
 503     @Test
 504     public void testGivenManifestAndDefinitionFile_withSameNames_thenNoErrorReturned()  {
 505         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 506
 507         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 508         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 509
 510         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 511         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 512
 513         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 514         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 515
 516         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 517         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 518
 519         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 520         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 521
 522         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 523         assertEquals(0, errors.size());
 524     }
 525
 526     /**
 527      * Main TOSCA definitions file and Manifest file with different name should return error.
 528      */
 529     @Test
 530     public void testGivenManifestAndMainDefinitionFile_withDifferentNames_thenErrorIsReturned() {
 531         metaFileBuilder = new StringBuilder()
 532             .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 533                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 534             .append(CSAR_VERSION_ENTRY.getName())
 535                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 536             .append(CREATED_BY_ENTRY.getName())
 537                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 538             .append(ENTRY_DEFINITIONS.getName())
 539                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 540             .append(ETSI_ENTRY_MANIFEST.getName())
 541                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Definitions/MainServiceTemplate2.mf\n")
 542             .append(ETSI_ENTRY_CHANGE_LOG.getName())
 543                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 544
 545         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 546
 547         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 548         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 549
 550         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 551         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 552
 553         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 554         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 555
 556         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 557         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 558
 559         manifestBuilder.withSource("Definitions/MainServiceTemplate2.mf");
 560         handler.addFile("Definitions/MainServiceTemplate2.mf", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 561
 562         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 563         assertExpectedErrors("Main TOSCA definitions file and Manifest file with different name should return error",
 564                errors, 1);
 565     }
 566
 567     @Test
 568     public void testGivenManifestFile_withDifferentExtension_thenErrorIsReturned() {
 569         metaFileBuilder = new StringBuilder()
 570             .append(TOSCA_META_FILE_VERSION_ENTRY.getName())
 571                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.0").append("\n")
 572             .append(CSAR_VERSION_ENTRY.getName())
 573                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" 1.1").append("\n")
 574             .append(CREATED_BY_ENTRY.getName())
 575                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Vendor").append("\n")
 576             .append(ENTRY_DEFINITIONS.getName())
 577                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_DEFINITION_FILEPATH).append("\n")
 578             .append(ETSI_ENTRY_MANIFEST.getName())
 579                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Definitions/MainServiceTemplate.txt\n")
 580             .append(ETSI_ENTRY_CHANGE_LOG.getName())
 581                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(TOSCA_CHANGELOG_FILEPATH).append("\n");
 582
 583         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 584
 585         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 586         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 587
 588         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 589         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 590
 591         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 592         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 593
 594         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 595         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 596
 597         manifestBuilder.withSource("Definitions/MainServiceTemplate.txt");
 598         handler.addFile("Definitions/MainServiceTemplate.txt", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 599
 600         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 601         assertExpectedErrors("Manifest file with different extension than .mf should return error",
 602                 errors, 1);
 603     }
 604
 605     @Test
 606     public void testGivenManifestFile_withValidVnfMetadata_thenNoErrorsReturned() {
 607         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 608
 609         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 610         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 611         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 612         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 613         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 614         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 615
 616         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 617         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 618
 619         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 620         assertExpectedErrors("Manifest with valid vnf mandatory values should not return any errors", errors, 0);
 621     }
 622
 623     @Test
 624     public void testGivenManifestFile_withValidPnfMetadata_thenNoErrorsReturned() {
 625         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 626
 627         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 628         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 629
 630         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 631         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 632
 633         manifestBuilder.withSignedSource(TOSCA_DEFINITION_FILEPATH
 634             , "SHA-abc", "09e5a788acb180162c51679ae4c998039fa6644505db2415e35107d1ee213943");
 635         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 636
 637         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 638         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 639
 640         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 641         assertExpectedErrors("Manifest with valid pnf mandatory values should not return any errors", errors, 0);
 642     }
 643
 644     /**
 645      * Manifest with mixed metadata should return error.
 646      */
 647     @Test
 648     public void testGivenManifestFile_withMetadataContainingMixedPnfVnfMetadata_thenErrorIsReturned() {
 649         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 650             .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 651             .withMetaData(VNF_PROVIDER_ID.getToken(), "Bilal Iqbal")
 652             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 653             .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 654
 655         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 656         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 657         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 658         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 659         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 660         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 661
 662         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 663         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 664
 665         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 666         assertExpectedErrors("Manifest with mixed metadata should return error", errors, 1);
 667     }
 668
 669
 670     @Test
 671     public void testGivenManifestFile_withMetadataMissingPnfOrVnfMandatoryEntries_thenErrorIsReturned() {
 672         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 673             .withMetaData("invalid_product_name", "RadioNode")
 674             .withMetaData("invalid_provider_id", "Bilal Iqbal")
 675             .withMetaData("invalid_package_version", "1.0")
 676             .withMetaData("invalid_release_date_time", "2019-12-14T11:25:00+00:00");
 677
 678         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 679         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 680
 681         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 682         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 683
 684         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 685         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 686
 687         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 688         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 689
 690         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 691         assertExpectedErrors("Manifest with missing vnf or pnf mandatory entries should return error", errors, 1);
 692     }
 693
 694     @Test
 695     public void testGivenManifestFile_withMetadataMissingMandatoryPnfEntries_thenErrorIsReturned() {
 696         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 697
 698         manifestBuilder.withMetaData(PNFD_NAME.getToken(), "RadioNode");
 699         manifestBuilder.withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-12-14T11:25:00+00:00");
 700
 701         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 702         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 703
 704         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 705         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 706
 707         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 708         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 709
 710         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 711         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 712
 713         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 714         assertExpectedErrors("Manifest with metadata missing pnf mandatory entries should return error", errors, 1);
 715
 716     }
 717
 718     @Test
 719     public void testGivenManifestFile_withMetadataMissingMandatoryVnfEntries_thenErrorIsReturned() {
 720         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 721
 722         manifestBuilder.withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode");
 723
 724         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 725         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 726
 727         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 728         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 729
 730         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 731         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 732
 733         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 734         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 735
 736         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 737         assertExpectedErrors("Manifest with metadata missing vnf mandatory entries should return error", errors, 1);
 738
 739     }
 740
 741     /**
 742      * Manifest with more than 4 metadata entries should return error.
 743      */
 744     @Test
 745     public void testGivenManifestFile_withMetadataEntriesExceedingTheLimit_thenErrorIsReturned() {
 746         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 747             .withMetaData(PNFD_NAME.getToken(), "RadioNode")
 748             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "Bilal Iqbal")
 749             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
 750             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
 751
 752         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 753         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 754
 755         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 756         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 757
 758         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 759         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 760
 761         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 762         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 763
 764         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 765         assertExpectedErrors("Manifest with more than 4 metadata entries should return error", errors, 1);
 766     }
 767
 768     @Test
 769     public void testGivenManifestFile_withPnfMetadataAndVfEntries_thenErrorIsReturned() {
 770         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 771         metaFileBuilder
 772             .append(ETSI_ENTRY_TESTS.getName())
 773                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Files/Tests").append("\n")
 774             .append(ETSI_ENTRY_LICENSES.getName())
 775                 .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" Files/Licenses");
 776
 777         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 778         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 779
 780         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 781         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 782
 783         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 784         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 785
 786         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 787         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 788         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler);
 789         assertExpectedErrors("Tosca.meta should not have entries applicable only to VF", errors, 2);
 790
 791     }
 792
 793     /**
 794      * Tests an imported descriptor with a missing imported file.
 795      */
 796     @Test
 797     public void testGivenDefinitionFileWithImportedDescriptor_whenImportedDescriptorImportsMissingFile_thenMissingImportErrorOccur() {
 798         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 799
 800         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 801         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 802
 803         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 804         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 805
 806         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 807         manifestBuilder.withSource(SAMPLE_SOURCE);
 808
 809         final String definitionImportOne = "Definitions/importOne.yaml";
 810         handler.addFile(definitionImportOne,
 811             getResourceBytesOrFail("validation.files/definition/sampleDefinitionFile2.yaml"));
 812         manifestBuilder.withSource(definitionImportOne);
 813
 814         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithOneImport.yaml";
 815         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 816         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 817
 818         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 819         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 820
 821         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 822
 823         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 824         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 825             , Messages.MISSING_IMPORT_FILE.formatMessage("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml"))
 826         );
 827
 828         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 829     }
 830
 831     /**
 832      * Tests an imported descriptor with invalid import statement.
 833      */
 834     @Test
 835     public void testGivenDefinitionFileWithImportedDescriptor_whenInvalidImportStatementExistInImportedDescriptor_thenInvalidImportErrorOccur() {
 836         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 837
 838         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 839         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 840
 841         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 842         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 843
 844         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 845         manifestBuilder.withSource(SAMPLE_SOURCE);
 846
 847         final String definitionImportOne = "Definitions/importOne.yaml";
 848         handler.addFile(definitionImportOne,
 849             getResourceBytesOrFail("validation.files/definition/definitionFileWithInvalidImport.yaml"));
 850         manifestBuilder.withSource(definitionImportOne);
 851
 852         final String definitionFileWithValidImports = "validation.files/definition/definitionFileWithOneImport.yaml";
 853         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(definitionFileWithValidImports));
 854         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 855
 856         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 857         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 858
 859         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
 860
 861         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 862         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 863             , Messages.INVALID_IMPORT_STATEMENT.formatMessage(definitionImportOne, "null"))
 864         );
 865
 866         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 867     }
 868
 869     @Test
 870     public void givenManifestWithNonManoPmAndVesArtifacts_whenNonManoArtifactsAreValid_thenNoErrorsOccur() {
 871         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 872
 873         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 874         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 875
 876         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 877         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 878
 879         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 880         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 881
 882         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 883         handler.addFile(nonManoPmEventsSource,
 884             getResourceBytesOrFail("validation.files/measurements/pmEvents-valid.yaml"));
 885         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 886
 887         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 888         handler.addFile(nonManoVesEventsSource,
 889             getResourceBytesOrFail("validation.files/events/vesEvents-valid.yaml"));
 890         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 891
 892         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 893         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 894
 895         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 896             .validateContent(handler);
 897
 898         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
 899     }
 900
 901     @Test
 902     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreInvalid_thenInvalidYamlErrorOccur() {
 903         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 904
 905         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 906         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 907
 908         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 909         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 910
 911         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 912         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 913
 914         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 915         handler.addFile(nonManoPmEventsSource, getResourceBytesOrFail(INVALID_YAML_FILE_PATH));
 916         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 917
 918         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 919         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 920
 921         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 922         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 923             , Messages.INVALID_YAML_FORMAT_1.formatMessage(nonManoPmEventsSource, "while scanning a simple key\n"
 924             + " in 'reader', line 2, column 1:\n"
 925             + "    key {}\n"
 926             + "    ^\n"
 927             + "could not find expected ':'\n"
 928             + " in 'reader', line 2, column 7:\n"
 929             + "    {}\n"
 930             + "      ^\n"))
 931         );
 932
 933         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 934             .validateContent(handler);
 935
 936         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 937     }
 938
 939     @Test
 940     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsYamlAreEmpty_thenEmptyYamlErrorOccur() {
 941         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 942
 943         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 944         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 945
 946         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 947         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 948
 949         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 950         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 951
 952         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 953         handler.addFile(nonManoPmEventsSource, getResourceBytesOrFail(EMPTY_YAML_FILE_PATH));
 954         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 955
 956         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.yaml";
 957         handler.addFile(nonManoVesEventsSource, getResourceBytesOrFail(EMPTY_YAML_FILE_PATH));
 958         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 959
 960         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 961         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 962
 963         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 964         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 965             , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoPmEventsSource))
 966         );
 967         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 968             , Messages.EMPTY_YAML_FILE_1.formatMessage(nonManoVesEventsSource))
 969         );
 970
 971         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
 972             .validateContent(handler);
 973
 974         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 975     }
 976
 977     @Test
 978     public void givenManifestWithNonManoPmOrVesArtifacts_whenNonManoArtifactsHaveNotYamlExtension_thenInvalidYamlExtensionErrorOccur() {
 979         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 980
 981         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
 982         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 983
 984         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
 985         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 986
 987         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 988         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 989
 990         final String nonManoPmEventsSource = "Artifacts/Deployment/Measurements/PM_Dictionary.y1";
 991         handler.addFile(nonManoPmEventsSource, "".getBytes());
 992         manifestBuilder.withNonManoArtifact(ONAP_PM_DICTIONARY.getType(), nonManoPmEventsSource);
 993
 994         final String nonManoVesEventsSource = "Artifacts/Deployment/Events/ves_events.y2";
 995         handler.addFile(nonManoVesEventsSource, "".getBytes());
 996         manifestBuilder.withNonManoArtifact(ONAP_VES_EVENTS.getType(), nonManoVesEventsSource);
 997
 998         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 999         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1000
1001         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1002         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1003             , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoPmEventsSource))
1004         );
1005         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1006             , Messages.INVALID_YAML_EXTENSION.formatMessage(nonManoVesEventsSource))
1007         );
1008
1009         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator
1010             .validateContent(handler);
1011
1012         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1013     }
1014
1015     @Test
1016     public void givenPackageWithValidSoftwareInformationNonMano_whenThePackageIsValidated_thenNoErrorsAreReturned() {
1017         //given a package with software information non-mano artifact
1018         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1019         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-valid.yaml";
1020         handler.addFile(nonManoSoftwareInformationPath,
1021             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1022         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1023         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1024             .getBytes(StandardCharsets.UTF_8));
1025         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1026         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1027         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1028         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1029         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1030
1031         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1032         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1033         //when package is validated
1034         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1035         //then no errors
1036         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
1037     }
1038
1039     @Test
1040     public void givenPackageWithUnparsableSwInformationNonMano_whenThePackageIsValidated_thenInvalidErrorIsReturned() {
1041         //given a package with unparsable software information non-mano artifact
1042         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1043         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-valid.yaml";
1044         handler.addFile(nonManoSoftwareInformationPath,
1045             getResourceBytesOrFail("validation.files/invalid.yaml"));
1046         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1047         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1048             .getBytes(StandardCharsets.UTF_8));
1049         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1050         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1051         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1052         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1053         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1054
1055         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1056         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1057         //when package is validated
1058         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1059         //then invalid error returned
1060         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1061         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1062             , Messages.INVALID_SW_INFORMATION_NON_MANO_ERROR.formatMessage(nonManoSoftwareInformationPath))
1063         );
1064         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1065     }
1066
1067     @Test
1068     public void givenPackageWithIncorrectSwInformationNonMano_whenThePackageIsValidated_thenInvalidErrorIsReturned() {
1069         //given a package with incorrect software information non-mano artifact
1070         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1071         final String nonManoSoftwareInformationPath = "Artifacts/software-information/pnf-sw-information-invalid.yaml";
1072         handler.addFile(nonManoSoftwareInformationPath,
1073             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-invalid.yaml"));
1074         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformationPath);
1075         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1076             .getBytes(StandardCharsets.UTF_8));
1077         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1078         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1079         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1080         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1081         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1082
1083         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1084         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1085         //when package is validated
1086         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1087         //then incorrect error returned
1088         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1089         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1090             , Messages.INCORRECT_SW_INFORMATION_NON_MANO_ERROR.formatMessage(nonManoSoftwareInformationPath))
1091         );
1092         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1093     }
1094
1095     @Test
1096     public void givenPackageWithTwoSoftwareInformationNonMano_whenThePackageIsValidated_thenUniqueErrorIsReturned() {
1097         //given a package with two software information non-mano artifacts
1098         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1099         final String nonManoSoftwareInformation1Path = "Artifacts/software-information/pnf-sw-information-valid1.yaml";
1100         handler.addFile(nonManoSoftwareInformation1Path,
1101             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1102         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformation1Path);
1103         final String nonManoSoftwareInformation2Path = "Artifacts/software-information/pnf-sw-information-valid2.yaml";
1104         handler.addFile(nonManoSoftwareInformation2Path,
1105             getResourceBytesOrFail("validation.files/non-mano/pnf-sw-information-valid.yaml"));
1106         manifestBuilder.withNonManoArtifact(ONAP_SW_INFORMATION.getType(), nonManoSoftwareInformation2Path);
1107         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileBuilder.toString()
1108             .getBytes(StandardCharsets.UTF_8));
1109         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1110         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1111         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1112         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1113         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1114
1115         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1116         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1117         //when package is validated
1118         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1119         //then unique error returned
1120         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
1121         final String errorFiles = Stream.of(nonManoSoftwareInformation1Path, nonManoSoftwareInformation2Path)
1122             .map(s -> String.format("'%s'", s))
1123             .collect(Collectors.joining(", "));
1124         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1125             , Messages.UNIQUE_SW_INFORMATION_NON_MANO_ERROR.formatMessage(errorFiles))
1126         );
1127         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1128     }
1129
1130     @Test
1131     public void signedPackage() throws SecurityManagerException {
1132         //given
1133         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
1134         final String fakeArtifactPath = "Artifacts/aArtifact.yaml";
1135         final String fakeArtifactCmsPath = "Artifacts/aArtifact.cms";
1136         final String fakeCertificatePath = "certificate.cert";
1137         handler.addFile(fakeArtifactPath, new byte[0]);
1138         manifestBuilder.withSource(fakeArtifactPath);
1139         handler.addFile(fakeArtifactCmsPath, new byte[0]);
1140         manifestBuilder.withSource(fakeArtifactCmsPath);
1141         handler.addFile(fakeCertificatePath, new byte[0]);
1142         manifestBuilder.withSource(fakeCertificatePath);
1143         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
1144         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
1145         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytesOrFail(SAMPLE_DEFINITION_FILE_PATH));
1146         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
1147
1148         metaFileBuilder.append(ETSI_ENTRY_CERTIFICATE.getName())
1149             .append(ATTRIBUTE_VALUE_SEPARATOR.getToken()).append(" ").append(fakeCertificatePath).append("\n");
1150         handler.addFile(TOSCA_META_PATH_FILE_NAME,
1151             metaFileBuilder.toString().getBytes(StandardCharsets.UTF_8));
1152         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
1153
1154         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
1155         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
1156
1157         final SecurityManager securityManagerMock = mock(SecurityManager.class);
1158         when(securityManagerMock.verifySignedData(any(), any(), any())).thenReturn(true);
1159         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator(securityManagerMock);
1160
1161         //when
1162         Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1163         //then
1164         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), Collections.emptyList());
1165
1166         //given
1167         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator(securityManagerMock);
1168         when(securityManagerMock.verifySignedData(any(), any(), any())).thenReturn(false);
1169
1170         //when
1171         actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1172
1173         //then
1174         List<ErrorMessage> expectedErrorList = new ArrayList<>();
1175         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
1176             , Messages.ARTIFACT_INVALID_SIGNATURE.formatMessage(fakeArtifactCmsPath, fakeArtifactPath))
1177         );
1178         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1179
1180         //given
1181         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator(securityManagerMock);
1182         when(securityManagerMock.verifySignedData(any(), any(), any()))
1183             .thenThrow(new SecurityManagerException("SecurityManagerException"));
1184         //when
1185         actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler);
1186
1187         //then
1188         expectedErrorList = new ArrayList<>();
1189         expectedErrorList.add(
1190             new ErrorMessage(ErrorLevel.ERROR,
1191                 Messages.ARTIFACT_SIGNATURE_VALIDATION_ERROR.formatMessage(fakeArtifactCmsPath,
1192                     fakeArtifactPath, fakeCertificatePath, "SecurityManagerException")
1193             )
1194         );
1195         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
1196     }
1197
1198
1199
1200
1201     private void assertExpectedErrors(final String testCase, final Map<String, List<ErrorMessage>> errors, final int expectedErrors){
1202         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
1203         printErrorMessages(errorMessages);
1204         if (expectedErrors > 0) {
1205             assertEquals(testCase, expectedErrors, errorMessages.size());
1206         } else {
1207             assertEquals(testCase, expectedErrors, errors.size());
1208         }
1209     }
1210
1211     private void printErrorMessages(final List<ErrorMessage> errorMessages) {
1212         if (CollectionUtils.isNotEmpty(errorMessages)) {
1213             errorMessages.forEach(errorMessage ->
1214                 System.out.println(String.format("%s: %s", errorMessage.getLevel(), errorMessage.getMessage()))
1215             );
1216         }
1217     }
1218
1219     private ManifestBuilder getPnfManifestSampleBuilder() {
1220         return new ManifestBuilder()
1221             .withMetaData(PNFD_NAME.getToken(), "myPnf")
1222             .withMetaData(ManifestTokenType.PNFD_PROVIDER.getToken(), "ACME")
1223             .withMetaData(PNFD_ARCHIVE_VERSION.getToken(), "1.0")
1224             .withMetaData(PNFD_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
1225     }
1226
1227     private ManifestBuilder getVnfManifestSampleBuilder() {
1228         return new ManifestBuilder()
1229             .withMetaData(VNF_PRODUCT_NAME.getToken(), "RadioNode")
1230             .withMetaData(VNF_PROVIDER_ID.getToken(), "ACME")
1231             .withMetaData(VNF_PACKAGE_VERSION.getToken(), "1.0")
1232             .withMetaData(VNF_RELEASE_DATE_TIME.getToken(), "2019-03-11T11:25:00+00:00");
1233     }
1234
1235     private void assertExpectedErrors(List<ErrorMessage> actualErrorList, final List<ErrorMessage> expectedErrorList) {
1236         if (actualErrorList == null) {
1237             actualErrorList = new ArrayList<>();
1238         }
1239
1240         printErrorMessages(actualErrorList);
1241
1242         assertThat("The actual error list should have the same size as the expected error list"
1243             , actualErrorList, hasSize(expectedErrorList.size())
1244         );
1245
1246         assertThat("The actual error and expected error lists should be the same"
1247             , actualErrorList, containsInAnyOrder(expectedErrorList.toArray(new ErrorMessage[0]))
1248         );
1249     }
1250
1251 }