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