common-app-api/src/test/java/org/openecomp/sdc/common/util/ValidationUtilsTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019 Nokia. All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.openecomp.sdc.common.util;
  23
  24 import com.google.common.collect.Lists;
  25 import org.junit.Test;
  26
  27 import java.util.Collections;
  28 import java.util.List;
  29
  30 import static junit.framework.TestCase.assertEquals;
  31 import static junit.framework.TestCase.assertFalse;
  32 import static junit.framework.TestCase.assertTrue;
  33
  34
  35 public class ValidationUtilsTest {
  36
  37         @Test
  38         public void checkValidateArtifactLabelReturnsTrueIfInputIsValid() {
  39                 final String testLabel = "testArtifactLabel";
  40
  41                 boolean result = ValidationUtils.validateArtifactLabel(testLabel);
  42
  43                 assertTrue(result);
  44         }
  45
  46         @Test
  47         public void checkValidateArtifactLabelReturnsFalseIfInputIsInvalid() {
  48                 final String testLabel = "wrong*()ArtifactLABEL+=";
  49
  50                 boolean result = ValidationUtils.validateArtifactLabel(testLabel);
  51
  52                 assertFalse(result);
  53         }
  54
  55         @Test
  56         public void checkValidateArtifactLabelReturnsFalseIfInputIsEmpty() {
  57                 final String testLabel = "";
  58
  59                 boolean result = ValidationUtils.validateArtifactLabel(testLabel);
  60
  61                 assertFalse(result);
  62         }
  63
  64         @Test
  65         public void checkValidateArtifactDisplayNameReturnsTrueIfInputIsValid() {
  66                 final String testDisplayName = "testDisplayName";
  67
  68                 boolean result = ValidationUtils.validateArtifactDisplayName(testDisplayName);
  69
  70                 assertTrue(result);
  71         }
  72
  73         @Test
  74         public void checkValidateArtifactDisplayNameReturnsFalseIfInputIsInvalid() {
  75                 final String testDisplayName = "wrong*()DisplayNAME+=";
  76
  77                 boolean result = ValidationUtils.validateArtifactDisplayName(testDisplayName);
  78
  79                 assertFalse(result);
  80         }
  81
  82         @Test
  83         public void checkValidateArtifactDisplayNameReturnsFalseIfInputIsEmpty() {
  84                 final String testDisplayName = "";
  85
  86                 boolean result = ValidationUtils.validateArtifactDisplayName(testDisplayName);
  87
  88                 assertFalse(result);
  89         }
  90
  91         @Test
  92         public void checkValidateCategoryDisplayNameFormatReturnsTrueIfInputIsValid() {
  93                 final String testCatalogDisplayName = "testCatalogDisplayName";
  94
  95                 boolean result = ValidationUtils.validateCategoryDisplayNameFormat(testCatalogDisplayName);
  96
  97                 assertTrue(result);
  98         }
  99
 100         @Test
 101         public void checkValidateCategoryDisplayNameLengthReturnsTrueIfNameIsBetweenMinAndMax() {
 102                 final String testCatalogDisplayName = "testCatalogDisplayName";
 103
 104                 boolean result = ValidationUtils.validateCategoryDisplayNameLength(testCatalogDisplayName);
 105
 106                 assertTrue(result);
 107         }
 108
 109         @Test
 110         public void checkValidateCategoryDisplayNameLengthReturnsFalseIfNameIsToLong() {
 111                 final String testCatalogDisplayName = "testCatalogVeryLongDisplayName";
 112
 113                 boolean result = ValidationUtils.validateCategoryDisplayNameLength(testCatalogDisplayName);
 114
 115                 assertFalse(result);
 116         }
 117
 118         @Test
 119         public void checkValidateCategoryDisplayNameLengthReturnsFalseIfNameIsToShort() {
 120                 final String testCatalogDisplayName = "Na";
 121
 122                 boolean result = ValidationUtils.validateCategoryDisplayNameLength(testCatalogDisplayName);
 123
 124                 assertFalse(result);
 125         }
 126
 127         @Test
 128         public void checkValidateProductFullNameLengthReturnsTrueIfNameIsBetweenMinAndMax() {
 129                 final String testProductFullName = "testProductFullName";
 130
 131                 boolean result = ValidationUtils.validateProductFullNameLength(testProductFullName);
 132
 133                 assertTrue(result);
 134         }
 135
 136         @Test
 137         public void checkValidateProductFullNameLengthReturnsTrueIfNameIsToLong() {
 138                 final String testProductFullName =
 139                                 "testProductVeryVeryLongFullNameThatIsToLong" +
 140                                                 "ToPassValidationBecauseItExceedsTheMaxLengthOfThatParameter";
 141
 142                 boolean result = ValidationUtils.validateProductFullNameLength(testProductFullName);
 143
 144                 assertFalse(result);
 145         }
 146
 147         @Test
 148         public void checkValidateProductFullNameLengthReturnsTrueIfNameIsToShort() {
 149                 final String testProductFullName = "tes";
 150
 151                 boolean result = ValidationUtils.validateProductFullNameLength(testProductFullName);
 152
 153                 assertFalse(result);
 154         }
 155
 156         @Test
 157         public void checkValidateArtifactLabelLengthReturnsTrueIfNameIsBetweenMinAndMax() {
 158                 final String testArtifactLabel = "testArtifactLabel";
 159
 160                 boolean result = ValidationUtils.validateArtifactLabelLength(testArtifactLabel);
 161
 162                 assertTrue(result);
 163         }
 164
 165         @Test
 166         public void checkValidateArtifactLabelLengthReturnsFalseIfNameIsToLong() {
 167                 final String testArtifactLabel = generateLongString(300);
 168
 169                 boolean result = ValidationUtils.validateArtifactLabelLength(testArtifactLabel);
 170
 171                 assertFalse(result);
 172         }
 173
 174         @Test
 175         public void checkValidateResourceInstanceNameLengthReturnsTrueIfNameIsBetweenMinAndMax() {
 176                 final String testResourceInstanceName = "testResourceInstanceName";
 177
 178                 boolean result = ValidationUtils.validateResourceInstanceNameLength(testResourceInstanceName);
 179
 180                 assertTrue(result);
 181         }
 182
 183         @Test
 184         public void checkValidateResourceInstanceNameReturnsTrueIfNameIsCorrect() {
 185                 final String testResourceInstanceName = "testResourceInstanceName";
 186
 187                 boolean result = ValidationUtils.validateResourceInstanceName(testResourceInstanceName);
 188
 189                 assertTrue(result);
 190         }
 191
 192         @Test
 193         public void checkValidateResourceInstanceNameReturnsFalseIfNameIsNotCorrect() {
 194                 final String testResourceInstanceName = "wrong!@#resourceInstance\nName=+";
 195
 196                 boolean result = ValidationUtils.validateResourceInstanceName(testResourceInstanceName);
 197
 198                 assertFalse(result);
 199         }
 200
 201         @Test
 202         public void checkValidateUrlLengthReturnsTrueIfUrlLengthIsBetweenMinAndMax() {
 203                 final String testURL = "test/url/";
 204
 205                 boolean result = ValidationUtils.validateUrlLength(testURL);
 206
 207                 assertTrue(result);
 208         }
 209
 210         @Test
 211         public void checkValidateUrlLengthReturnsFalseIfUrlLengthIsToLong() {
 212                 final String testURL = generateLongString(120);
 213
 214                 boolean result = ValidationUtils.validateUrlLength(testURL);
 215
 216                 assertFalse(result);
 217         }
 218
 219         @Test
 220         public void checkValidateArtifactNameLengthReturnsTrueIfUrlLengthIsBetweenMinAndMax() {
 221                 final String testArtifactNameLength = "testArtifact";
 222
 223                 boolean result = ValidationUtils.validateArtifactNameLength(testArtifactNameLength);
 224
 225                 assertTrue(result);
 226         }
 227
 228         @Test
 229         public void checkValidateArtifactNameLengthReturnsFalseIfUrlLengthIsToLong() {
 230                 final String testArtifactNameLength = generateLongString(260);
 231
 232                 boolean result = ValidationUtils.validateArtifactNameLength(testArtifactNameLength);
 233
 234                 assertFalse(result);
 235         }
 236
 237         @Test
 238         public void checkValidateComponentNamePatternReturnsTrueIfNameMatchesPattern() {
 239                 final String testComponentName = "testComponent";
 240
 241                 boolean result = ValidationUtils.validateComponentNamePattern(testComponentName);
 242
 243                 assertTrue(result);
 244         }
 245
 246         @Test
 247         public void checkValidateComponentNamePatternReturnsFalseIfNameDoesNotMatchesPattern() {
 248                 final String testComponentName = "testWRONG!@#Component+!";
 249
 250                 boolean result = ValidationUtils.validateComponentNamePattern(testComponentName);
 251
 252                 assertFalse(result);
 253         }
 254
 255         @Test
 256         public void checkValidateComponentNameLengthReturnsTrueIfNameLengthIsBetweenMinAndMax() {
 257                 final String testComponentName = "testComponent";
 258
 259                 boolean result = ValidationUtils.validateComponentNameLength(testComponentName);
 260
 261                 assertTrue(result);
 262         }
 263
 264         @Test
 265         public void checkValidateComponentNameLengthReturnsFalseIfNameLengthIsToLong() {
 266                 final String testComponentName = generateLongString(1100);
 267
 268                 boolean result = ValidationUtils.validateComponentNameLength(testComponentName);
 269
 270                 assertFalse(result);
 271         }
 272
 273         @Test
 274         public void checkValidateIconReturnsTrueIfIconMatchesPattern() {
 275                 final String testIcon = "icon";
 276
 277                 boolean result = ValidationUtils.validateIcon(testIcon);
 278
 279                 assertTrue(result);
 280         }
 281
 282         @Test
 283         public void checkValidateIconReturnsFalseIfIconDoesNotMatchesPattern() {
 284                 final String testIcon = "icon,";
 285
 286                 boolean result = ValidationUtils.validateIcon(testIcon);
 287
 288                 assertFalse(result);
 289         }
 290
 291         @Test
 292         public void checkValidateIconLengthReturnsTrueIfILengthIsBetweenMinAndMax() {
 293                 final String testIcon = "icon";
 294
 295                 boolean result = ValidationUtils.validateIconLength(testIcon);
 296
 297                 assertTrue(result);
 298         }
 299
 300         @Test
 301         public void checkValidateIconLengthReturnsTrueFalseIfILengthIsToLong() {
 302                 final String testIcon = generateLongString(30);
 303
 304                 boolean result = ValidationUtils.validateIconLength(testIcon);
 305
 306                 assertFalse(result);
 307         }
 308
 309         @Test
 310         public void checkValidateProjectCodeReturnsTrueIfCodeMatchesPattern() {
 311                 final String testProjectCode = "testProjectCode";
 312
 313                 boolean result = ValidationUtils.validateProjectCode(testProjectCode);
 314
 315                 assertTrue(result);
 316         }
 317
 318         @Test
 319         public void checkValidateProjectCodeReturnsFalseIfCodeDoesNotMatchesPattern() {
 320                 final String testProjectCode = "testWRONG!@#ProjectCode";
 321
 322                 boolean result = ValidationUtils.validateProjectCode(testProjectCode);
 323
 324                 assertFalse(result);
 325         }
 326
 327         @Test
 328         public void checkValidateProjectCodeLengthReturnsTrueIfCodeMatchesPattern() {
 329                 final String testProjectCode = "testProjectCode";
 330
 331                 boolean result = ValidationUtils.validateProjectCodeLegth(testProjectCode);
 332
 333                 assertTrue(result);
 334         }
 335
 336         @Test
 337         public void checkValidateContactIdReturnsTrueIfIdMatchesPattern() {
 338                 final String testContactId = "testContactId";
 339
 340                 boolean result = ValidationUtils.validateContactId(testContactId);
 341
 342                 assertTrue(result);
 343         }
 344
 345         @Test
 346         public void checkValidateCostReturnsTrueIfIdMatchesPattern() {
 347                 final String testCost = "120.15";
 348
 349                 boolean result = ValidationUtils.validateCost(testCost);
 350
 351                 assertTrue(result);
 352         }
 353
 354         @Test
 355         public void validateRemoveHtmlTagsReturnsStringWithNoHTMLTags() {
 356                 final String htmlString = "<div>test with <p>tags</p></div>";
 357
 358                 String result = ValidationUtils.removeHtmlTags(htmlString);
 359
 360                 assertEquals(result, "test with tags");
 361         }
 362
 363         @Test
 364         public void validateRemoveAllTagsReturnsStringWithNoHTMLTags() {
 365                 final String htmlString = "<div>test with <p>tags</p></div>";
 366
 367                 String result = ValidationUtils.removeAllTags(htmlString);
 368
 369                 assertEquals(result, "test with tags");
 370         }
 371
 372         @Test
 373         public void validateNormalizeWhitespaceReturnsStringWithNormalizedWhitespace() {
 374                 final String whitespaceString = "test   normalize  whitespace";
 375
 376                 String result = ValidationUtils.normaliseWhitespace(whitespaceString);
 377
 378                 assertEquals(result, "test normalize whitespace");
 379         }
 380
 381         @Test
 382         public void validateStripOctetsReturnsStringWithNormalizedWhitespace() {
 383                 final String octedString = "%2Dtest strip octets text";
 384
 385                 String result = ValidationUtils.stripOctets(octedString);
 386
 387                 assertEquals(result, "test strip octets text");
 388         }
 389
 390         @Test
 391         public void validateRemoveNoneUtf8CharsRemovesCharacterThatAreNotFromUtf8() {
 392                 final String nonUtf8String = "test קקUtf8 קק textקק";
 393
 394                 String result = ValidationUtils.removeNoneUtf8Chars(nonUtf8String);
 395
 396                 assertEquals(result, "test Utf8  text");
 397         }
 398
 399         @Test
 400         public void validateIsEnglishReturnsTrueIfStringContainsOnlyEnglishCharacters() {
 401                 final String nonUtf8String = "test english text";
 402
 403                 boolean result = ValidationUtils.validateIsEnglish(nonUtf8String);
 404
 405                 assertTrue(result);
 406         }
 407
 408         @Test
 409         public void validateIsEnglishReturnsFalseIfStringContainsNoEnglishCharacters() {
 410                 final String nonUtf8String = "test noEnglish text文";
 411
 412                 boolean result = ValidationUtils.validateIsEnglish(nonUtf8String);
 413
 414                 assertFalse(result);
 415         }
 416
 417         @Test
 418         public void validateIsAsciiReturnsTrueIfStringContainsOnlyAsciiCharacters() {
 419                 final String testAsciiText = "ascii text";
 420
 421                 boolean result = ValidationUtils.validateIsAscii(testAsciiText);
 422
 423                 assertTrue(result);
 424         }
 425
 426         @Test
 427         public void validateIsAsciiReturnsFalseIfStringContainsNotAsciiCharacter() {
 428                 final String testAsciiText = "no ascii text ┬á";
 429
 430                 boolean result = ValidationUtils.validateIsAscii(testAsciiText);
 431
 432                 assertFalse(result);
 433         }
 434
 435         @Test
 436         public void validateConvertHtmlTagsToEntitiesReturnsStringWithReplacedTags() {
 437                 final String testAsciiText = "<div>ascii text</div>";
 438
 439                 String result = ValidationUtils.convertHtmlTagsToEntities(testAsciiText);
 440
 441                 assertEquals(result, "&lt;div&gt;ascii text&lt;/div&gt;");
 442         }
 443
 444
 445         @Test
 446         public void validateRemoveDuplicateFromListReturnsListWithoutDuplicates() {
 447                 List<String> listOfDuplicates =
 448                                 Lists.newArrayList("text01","text01","text02","text02","text02","text03");
 449
 450                 List<String> result = ValidationUtils.removeDuplicateFromList(listOfDuplicates);
 451
 452                 assertTrue(result.containsAll(Lists.newArrayList("text01","text03","text03")));
 453                 assertEquals(result.size(), 3);
 454         }
 455
 456         @Test
 457         public void checkValidateTagLengthReturnsTrueIfTagIsBetweenMaxAndMin() {
 458                 final String testTag = "testTag";
 459
 460                 boolean result = ValidationUtils.validateTagLength(testTag);
 461
 462                 assertTrue(result);
 463         }
 464
 465         @Test
 466         public void checkValidateTagLengthReturnsFalseIfTagIsToLong() {
 467                 final String testTag = generateLongString(1200);
 468
 469                 boolean result = ValidationUtils.validateTagLength(testTag);
 470
 471                 assertFalse(result);
 472         }
 473
 474         @Test
 475         public void checkValidateTagLengthReturnsFalseIfTagIsNull() {
 476                 boolean result = ValidationUtils.validateTagLength(null);
 477
 478                 assertFalse(result);
 479         }
 480
 481         @Test
 482         public void validateValidateTagListLengthReturnsTrueIfListIsBetweenMaxAndMin() {
 483                 boolean result = ValidationUtils.validateTagListLength(5);
 484
 485                 assertTrue(result);
 486         }
 487
 488         @Test
 489         public void validateValidateTagListLengthReturnsFalseIfListIsToLong() {
 490                 boolean result = ValidationUtils.validateTagListLength(1250);
 491
 492                 assertFalse(result);
 493         }
 494
 495         @Test
 496         public void checkCalidateListNotEmptyReturnsTrueIfListIsNotEmpty() {
 497                 boolean result = ValidationUtils.validateListNotEmpty(Collections.singletonList("testItem"));
 498
 499                 assertTrue(result);
 500         }
 501
 502         @Test
 503         public void checkCalidateListNotEmptyReturnsFalseIfListIsEmpty() {
 504                 boolean result = ValidationUtils.validateListNotEmpty(Collections.emptyList());
 505
 506                 assertFalse(result);
 507         }
 508
 509         @Test
 510         public void checkValidateDescriptionLengthTestReturnsTrueIfTagIsBetweenMaxAndMin() {
 511                 final String testDescription = "testDescription";
 512
 513                 boolean result = ValidationUtils.validateDescriptionLength(testDescription);
 514
 515                 assertTrue(result);
 516         }
 517
 518         @Test
 519         public void checkValidateDescriptionLengthTestReturnsFalseIfTagIsToLong() {
 520                 final String testDescription =  generateLongString(1200);
 521
 522                 boolean result = ValidationUtils.validateDescriptionLength(testDescription);
 523
 524                 assertFalse(result);
 525         }
 526
 527         @Test
 528         public void checkValidateStringNotEmptyReturnsFalseIfStringIsNotEmpty() {
 529                 final String testString =  "test";
 530
 531                 boolean result = ValidationUtils.validateStringNotEmpty(testString);
 532
 533                 assertTrue(result);
 534         }
 535
 536         @Test
 537         public void checkValidateStringNotEmptyReturnsFTrueIfStringIsEmpty() {
 538                 final String testString =  "";
 539
 540                 boolean result = ValidationUtils.validateStringNotEmpty(testString);
 541
 542                 assertFalse(result);
 543         }
 544
 545         @Test
 546         public void checkValidateVendorNameReturnsTrueIfNameFitsPattern() {
 547                 final String testVendorName =  "testVendor";
 548
 549                 boolean result = ValidationUtils.validateVendorName(testVendorName);
 550
 551                 assertTrue(result);
 552         }
 553
 554         @Test
 555         public void checkValidateVendorNameReturnsFalseIfNameDoesNotFitsPattern() {
 556                 final String testVendorName =  "test:Vendor";
 557
 558                 boolean result = ValidationUtils.validateVendorName(testVendorName);
 559
 560                 assertFalse(result);
 561         }
 562
 563         @Test
 564         public void checkValidateVendorNameLengthReturnsTrueIfNameIsBetweenMaxAndMin() {
 565                 final String testVendorName =  "testVendor";
 566
 567                 boolean result = ValidationUtils.validateVendorNameLength(testVendorName);
 568
 569                 assertTrue(result);
 570         }
 571
 572         @Test
 573         public void checkValidateVendorNameLengthReturnsFalseIfNameIsToLong() {
 574                 final String testVendorName =  generateLongString(90);
 575
 576                 boolean result = ValidationUtils.validateVendorNameLength(testVendorName);
 577
 578                 assertFalse(result);
 579         }
 580
 581         @Test
 582         public void checkValidateResourceVendorModelNumberLengthReturnsTrueIfNameIsBetweenMaxAndMin() {
 583                 final String testVendorName =  "testVendor";
 584
 585                 boolean result = ValidationUtils.validateResourceVendorModelNumberLength(testVendorName);
 586
 587                 assertTrue(result);
 588         }
 589
 590         @Test
 591         public void checkValidateResourceVendorModelNumberLengthReturnsFalseIfNameIsToLong() {
 592                 final String testVendorName =  generateLongString(90);
 593
 594                 boolean result = ValidationUtils.validateResourceVendorModelNumberLength(testVendorName);
 595
 596                 assertFalse(result);
 597         }
 598
 599         @Test
 600         public void checkValidateVendorReleaseReturnsTrueIfReleaseFitsPattern() {
 601                 final String testVendorRelease =  "testVendorRelease";
 602
 603                 boolean result = ValidationUtils.validateVendorRelease(testVendorRelease);
 604
 605                 assertTrue(result);
 606         }
 607
 608         @Test
 609         public void checkValidateVendorReleaseReturnsFalseIfReleaseDoesNotFitsPattern() {
 610                 final String testVendorRelease =  "testVendor:Release";
 611
 612                 boolean result = ValidationUtils.validateVendorRelease(testVendorRelease);
 613
 614                 assertFalse(result);
 615         }
 616
 617         @Test
 618         public void checkValidateVendorReleaseLengthReturnsTrueIfReleaseIsBetweenMaxAndMin() {
 619                 final String testVendorRelease =  "testVendorRelease";
 620
 621                 boolean result = ValidationUtils.validateVendorReleaseLength(testVendorRelease);
 622
 623                 assertTrue(result);
 624         }
 625
 626         @Test
 627         public void checkValidateVendorReleaseLengthReturnsFalseIfReleaseIsToLong() {
 628                 final String testVendorRelease =  generateLongString(30);
 629
 630                 boolean result = ValidationUtils.validateVendorReleaseLength(testVendorRelease);
 631
 632                 assertFalse(result);
 633         }
 634
 635         @Test
 636         public void checkValidateServiceTypeLengthReturnsTrueIfReleaseIsBetweenMaxAndMin() {
 637                 final String testServiceType =  "testServiceType";
 638
 639                 boolean result = ValidationUtils.validateServiceTypeLength(testServiceType);
 640
 641                 assertTrue(result);
 642         }
 643
 644         @Test
 645         public void checkValidateServiceTypeLengthReturnsFalseIfReleaseIsToLong() {
 646                 final String testServiceType =  generateLongString(500);
 647
 648                 boolean result = ValidationUtils.validateServiceTypeLength(testServiceType);
 649
 650                 assertFalse(result);
 651         }
 652
 653         @Test
 654         public void checkValidateServiceRoleLengthReturnsTrueIfReleaseIsBetweenMaxAndMin() {
 655                 final String testServiceRoleLength =  "testServiceType";
 656
 657                 boolean result = ValidationUtils.validateServiceRoleLength(testServiceRoleLength);
 658
 659                 assertTrue(result);
 660         }
 661
 662         @Test
 663         public void checkValidateServiceRoleLengthReturnsFalseIfReleaseIsToLong() {
 664                 final String testServiceRoleLength =  generateLongString(500);
 665
 666                 boolean result = ValidationUtils.validateServiceRoleLength(testServiceRoleLength);
 667
 668                 assertFalse(result);
 669         }
 670
 671         @Test
 672         public void validateHasBeenCertifiedReturnsTrueIfVersionIsEqualOrBiggerThan1() {
 673                 final String testVersion = "1.0";
 674
 675                 boolean result = ValidationUtils.hasBeenCertified(testVersion);
 676
 677                 assertTrue(result);
 678         }
 679
 680         @Test
 681         public void validateHasBeenCertifiedReturnsFalseIfVersionIsSmallerThan1() {
 682                 final String testVersion = "0.6";
 683
 684                 boolean result = ValidationUtils.hasBeenCertified(testVersion);
 685
 686                 assertFalse(result);
 687         }
 688
 689         @Test
 690         public void validateNormaliseComponentNameReturnsNormalizedName() {
 691                 final String testName = "test-Component-Service";
 692
 693                 String result = ValidationUtils.normaliseComponentName(testName);
 694
 695                 assertEquals(result, "testcomponentservice");
 696         }
 697
 698         @Test
 699         public void validateNormaliseComponentInstanceNameReturnsNormalizedName() {
 700                 final String testName = "test-Component-Service";
 701
 702                 String result = ValidationUtils.normalizeComponentInstanceName(testName);
 703
 704                 assertEquals(result, "testcomponentservice");
 705         }
 706
 707         @Test
 708         public void validateConvertToSystemNameReturnsProperSystemName() {
 709                 final String testName = "test-Component-Service";
 710
 711                 String result = ValidationUtils.convertToSystemName(testName);
 712
 713                 assertEquals(result, "TestComponentService");
 714         }
 715
 716         @Test
 717         public void validateNormalizeFileNameReturnsNormalizedName() {
 718                 final String testName = "test File Name";
 719
 720                 String result = ValidationUtils.normalizeFileName(testName);
 721
 722                 assertEquals(result, "test-File-Name");
 723         }
 724
 725         @Test
 726         public void checkValidateUrlReturnsTrueIfURLIsValid() {
 727                 final String testUrl = "http://test.co/valid/url/";
 728
 729                 boolean result = ValidationUtils.validateUrl(testUrl);
 730
 731                 assertTrue(result);
 732         }
 733
 734         @Test
 735         public void checkValidateUrlReturnsFalseIfURLIsNotValid() {
 736                 final String testUrl = "http//notvalid!#url";
 737
 738                 boolean result = ValidationUtils.validateUrl(testUrl);
 739
 740                 assertFalse(result);
 741         }
 742
 743         @Test
 744         public void checkValidateUrlReturnsFalseIfURLIsNotUtf8() {
 745                 final String testUrl = "http://test.co/notutf/קקurl/";
 746
 747                 boolean result = ValidationUtils.validateUrl(testUrl);
 748
 749                 assertFalse(result);
 750         }
 751
 752         @Test
 753         public void validateNormalizeArtifactLabelReturnsNormalizeArtifactLabel() {
 754                 final String testArtifactLabel = "test-File-Name";
 755
 756                 String result = ValidationUtils.normalizeArtifactLabel(testArtifactLabel);
 757
 758                 assertEquals(result, "testfilename");
 759         }
 760
 761         @Test
 762         public void validateAdditionalInformationKeyNameReturnsTrueIfAdditionalInformationAreValid() {
 763                 final String testAdditionalInformationKeyName = "KeyName";
 764
 765                 boolean result = ValidationUtils.validateAdditionalInformationKeyName(testAdditionalInformationKeyName);
 766
 767                 assertTrue(result);
 768         }
 769
 770         @Test
 771         public void validateNormalizeAdditionalInformationReturnsNormalizeArtifactLabel() {
 772                 final String testArtifactLabel = "additional--Information__Testing";
 773
 774                 String result = ValidationUtils.normalizeAdditionalInformation(testArtifactLabel);
 775
 776                 assertEquals(result, "additional-Information_Testing");
 777         }
 778
 779         @Test
 780         public void checkValidateLengthReturnsTrueIfStringIsShorterThenGivenLength() {
 781                 final String testString = "testString";
 782
 783                 boolean result = ValidationUtils.validateLength(testString,50);
 784
 785                 assertTrue(result);
 786         }
 787
 788         @Test
 789         public void checkValidateLengthReturnsTrueIfStringIsNull() {
 790                 boolean result = ValidationUtils.validateLength(null,50);
 791
 792                 assertTrue(result);
 793         }
 794
 795         @Test
 796         public void checkValidateLengthReturnsTrueIfStringIsExitsTheGivenLength() {
 797                 final String testString = "testString";
 798
 799                 boolean result = ValidationUtils.validateLength(testString,5);
 800
 801                 assertFalse(result);
 802         }
 803
 804         @Test
 805         public void validateIsUTF8StrReturnsFalseIfGivenStringContainsUtf8Character() {
 806                 final String testString = "testקString";
 807
 808                 boolean result = ValidationUtils.isUTF8Str(testString);
 809
 810                 assertFalse(result);
 811         }
 812
 813         @Test
 814         public void validateIsUTF8StrReturnsTrueIfGivenStringDoesNotContainsUtf8Character() {
 815                 final String testString = "testString";
 816
 817                 boolean result = ValidationUtils.isUTF8Str(testString);
 818
 819                 assertTrue(result);
 820         }
 821
 822         @Test
 823         public void validateIsFloatNumberReturnsTrueIfGivenStringRepresentsFloatNumber() {
 824                 final String testString = "12.45";
 825
 826                 boolean result = ValidationUtils.isFloatNumber(testString);
 827
 828                 assertTrue(result);
 829         }
 830
 831         @Test
 832         public void validateIsFloatNumberReturnsFalseIfGivenStringDoesNotRepresentsFloatNumber() {
 833                 final String testString = "notFloatingPoint";
 834
 835                 boolean result = ValidationUtils.isFloatNumber(testString);
 836
 837                 assertFalse(result);
 838         }
 839
 840         @Test
 841         public void validateCertifiedVersionReturnsTrueIfGivenStringRepresentsVersion() {
 842                 final String testString = "1.0";
 843
 844                 boolean result = ValidationUtils.validateCertifiedVersion(testString);
 845
 846                 assertTrue(result);
 847         }
 848
 849         @Test
 850         public void validateCertifiedVersionReturnsFalseIfGivenStringDoesNotRepresentsVersion() {
 851                 final String testString = "notVersion";
 852
 853                 boolean result = ValidationUtils.validateCertifiedVersion(testString);
 854
 855                 assertFalse(result);
 856         }
 857
 858         @Test
 859         public void validateMinorVersionReturnsTrueIfGivenStringRepresentsMinorVersion() {
 860                 final String testString = "0.1";
 861
 862                 boolean result = ValidationUtils.validateMinorVersion(testString);
 863
 864                 assertTrue(result);
 865         }
 866
 867         @Test
 868         public void validateMinorVersionReturnsFalseIfGivenStringDoesNotRepresentsMinorVersion() {
 869                 final String testString = "notMinorVersion";
 870
 871                 boolean result = ValidationUtils.validateMinorVersion(testString);
 872
 873                 assertFalse(result);
 874         }
 875
 876         @Test
 877         public void validateCleanArtifactDisplayNameReturnsCleanedArtifactName() {
 878                 final String testArtifactDisplayName = "  test-File   Name";
 879
 880                 String result = ValidationUtils.cleanArtifactDisplayName(testArtifactDisplayName);
 881
 882                 assertEquals(result, "test-File Name");
 883         }
 884
 885         @Test
 886         public void checkValidateArtifactLabelReturnsTrueIfLabelIsValid() {
 887                 final String testArtifactDisplayName = "testLabel";
 888
 889                 boolean result = ValidationUtils.validateArtifactLabel(testArtifactDisplayName);
 890
 891                 assertTrue(result);
 892         }
 893
 894         @Test
 895         public void checkValidateArtifactLabelReturnsFalseIfLabelIsNotValid() {
 896                 final String testArtifactDisplayName = "test=notValid=Label";
 897
 898                 boolean result = ValidationUtils.validateArtifactLabel(testArtifactDisplayName);
 899
 900                 assertFalse(result);
 901         }
 902
 903         @Test
 904         public void checkValidateConsumerNameReturnsTrueIfLabelIsValid() {
 905                 final String testConsumerName = "testConsumerName";
 906
 907                 boolean result = ValidationUtils.validateConsumerName(testConsumerName);
 908
 909                 assertTrue(result);
 910         }
 911
 912         @Test
 913         public void checkValidateConsumerNameReturnsFalseIfLabelIsNotValid() {
 914                 final String testConsumerName = "test=notValid=ConsumerName";
 915
 916                 boolean result = ValidationUtils.validateConsumerName(testConsumerName);
 917
 918                 assertFalse(result);
 919         }
 920
 921         @Test
 922         public void checkValidateConsumerPassSaltReturnsTrueIfLabelIsValid() {
 923                 final String testPassSalt = "123qwe";
 924
 925                 boolean result = ValidationUtils.validateConsumerPassSalt(testPassSalt);
 926
 927                 assertTrue(result);
 928         }
 929
 930         @Test
 931         public void checkValidateConsumerPassSaltReturnsFalseIfLabelIsNotValid() {
 932                 final String testPassSalt = "_123qweLO";
 933
 934                 boolean result = ValidationUtils.validateConsumerPassSalt(testPassSalt);
 935
 936                 assertFalse(result);
 937         }
 938
 939         @Test
 940         public void checkValidateCategoryNameFormatReturnsTrueIfLabelIsValid() {
 941                 final String testDisplayNameFormat = "DisplayNameFormat";
 942
 943                 boolean result = ValidationUtils.validateCategoryDisplayNameFormat(testDisplayNameFormat);
 944
 945                 assertTrue(result);
 946         }
 947
 948         @Test
 949         public void checkValidateCategoryNameFormatReturnsFalseIfLabelIsNotValid() {
 950                 final String testDisplayNameFormat = "Display{NotValid}NameFormat";
 951
 952                 boolean result = ValidationUtils.validateCategoryDisplayNameFormat(testDisplayNameFormat);
 953
 954                 assertFalse(result);
 955         }
 956
 957         @Test
 958         public void checkValidateCategoryNameFormatReturnsFalseIfLabelIsStartingWihNonAlphabetical() {
 959                 final String testDisplayNameFormat = "@DisplayNameFormat";
 960
 961                 boolean result = ValidationUtils.validateCategoryDisplayNameFormat(testDisplayNameFormat);
 962
 963                 assertFalse(result);
 964         }
 965
 966         @Test
 967         public void checkValidateCategoryNameLengthReturnsTrueIfLabelLengthIsBetweenMinaAndMax() {
 968                 final String testDisplayNameFormat = "DisplayNameFormat";
 969
 970                 boolean result = ValidationUtils.validateCategoryDisplayNameLength(testDisplayNameFormat);
 971
 972                 assertTrue(result);
 973         }
 974
 975         @Test
 976         public void checkValidateCategoryNameLengthReturnsFalseIfLabelLengthIsToLong() {
 977                 final String testDisplayNameFormat = generateLongString(28);
 978
 979                 boolean result = ValidationUtils.validateCategoryDisplayNameLength(testDisplayNameFormat);
 980
 981                 assertFalse(result);
 982         }
 983
 984         @Test
 985         public void validateNormalizeCategoryNameReturnsNormalizeName() {
 986                 final String testCatalogName = "not Normalize OF CatalogName";
 987
 988                 String result = ValidationUtils.normalizeCategoryName4Display(testCatalogName);
 989
 990                 assertEquals(result, "Not Normalize of CatalogName");
 991         }
 992
 993         @Test
 994         public void validateNormalizeCategoryLabelReturnsNormalizeLabel() {
 995                 final String testCatalogLabel = "not Normalize OF CatalogLabel";
 996
 997                 String result = ValidationUtils.normalizeCategoryName4Uniqueness(testCatalogLabel);
 998
 999                 assertEquals(result, "not normalize of cataloglabel");
1000         }
1001
1002         @Test
1003         public void validateNormaliseProductNameReturnsNormalizedName() {
1004                 final String testProductName = "Product Name";
1005
1006                 String result = ValidationUtils.normaliseProductName(testProductName);
1007
1008                 assertEquals(result, "productname");
1009
1010         }
1011
1012         @Test
1013         public void validateRemoveHtmlTagsOnlyReturnsStringWithRemovedHtmlTags() {
1014                 final String testHtml = "<div>Product <p>Name</p> <not html tag></div>";
1015
1016                 String result = ValidationUtils.removeHtmlTagsOnly(testHtml);
1017
1018                 assertEquals(result, "Product Name <not html tag>");
1019
1020         }
1021
1022         @Test
1023         public void checkValidateForwardingPathNamePatternReturnsTrueIfPathIsValid() {
1024                 final String testForwardingPath = "test.forwarding.path";
1025
1026                 boolean result = ValidationUtils.validateForwardingPathNamePattern(testForwardingPath);
1027
1028                 assertTrue(result);
1029         }
1030
1031         @Test
1032         public void checkValidateForwardingPathNamePatternReturnsFalseIfPathIsNotValid() {
1033                 final String testForwardingPath = "test/notValid/forwarding//path";
1034
1035                 boolean result = ValidationUtils.validateForwardingPathNamePattern(testForwardingPath);
1036
1037                 assertFalse(result);
1038         }
1039
1040         private String generateLongString(int length) {
1041                 StringBuilder toLongLabelBuilder = new StringBuilder();
1042                 for(int i=0 ; i<=length ; i++) {
1043                         toLongLabelBuilder.append("t");
1044                 }
1045                 return toLongLabelBuilder.toString();
1046         }
1047 }