gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation;
  22
  23 import org.apache.commons.collections.CollectionUtils;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.openecomp.core.utilities.file.FileContentHandler;
  27 import org.openecomp.sdc.common.errors.Messages;
  28 import org.openecomp.sdc.common.utils.SdcCommon;
  29 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  30 import org.openecomp.sdc.datatypes.error.ErrorMessage;
  31 import java.io.IOException;
  32 import java.nio.charset.StandardCharsets;
  33 import java.util.ArrayList;
  34 import java.util.Collections;
  35 import java.util.List;
  36 import java.util.Map;
  37 import org.openecomp.sdc.logging.api.Logger;
  38 import org.openecomp.sdc.logging.api.LoggerFactory;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertTrue;
  42 import static org.junit.Assert.fail;
  43 import static org.hamcrest.Matchers.containsInAnyOrder;
  44 import static org.hamcrest.Matchers.hasSize;
  45 import static org.hamcrest.MatcherAssert.assertThat;
  46 import static org.openecomp.sdc.tosca.csar.CSARConstants.PNFD_NAME;
  47 import static org.openecomp.sdc.tosca.csar.CSARConstants.PNFD_PROVIDER;
  48 import static org.openecomp.sdc.tosca.csar.CSARConstants.PNFD_ARCHIVE_VERSION;
  49 import static org.openecomp.sdc.tosca.csar.CSARConstants.PNFD_RELEASE_DATE_TIME;
  50 import static org.openecomp.sdc.tosca.csar.CSARConstants.SEPARATOR_MF_ATTRIBUTE;
  51 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ENTRY_DEFINITIONS;
  52 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_CERTIFICATE;
  53 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_CHANGE_LOG;
  54 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_LICENSES;
  55 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_MANIFEST;
  56 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ETSI_ENTRY_TESTS;
  57 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_PATH_FILE_NAME;
  58 import static org.openecomp.sdc.tosca.csar.CSARConstants.VNF_PRODUCT_NAME;
  59 import static org.openecomp.sdc.tosca.csar.CSARConstants.VNF_PROVIDER_ID;
  60 import static org.openecomp.sdc.tosca.csar.CSARConstants.VNF_PACKAGE_VERSION;
  61 import static org.openecomp.sdc.tosca.csar.CSARConstants.VNF_RELEASE_DATE_TIME;
  62
  63 import static org.openecomp.sdc.vendorsoftwareproduct.impl.orchestration.csar.validation.TestConstants.*;
  64
  65 public class SOL004MetaDirectoryValidatorTest {
  66
  67     private static final Logger LOGGER = LoggerFactory.getLogger(SOL004MetaDirectoryValidatorTest.class);
  68
  69     private SOL004MetaDirectoryValidator sol004MetaDirectoryValidator;
  70     private FileContentHandler handler;
  71     private String metaFile;
  72
  73     @Before
  74     public void setUp() {
  75         sol004MetaDirectoryValidator = new SOL004MetaDirectoryValidator();
  76         handler = new FileContentHandler();
  77         metaFile =
  78                 "TOSCA-Meta-File-Version: 1.0\n"+
  79                 "CSAR-Version: 1.1\n"+
  80                 "Created-By: Vendor\n"+
  81                 TOSCA_META_ENTRY_DEFINITIONS + SEPARATOR_MF_ATTRIBUTE + "Definitions/MainServiceTemplate.yaml\n"+
  82                 TOSCA_META_ETSI_ENTRY_MANIFEST + SEPARATOR_MF_ATTRIBUTE + "Definitions/MainServiceTemplate.mf\n"+
  83                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + SEPARATOR_MF_ATTRIBUTE + "Artifacts/changeLog.text\n";
  84     }
  85
  86     @Test
  87     public void testGivenTOSCAMetaFile_whenEntryHasNoValue_thenErrorIsReturned() {
  88         final String metaFileWithInvalidEntry = "TOSCA-Meta-File-Version: \n" +
  89                 "Entry-Definitions: Definitions/MainServiceTemplate.yaml";
  90
  91         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFileWithInvalidEntry.getBytes(StandardCharsets.UTF_8));
  92         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(TestConstants.SAMPLE_DEFINITION_FILE_PATH));
  93
  94         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
  95         assertExpectedErrors("TOSCA Meta file with no entries", errors, 1);
  96     }
  97
  98     @Test
  99     public void testGivenTOSCAMeta_withAllSupportedEntries_thenNoErrorsReturned() {
 100
 101         final String entryTestFilePath = "Files/Tests";
 102         final String entryLicenseFilePath = "Files/Licenses";
 103
 104         final List<String> folderList = new ArrayList<>();
 105         folderList.add("Files/Tests/");
 106         folderList.add("Files/Licenses/");
 107
 108         metaFile = metaFile +
 109                 TOSCA_META_ETSI_ENTRY_TESTS + SEPARATOR_MF_ATTRIBUTE + entryTestFilePath + "\n" +
 110                 TOSCA_META_ETSI_ENTRY_LICENSES + SEPARATOR_MF_ATTRIBUTE + entryLicenseFilePath +"\n";
 111
 112         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 113         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 114         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 115
 116         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 117         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 118         handler.addFile(entryTestFilePath, "".getBytes());
 119         handler.addFile(entryLicenseFilePath, "".getBytes());
 120
 121         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 122             .withSource(TOSCA_META_PATH_FILE_NAME)
 123             .withSource(TOSCA_DEFINITION_FILEPATH)
 124             .withSource(TOSCA_CHANGELOG_FILEPATH)
 125             .withSource(TOSCA_MANIFEST_FILEPATH).withSource(SAMPLE_SOURCE)
 126             .withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH)
 127             .withSource(entryTestFilePath)
 128             .withSource(entryLicenseFilePath);
 129
 130         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 131
 132         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, folderList);
 133         assertTrue(errors.size() == 0);
 134     }
 135
 136     @Test
 137     public void testGivenTOSCAMeta_withUnsupportedEntry_thenWarningIsReturned() {
 138         metaFile = "Entry-Events: Definitions/events.log";
 139
 140         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 141         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 142         List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 143         assertTrue(errors.size() == 1 && errorMessages.size() == 1);
 144         assertTrue(errorMessages.get(0).getLevel() == ErrorLevel.ERROR);
 145     }
 146
 147     /**
 148      * Tests if the meta file contains invalid versions in TOSCA-Meta-File-Version and CSAR-Version attributes.
 149      */
 150     @Test
 151     public void testGivenTOSCAMetaFile_withInvalidTOSCAMetaFileVersionAndCSARVersion_thenErrorIsReturned() {
 152         final String metaFile =
 153                 "TOSCA-Meta-File-Version: " + Integer.MAX_VALUE +
 154                 "\nCSAR-Version: " + Integer.MAX_VALUE  +
 155                 "\nCreated-By: Bilal Iqbal\n" +
 156                 TOSCA_META_ENTRY_DEFINITIONS+ SEPARATOR_MF_ATTRIBUTE + "Definitions/MainServiceTemplate.yaml\n" +
 157                 TOSCA_META_ETSI_ENTRY_MANIFEST + SEPARATOR_MF_ATTRIBUTE + "Definitions/MainServiceTemplate.mf\n"+
 158                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + SEPARATOR_MF_ATTRIBUTE + "Artifacts/changeLog.text";
 159
 160         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 161
 162         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 163         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 164
 165         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(TestConstants.SAMPLE_DEFINITION_FILE_PATH));
 166         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 167
 168         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 169         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 170
 171         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 172         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 173
 174         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 175         assertExpectedErrors("Invalid TOSCA-Meta-File-Version and CSAR-Version attributes", errors, 2);
 176     }
 177
 178     @Test
 179     public void testGivenTOSCAMetaFile_withNonExistentFileReferenced_thenErrorsReturned() {
 180         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 181
 182         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 183         List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 184         assertTrue(errors.size() == 1 && errorMessages.size() == 3);
 185     }
 186
 187
 188     @Test
 189     public void testGivenDefinitionFile_whenValidImportStatementExist_thenNoErrorsReturned() {
 190         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 191
 192         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 193         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 194
 195         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 196         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 197
 198         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 199         manifestBuilder.withSource(SAMPLE_SOURCE);
 200
 201         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 202         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 203
 204         final String definitionFileWithValidImports = "/validation.files/definition/definitionFileWithValidImports.yaml";
 205         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithValidImports));
 206         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 207
 208         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 209         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 210
 211         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 212         assertTrue(errors.size() == 0);
 213     }
 214
 215     @Test
 216     public void testGivenDefinitionFile_whenMultipleDefinitionsImportStatementExist_thenNoErrorsReturned() {
 217         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 218
 219         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 220         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 221
 222         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 223         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 224
 225         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 226         manifestBuilder.withSource(SAMPLE_SOURCE);
 227
 228         final byte [] sampleDefinitionFile1 = getResourceBytes("/validation.files/definition/sampleDefinitionFile1.yaml");
 229         handler.addFile(TOSCA_DEFINITION_FILEPATH, sampleDefinitionFile1);
 230         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 231
 232         final byte [] sampleDefinitionFile2 = getResourceBytes("/validation.files/definition/sampleDefinitionFile2.yaml");
 233         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", sampleDefinitionFile2);
 234         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 235
 236         final byte [] sampleDefinitionFile3 = getResourceBytes("/validation.files/definition/sampleDefinitionFile1.yaml");
 237         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml", sampleDefinitionFile3);
 238         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml");
 239
 240         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 241         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 242
 243         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 244         assertTrue(errors.size() == 0);
 245     }
 246
 247     @Test
 248     public void testGivenDefinitionFile_whenInvalidImportStatementExist_thenErrorIsReturned() {
 249         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 250
 251         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 252         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 253
 254         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 255         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 256
 257         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 258         manifestBuilder.withSource(SAMPLE_SOURCE);
 259
 260         final String definitionFileWithInvalidImports = "/validation.files/definition/definitionFileWithInvalidImport.yaml";
 261         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithInvalidImports));
 262         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 263
 264         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 265         String manifest = manifestBuilder.build();
 266         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifest.getBytes(StandardCharsets.UTF_8));
 267
 268         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 269         assertExpectedErrors("", errors, 1);
 270     }
 271
 272     /**
 273      * Manifest referenced import file missing
 274      */
 275     @Test
 276     public void testGivenDefinitionFile_whenReferencedImportDoesNotExist_thenErrorIsReturned() {
 277         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 278
 279         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 280         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 281
 282         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 283         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 284
 285         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 286         manifestBuilder.withSource(SAMPLE_SOURCE);
 287
 288         handler.addFile("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml", "".getBytes());
 289         manifestBuilder.withSource("Definitions/etsi_nfv_sol001_pnfd_2_5_1_types.yaml");
 290
 291         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 292         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes("/validation.files/definition/sampleDefinitionFile2.yaml"));
 293
 294         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 295         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 296
 297         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 298         assertExpectedErrors("Manifest referenced import file missing", errors, 1);
 299     }
 300
 301     /**
 302      * Reference with invalid YAML format.
 303      */
 304     @Test
 305     public void testGivenDefinitionFile_withInvalidYAML_thenErrorIsReturned() {
 306         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 307
 308         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 309         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 310
 311         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 312         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 313
 314         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 315         manifestBuilder.withSource(SAMPLE_SOURCE);
 316
 317         final String definitionFileWithInvalidYAML = "/validation.files/definition/invalidDefinitionFile.yaml";
 318         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithInvalidYAML));
 319         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 320
 321         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 322         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 323
 324         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 325         assertExpectedErrors("Reference with invalid YAML format", errors, 1);
 326     }
 327
 328     @Test
 329     public void testGivenManifestFile_withValidSourceAndNonManoSources_thenNoErrorIsReturned() {
 330         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 331
 332         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 333         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 334
 335         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 336         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 337
 338         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 339         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 340
 341         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 342         manifestBuilder.withSource(SAMPLE_SOURCE);
 343
 344         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 345         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 346
 347         final String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 348         handler.addFile(nonManoSource, "".getBytes());
 349         manifestBuilder.withNonManoArtifact("onap_pm_events", nonManoSource);
 350
 351         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 352         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 353
 354         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 355         assertTrue(errors.size() == 0);
 356     }
 357
 358     /**
 359      * Manifest with non existent source files should return error.
 360      */
 361     @Test
 362     public void testGivenManifestFile_withNonExistentSourceFile_thenErrorIsReturned() {
 363         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 364         //non existent reference
 365         manifestBuilder.withSource("Artifacts/Deployment/Events/RadioNode_pnf_v1.yaml");
 366
 367         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 368         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 369
 370         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 371         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 372
 373         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 374         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 375
 376         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 377         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 378
 379         String nonManoSource = "Artifacts/Deployment/Measurements/PM_Dictionary.yaml";
 380         handler.addFile(nonManoSource, "".getBytes());
 381         manifestBuilder.withNonManoArtifact("onap_pm_events", nonManoSource);
 382
 383         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 384         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 385
 386         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 387         assertExpectedErrors("Manifest with non existent source files", errors, 1);
 388     }
 389
 390     /**
 391      * Tests the validation for a TOSCA Manifest with invalid data.
 392      */
 393     @Test
 394     public void testGivenManifestFile_withInvalidData_thenErrorIsReturned() {
 395         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 396         handler.addFile(TOSCA_MANIFEST_FILEPATH, getResourceBytes("/validation.files/manifest/invalidManifest.mf"));
 397         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 398         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 399         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 400
 401         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 402         assertExpectedErrors("TOSCA manifest with invalid data", errors, 1);
 403     }
 404
 405     @Test
 406     public void testGivenManifestAndDefinitionFile_withSameNames_thenNoErrorReturned()  {
 407         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 408
 409         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 410         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 411
 412         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 413         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 414
 415         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 416         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 417
 418         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 419         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 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, Collections.emptyList());
 425         assertTrue(errors.size() == 0);
 426     }
 427
 428     /**
 429      * Main TOSCA definitions file and Manifest file with different name should return error.
 430      */
 431     @Test
 432     public void testGivenManifestAndMainDefinitionFile_withDifferentNames_thenErrorIsReturned() {
 433         metaFile =
 434                 "TOSCA-Meta-File-Version: 1.0\n"+
 435                 "CSAR-Version: 1.1\n"+
 436                 "Created-By: Vendor\n"+
 437                 TOSCA_META_ENTRY_DEFINITIONS + SEPARATOR_MF_ATTRIBUTE + "Definitions/MainServiceTemplate.yaml\n"+
 438                 TOSCA_META_ETSI_ENTRY_MANIFEST + SEPARATOR_MF_ATTRIBUTE +"Definitions/MainServiceTemplate2.mf\n"+
 439                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + SEPARATOR_MF_ATTRIBUTE +"Artifacts/changeLog.text\n";
 440
 441         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 442
 443         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 444         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 445
 446         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 447         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 448
 449         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 450         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 451
 452         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 453         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 454
 455         manifestBuilder.withSource("Definitions/MainServiceTemplate2.mf");
 456         handler.addFile("Definitions/MainServiceTemplate2.mf", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 457
 458         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 459         assertExpectedErrors("Main TOSCA definitions file and Manifest file with different name should return error",
 460                errors, 1);
 461     }
 462
 463     @Test
 464     public void testGivenManifestFile_withDifferentExtension_thenErrorIsReturned() {
 465         metaFile =
 466                 "TOSCA-Meta-File-Version: 1.0\n"+
 467                 "CSAR-Version: 1.1\n"+
 468                 "Created-By: Vendor\n"+
 469                 "Entry-Definitions: Definitions/MainServiceTemplate.yaml\n"+
 470                 TOSCA_META_ETSI_ENTRY_MANIFEST + SEPARATOR_MF_ATTRIBUTE +  "Definitions/MainServiceTemplate.txt\n"+
 471                 TOSCA_META_ETSI_ENTRY_CHANGE_LOG + SEPARATOR_MF_ATTRIBUTE + "Artifacts/changeLog.text\n";
 472
 473         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 474
 475         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 476         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 477
 478         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 479         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 480
 481         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 482         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 483
 484         handler.addFile(SAMPLE_DEFINITION_IMPORT_FILE_PATH, "".getBytes());
 485         manifestBuilder.withSource(SAMPLE_DEFINITION_IMPORT_FILE_PATH);
 486
 487         manifestBuilder.withSource("Definitions/MainServiceTemplate.txt");
 488         handler.addFile("Definitions/MainServiceTemplate.txt", manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 489
 490         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 491         assertExpectedErrors("Manifest file with different extension than .mf should return error",
 492                 errors, 1);
 493     }
 494
 495     @Test
 496     public void testGivenManifestFile_withValidVnfMetadata_thenNoErrorsReturned() {
 497         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 498
 499         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 500         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 501         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 502         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 503         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 504         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 505
 506         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 507         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 508
 509         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 510         assertExpectedErrors("Manifest with valid vnf mandatory values should not return any errors", errors, 0);
 511     }
 512
 513     @Test
 514     public void testGivenManifestFile_withValidPnfMetadata_thenNoErrorsReturned() {
 515         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 516
 517         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 518         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 519
 520         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 521         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 522
 523         manifestBuilder.withSignedSource(TOSCA_DEFINITION_FILEPATH
 524             , "SHA-abc", "09e5a788acb180162c51679ae4c998039fa6644505db2415e35107d1ee213943");
 525         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 526
 527         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 528         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 529
 530         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 531         assertExpectedErrors("Manifest with valid pnf mandatory values should not return any errors", errors, 0);
 532     }
 533
 534     /**
 535      * Manifest with mixed metadata should return error.
 536      */
 537     @Test
 538     public void testGivenManifestFile_withMetadataContainingMixedPnfVnfMetadata_thenErrorIsReturned() {
 539         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 540             .withMetaData(PNFD_NAME, "RadioNode")
 541             .withMetaData(VNF_PROVIDER_ID, "Bilal Iqbal")
 542             .withMetaData(PNFD_ARCHIVE_VERSION, "1.0")
 543             .withMetaData(VNF_RELEASE_DATE_TIME, "2019-12-14T11:25:00+00:00");
 544
 545         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 546         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 547         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 548         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 549         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 550         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 551
 552         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 553         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 554
 555         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 556         assertExpectedErrors("Manifest with mixed metadata should return error", errors, 1);
 557     }
 558
 559
 560     @Test
 561     public void testGivenManifestFile_withMetadataMissingPnfOrVnfMandatoryEntries_thenErrorIsReturned() {
 562         final ManifestBuilder manifestBuilder = new ManifestBuilder()
 563             .withMetaData("invalid_product_name", "RadioNode")
 564             .withMetaData("invalid_provider_id", "Bilal Iqbal")
 565             .withMetaData("invalid_package_version", "1.0")
 566             .withMetaData("invalid_release_date_time", "2019-12-14T11:25:00+00:00");
 567
 568         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 569         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 570
 571         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 572         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 573
 574         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 575         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 576
 577         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 578         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 579
 580         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 581         assertExpectedErrors("Manifest with missing vnf or pnf mandatory entries should return error", errors, 1);
 582     }
 583
 584     @Test
 585     public void testGivenManifestFile_withMetadataMissingMandatoryPnfEntries_thenErrorIsReturned() {
 586         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 587
 588         manifestBuilder.withMetaData(PNFD_NAME, "RadioNode");
 589         manifestBuilder.withMetaData(PNFD_RELEASE_DATE_TIME, "2019-12-14T11:25:00+00:00");
 590
 591         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 592         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 593
 594         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 595         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 596
 597         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 598         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 599
 600         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 601         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 602
 603         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 604         assertExpectedErrors("Manifest with metadata missing pnf mandatory entries should return error", errors, 3);
 605
 606     }
 607
 608     @Test
 609     public void testGivenManifestFile_withMetadataMissingMandatoryVnfEntries_thenErrorIsReturned() {
 610         final ManifestBuilder manifestBuilder = new ManifestBuilder();
 611
 612         manifestBuilder.withMetaData(VNF_PRODUCT_NAME, "RadioNode");
 613
 614         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 615         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 616
 617         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 618         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 619
 620         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 621         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 622
 623         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 624         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 625
 626         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 627         assertExpectedErrors("Manifest with metadata missing vnf mandatory entries should return error", errors, 4);
 628
 629     }
 630
 631     /**
 632      * Manifest with more than 4 metadata entries should return error.
 633      */
 634     @Test
 635     public void testGivenManifestFile_withMetadataEntriesExceedingTheLimit_thenErrorIsReturned() {
 636         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder()
 637             .withMetaData(PNFD_NAME, "RadioNode")
 638             .withMetaData(PNFD_PROVIDER, "Bilal Iqbal")
 639             .withMetaData(PNFD_ARCHIVE_VERSION, "1.0")
 640             .withMetaData(PNFD_RELEASE_DATE_TIME, "2019-03-11T11:25:00+00:00");
 641
 642         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 643         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 644
 645         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 646         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 647
 648         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 649         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 650
 651         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 652         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 653
 654         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 655         assertExpectedErrors("Manifest with more than 4 metadata entries should return error", errors, 2);
 656     }
 657
 658     @Test
 659     public void testGivenManifestFile_withPnfMetadataAndVfEntries_thenErrorIsReturned() {
 660         final ManifestBuilder manifestBuilder = getPnfManifestSampleBuilder();
 661
 662         metaFile = metaFile +
 663             TOSCA_META_ETSI_ENTRY_TESTS + SEPARATOR_MF_ATTRIBUTE + "Files/Tests\n" +
 664             TOSCA_META_ETSI_ENTRY_LICENSES + SEPARATOR_MF_ATTRIBUTE + "Files/Licenses\n" +
 665             TOSCA_META_ETSI_ENTRY_CERTIFICATE + SEPARATOR_MF_ATTRIBUTE + "Files/Certificates";
 666
 667         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 668         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 669
 670         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes());
 671         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 672
 673         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(SAMPLE_DEFINITION_FILE_PATH));
 674         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 675
 676         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 677         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 678
 679         final List<String> folderList = new ArrayList<>();
 680         folderList.add("Files/Certificates/");
 681         final Map<String, List<ErrorMessage>> errors = sol004MetaDirectoryValidator.validateContent(handler, folderList);
 682         assertExpectedErrors("Tosca.meta should not have entries applicable only to VF", errors, 2);
 683
 684     }
 685
 686     /**
 687      * Tests an imported descriptor with a missing imported file.
 688      */
 689     @Test
 690     public void testGivenDefinitionFileWithImportedDescriptor_whenImportedDescriptorImportsMissingFile_thenMissingImportErrorOccur() throws IOException {
 691         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 692
 693         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 694         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 695
 696         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 697         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 698
 699         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 700         manifestBuilder.withSource(SAMPLE_SOURCE);
 701
 702         final String definitionImportOne = "Definitions/importOne.yaml";
 703         handler.addFile(definitionImportOne, getResourceBytes("/validation.files/definition/sampleDefinitionFile2.yaml"));
 704         manifestBuilder.withSource(definitionImportOne);
 705
 706         final String definitionFileWithValidImports = "/validation.files/definition/definitionFileWithOneImport.yaml";
 707         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithValidImports));
 708         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 709
 710         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 711         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 712
 713         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 714
 715         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 716         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 717             , Messages.MISSING_IMPORT_FILE.formatMessage("Definitions/etsi_nfv_sol001_pnfd_2_5_2_types.yaml"))
 718         );
 719
 720         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 721     }
 722
 723     /**
 724      * Tests an imported descriptor with invalid import statement.
 725      */
 726     @Test
 727     public void testGivenDefinitionFileWithImportedDescriptor_whenInvalidImportStatementExistInImportedDescriptor_thenInvalidImportErrorOccur() {
 728         final ManifestBuilder manifestBuilder = getVnfManifestSampleBuilder();
 729
 730         handler.addFile(TOSCA_META_PATH_FILE_NAME, metaFile.getBytes(StandardCharsets.UTF_8));
 731         manifestBuilder.withSource(TOSCA_META_PATH_FILE_NAME);
 732
 733         handler.addFile(TOSCA_CHANGELOG_FILEPATH, "".getBytes(StandardCharsets.UTF_8));
 734         manifestBuilder.withSource(TOSCA_CHANGELOG_FILEPATH);
 735
 736         handler.addFile(SAMPLE_SOURCE, "".getBytes());
 737         manifestBuilder.withSource(SAMPLE_SOURCE);
 738
 739         final String definitionImportOne = "Definitions/importOne.yaml";
 740         handler.addFile(definitionImportOne, getResourceBytes("/validation.files/definition/definitionFileWithInvalidImport.yaml"));
 741         manifestBuilder.withSource(definitionImportOne);
 742
 743         final String definitionFileWithValidImports = "/validation.files/definition/definitionFileWithOneImport.yaml";
 744         handler.addFile(TOSCA_DEFINITION_FILEPATH, getResourceBytes(definitionFileWithValidImports));
 745         manifestBuilder.withSource(TOSCA_DEFINITION_FILEPATH);
 746
 747         manifestBuilder.withSource(TOSCA_MANIFEST_FILEPATH);
 748         handler.addFile(TOSCA_MANIFEST_FILEPATH, manifestBuilder.build().getBytes(StandardCharsets.UTF_8));
 749
 750         final Map<String, List<ErrorMessage>> actualErrorMap = sol004MetaDirectoryValidator.validateContent(handler, Collections.emptyList());
 751
 752         final List<ErrorMessage> expectedErrorList = new ArrayList<>();
 753         expectedErrorList.add(new ErrorMessage(ErrorLevel.ERROR
 754             , Messages.INVALID_IMPORT_STATEMENT.formatMessage(definitionImportOne, "null"))
 755         );
 756
 757         assertExpectedErrors(actualErrorMap.get(SdcCommon.UPLOAD_FILE), expectedErrorList);
 758     }
 759
 760     private void assertExpectedErrors(final String testCase, final Map<String, List<ErrorMessage>> errors, final int expectedErrors){
 761         final List<ErrorMessage> errorMessages = errors.get(SdcCommon.UPLOAD_FILE);
 762         printErrorMessages(errorMessages);
 763         if (expectedErrors > 0) {
 764             assertEquals(testCase, errorMessages.size(), expectedErrors);
 765         } else {
 766             assertEquals(testCase, errors.size(), expectedErrors);
 767         }
 768     }
 769
 770     private void printErrorMessages(final List<ErrorMessage> errorMessages) {
 771         if (CollectionUtils.isNotEmpty(errorMessages)) {
 772             errorMessages.forEach(errorMessage -> {
 773                 System.out.println(String.format("%s: %s", errorMessage.getLevel(), errorMessage.getMessage()));
 774             });
 775         }
 776     }
 777
 778     private byte[] getResourceBytes(final String resourcePath) {
 779         try {
 780             return ValidatorUtil.getFileResource(resourcePath);
 781         } catch (final IOException e) {
 782             final String errorMsg = String.format("Could not load resource '%s'", resourcePath);
 783             LOGGER.error(errorMsg, e);
 784             fail(errorMsg);
 785         }
 786
 787         return null;
 788     }
 789
 790     private ManifestBuilder getPnfManifestSampleBuilder() {
 791         return new ManifestBuilder()
 792             .withMetaData(PNFD_NAME, "myPnf")
 793             .withMetaData(PNFD_PROVIDER, "ACME")
 794             .withMetaData(PNFD_ARCHIVE_VERSION, "1.0")
 795             .withMetaData(PNFD_RELEASE_DATE_TIME, "2019-03-11T11:25:00+00:00");
 796     }
 797
 798     private ManifestBuilder getVnfManifestSampleBuilder() {
 799         return new ManifestBuilder()
 800             .withMetaData(VNF_PRODUCT_NAME, "RadioNode")
 801             .withMetaData(VNF_PROVIDER_ID, "ACME")
 802             .withMetaData(VNF_PACKAGE_VERSION, "1.0")
 803             .withMetaData(VNF_RELEASE_DATE_TIME, "2019-03-11T11:25:00+00:00");
 804     }
 805
 806     private void assertExpectedErrors(List<ErrorMessage> actualErrorList, final List<ErrorMessage> expectedErrorList) {
 807         if (actualErrorList == null) {
 808             actualErrorList = new ArrayList<>();
 809         }
 810
 811         assertThat("The actual error list should have the same size as the expected error list"
 812             , actualErrorList, hasSize(expectedErrorList.size())
 813         );
 814
 815         assertThat("The actual error and expected error lists should be the same"
 816             , actualErrorList, containsInAnyOrder(expectedErrorList.toArray(new ErrorMessage[0]))
 817         );
 818     }
 819
 820 }