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