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

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