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

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