gerrit.onap Code Review - sdc.git/blob

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