gerrit.akraino Code Review - icn/sdwan.git/blob

   1 // SPDX-License-Identifier: Apache-2.0\r
   2 // Copyright (c) 2020 Intel Corporation\r
   3 \r
   4 package validation\r
   5 \r
   6 import (\r
   7         "bytes"\r
   8         "testing"\r
   9 )\r
  10 \r
  11 func TestIsTarGz(t *testing.T) {\r
  12 \r
  13         t.Run("Valid tar.gz", func(t *testing.T) {\r
  14                 content := []byte{\r
  15                         0x1f, 0x8b, 0x08, 0x08, 0xb0, 0x6b, 0xf4, 0x5b,\r
  16                         0x00, 0x03, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74,\r
  17                         0x61, 0x72, 0x00, 0xed, 0xce, 0x41, 0x0a, 0xc2,\r
  18                         0x30, 0x10, 0x85, 0xe1, 0xac, 0x3d, 0x45, 0x4e,\r
  19                         0x50, 0x12, 0xd2, 0xc4, 0xe3, 0x48, 0xa0, 0x01,\r
  20                         0x4b, 0x52, 0x0b, 0xed, 0x88, 0x1e, 0xdf, 0x48,\r
  21                         0x11, 0x5c, 0x08, 0xa5, 0x8b, 0x52, 0x84, 0xff,\r
  22                         0xdb, 0xbc, 0x61, 0x66, 0x16, 0x4f, 0xd2, 0x2c,\r
  23                         0x8d, 0x3c, 0x45, 0xed, 0xc8, 0x54, 0x21, 0xb4,\r
  24                         0xef, 0xb4, 0x67, 0x6f, 0xbe, 0x73, 0x61, 0x9d,\r
  25                         0xb2, 0xce, 0xd5, 0x55, 0xf0, 0xde, 0xd7, 0x3f,\r
  26                         0xdb, 0xd6, 0x49, 0x69, 0xb3, 0x67, 0xa9, 0x8f,\r
  27                         0xfb, 0x2c, 0x71, 0xd2, 0x5a, 0xc5, 0xee, 0x92,\r
  28                         0x73, 0x8e, 0x43, 0x7f, 0x4b, 0x3f, 0xff, 0xd6,\r
  29                         0xee, 0x7f, 0xea, 0x9a, 0x4a, 0x19, 0x1f, 0xe3,\r
  30                         0x54, 0xba, 0xd3, 0xd1, 0x55, 0x00, 0x00, 0x00,\r
  31                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  32                         0x00, 0x00, 0x00, 0x1b, 0xbc, 0x00, 0xb5, 0xe8,\r
  33                         0x4a, 0xf9, 0x00, 0x28, 0x00, 0x00,\r
  34                 }\r
  35 \r
  36                 err := IsTarGz(bytes.NewBuffer(content))\r
  37                 if err != nil {\r
  38                         t.Errorf("Error reading valid tar.gz file %s", err.Error())\r
  39                 }\r
  40         })\r
  41 \r
  42         t.Run("Invalid tar.gz", func(t *testing.T) {\r
  43                 content := []byte{\r
  44                         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,\r
  45                         0x00, 0xff, 0xf2, 0x48, 0xcd,\r
  46                 }\r
  47 \r
  48                 err := IsTarGz(bytes.NewBuffer(content))\r
  49                 if err == nil {\r
  50                         t.Errorf("Error should NOT be nil")\r
  51                 }\r
  52         })\r
  53 \r
  54         t.Run("Empty tar.gz", func(t *testing.T) {\r
  55                 content := []byte{}\r
  56                 err := IsTarGz(bytes.NewBuffer(content))\r
  57                 if err == nil {\r
  58                         t.Errorf("Error should NOT be nil")\r
  59                 }\r
  60         })\r
  61 }\r
  62 \r
  63 func TestIsValidName(t *testing.T) {\r
  64         t.Run("Valid Names", func(t *testing.T) {\r
  65                 validnames := []string{\r
  66                         "abc123",\r
  67                         "1_abc123.ONE",\r
  68                         "0abcABC_-.5",\r
  69                         "123456789012345678901234567890123456789012345678901234567890123", // max of 63 characters\r
  70                 }\r
  71                 for _, name := range validnames {\r
  72                         errs := IsValidName(name)\r
  73                         if len(errs) > 0 {\r
  74                                 t.Errorf("Valid name failed to pass: %v", name)\r
  75                         }\r
  76                 }\r
  77         })\r
  78 \r
  79         t.Run("Invalid Names", func(t *testing.T) {\r
  80                 invalidnames := []string{\r
  81                         "",               // empty\r
  82                         "_abc123",        // starts with non-alphanum\r
  83                         "-abc123",        // starts with non-alphanum\r
  84                         ".abc123",        // starts with non-alphanum\r
  85                         "abc123-",        // ends with non-alphanum\r
  86                         "abc123_",        // ends with non-alphanum\r
  87                         "abc123.",        // ends with non-alphanum\r
  88                         "1_abc-123.O=NE", // contains not allowed character\r
  89                         "1_a/bc-123.ONE", // contains not allowed character\r
  90                         "1234567890123456789012345678901234567890123456789012345678901234", // longer than 63 characters\r
  91                 }\r
  92                 for _, name := range invalidnames {\r
  93                         errs := IsValidName(name)\r
  94                         if len(errs) == 0 {\r
  95                                 t.Errorf("Invalid name passed: %v", name)\r
  96                         }\r
  97                 }\r
  98         })\r
  99 }\r
 100 \r
 101 func TestIsIpv4Cidr(t *testing.T) {\r
 102         t.Run("Valid IPv4 Cidr", func(t *testing.T) {\r
 103                 validipv4cidr := []string{\r
 104                         "1.2.3.4/32",\r
 105                         "10.11.12.0/24",\r
 106                         "192.168.1.2/8",\r
 107                         "255.0.0.0/16",\r
 108                 }\r
 109                 for _, ip := range validipv4cidr {\r
 110                         err := IsIpv4Cidr(ip)\r
 111                         if err != nil {\r
 112                                 t.Errorf("Valid IPv4 CIDR string failed to pass: %v", ip)\r
 113                         }\r
 114                 }\r
 115         })\r
 116 \r
 117         t.Run("Invalid IPv4 Cidr", func(t *testing.T) {\r
 118                 invalidipv4cidr := []string{\r
 119                         "",\r
 120                         "1.2.3.4.5/32",\r
 121                         "1.2.3.415/16",\r
 122                         "1.2.3.4/33",\r
 123                         "2.3.4/24",\r
 124                         "1.2.3.4",\r
 125                         "1.2.3.4/",\r
 126                 }\r
 127                 for _, ip := range invalidipv4cidr {\r
 128                         err := IsIpv4Cidr(ip)\r
 129                         if err == nil {\r
 130                                 t.Errorf("Invalid IPv4 Cidr passed: %v", ip)\r
 131                         }\r
 132                 }\r
 133         })\r
 134 }\r
 135 \r
 136 func TestIsIpv4(t *testing.T) {\r
 137         t.Run("Valid IPv4", func(t *testing.T) {\r
 138                 validipv4 := []string{\r
 139                         "1.2.3.42",\r
 140                         "10.11.12.0",\r
 141                         "192.168.1.2",\r
 142                         "255.0.0.0",\r
 143                         "255.255.255.255",\r
 144                         "0.0.0.0",\r
 145                 }\r
 146                 for _, ip := range validipv4 {\r
 147                         err := IsIpv4(ip)\r
 148                         if err != nil {\r
 149                                 t.Errorf("Valid IPv4 string failed to pass: %v", ip)\r
 150                         }\r
 151                 }\r
 152         })\r
 153 \r
 154         t.Run("Invalid IPv4", func(t *testing.T) {\r
 155                 invalidipv4 := []string{\r
 156                         "",\r
 157                         "1.2.3.4.5",\r
 158                         "1.2.3.45/32",\r
 159                         "1.2.3.4a",\r
 160                         "2.3.4",\r
 161                         "1.2.3.400",\r
 162                         "256.255.255.255",\r
 163                         "10,11,12,13",\r
 164                         "1.2.3.4/",\r
 165                 }\r
 166                 for _, ip := range invalidipv4 {\r
 167                         err := IsIpv4(ip)\r
 168                         if err == nil {\r
 169                                 t.Errorf("Invalid IPv4 passed: %v", ip)\r
 170                         }\r
 171                 }\r
 172         })\r
 173 }\r
 174 \r
 175 func TestIsMac(t *testing.T) {\r
 176         t.Run("Valid MAC", func(t *testing.T) {\r
 177                 validmacs := []string{\r
 178                         "11:22:33:44:55:66",\r
 179                         "ab-cd-ef-12-34-56",\r
 180                         "AB-CD-EF-12-34-56",\r
 181                 }\r
 182                 for _, mac := range validmacs {\r
 183                         err := IsMac(mac)\r
 184                         if err != nil {\r
 185                                 t.Errorf("Valid MAC string failed to pass: %v", mac)\r
 186                         }\r
 187                 }\r
 188         })\r
 189 \r
 190         t.Run("Invalid MAC", func(t *testing.T) {\r
 191                 invalidmacs := []string{\r
 192                         "",\r
 193                         "1.2.3.4.5",\r
 194                         "1.2.3.45/32",\r
 195                         "ab:cd:ef:gh:12:34",\r
 196                         "11:22-33-44:55:66",\r
 197                         "11,22,33,44,55,66",\r
 198                         "11|22|33|44|55|66",\r
 199                         "11:22:33:44:55:66:77",\r
 200                         "11-22-33-44-55",\r
 201                         "11-22-33-44-55-66-77",\r
 202                 }\r
 203                 for _, mac := range invalidmacs {\r
 204                         err := IsMac(mac)\r
 205                         if err == nil {\r
 206                                 t.Errorf("Invalid MAC passed: %v", mac)\r
 207                         }\r
 208                 }\r
 209         })\r
 210 }\r
 211 \r
 212 func TestIsValidString(t *testing.T) {\r
 213         t.Run("Valid Strings", func(t *testing.T) {\r
 214                 validStrings := []struct {\r
 215                         str    string\r
 216                         min    int\r
 217                         max    int\r
 218                         format string\r
 219                 }{\r
 220                         {\r
 221                                 str:    "abc123",\r
 222                                 min:    0,\r
 223                                 max:    16,\r
 224                                 format: VALID_NAME_STR,\r
 225                         },\r
 226                         {\r
 227                                 str:    "ab-c1_2.3",\r
 228                                 min:    0,\r
 229                                 max:    16,\r
 230                                 format: VALID_NAME_STR,\r
 231                         },\r
 232                         {\r
 233                                 str:    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",\r
 234                                 min:    0,\r
 235                                 max:    62,\r
 236                                 format: VALID_ALPHANUM_STR,\r
 237                         },\r
 238                         {\r
 239                                 str:    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",\r
 240                                 min:    0,\r
 241                                 max:    52,\r
 242                                 format: VALID_ALPHA_STR,\r
 243                         },\r
 244                         {\r
 245                                 str:    "",\r
 246                                 min:    0,\r
 247                                 max:    52,\r
 248                                 format: VALID_ALPHA_STR,\r
 249                         },\r
 250                         {\r
 251                                 str:    "",\r
 252                                 min:    0,\r
 253                                 max:    52,\r
 254                                 format: VALID_ALPHANUM_STR,\r
 255                         },\r
 256                         {\r
 257                                 str:    "dGhpcyBpcyBhCnRlc3Qgc3RyaW5nCg==",\r
 258                                 min:    0,\r
 259                                 max:    52,\r
 260                                 format: VALID_BASE64_STR,\r
 261                         },\r
 262                         {\r
 263                                 str:    "\t\n \n0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()_+-=,.<>/?'\"\\[]{}\n",\r
 264                                 min:    0,\r
 265                                 max:    256,\r
 266                                 format: VALID_ANY_STR,\r
 267                         },\r
 268                 }\r
 269                 for _, test := range validStrings {\r
 270                         errs := IsValidString(test.str, test.min, test.max, test.format)\r
 271                         if len(errs) > 0 {\r
 272                                 t.Errorf("Valid string failed to pass: str:%v, min:%v, max:%v, format:%v", test.str, test.min, test.max, test.format)\r
 273                         }\r
 274                 }\r
 275         })\r
 276 \r
 277         t.Run("Invalid Strings", func(t *testing.T) {\r
 278                 inValidStrings := []struct {\r
 279                         str    string\r
 280                         min    int\r
 281                         max    int\r
 282                         format string\r
 283                 }{\r
 284                         {\r
 285                                 str:    "abc123",\r
 286                                 min:    0,\r
 287                                 max:    5,\r
 288                                 format: VALID_NAME_STR,\r
 289                         },\r
 290                         {\r
 291                                 str:    "",\r
 292                                 min:    0,\r
 293                                 max:    5,\r
 294                                 format: VALID_NAME_STR,\r
 295                         },\r
 296                         {\r
 297                                 str:    "-ab-c1_2.3",\r
 298                                 min:    0,\r
 299                                 max:    16,\r
 300                                 format: VALID_NAME_STR,\r
 301                         },\r
 302                         {\r
 303                                 str:    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ=",\r
 304                                 min:    0,\r
 305                                 max:    100,\r
 306                                 format: VALID_ALPHANUM_STR,\r
 307                         },\r
 308                         {\r
 309                                 str:    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456",\r
 310                                 min:    0,\r
 311                                 max:    62,\r
 312                                 format: VALID_ALPHA_STR,\r
 313                         },\r
 314                         {\r
 315                                 str:    "",\r
 316                                 min:    1,\r
 317                                 max:    52,\r
 318                                 format: VALID_ALPHA_STR,\r
 319                         },\r
 320                         {\r
 321                                 str:    "abc123",\r
 322                                 min:    1,\r
 323                                 max:    3,\r
 324                                 format: VALID_ALPHA_STR,\r
 325                         },\r
 326                         {\r
 327                                 str:    "",\r
 328                                 min:    1,\r
 329                                 max:    52,\r
 330                                 format: VALID_ALPHANUM_STR,\r
 331                         },\r
 332                         {\r
 333                                 str:    "dGhpcyBpcyBhCnRlc3Qgc3RyaW5nCg===",\r
 334                                 min:    0,\r
 335                                 max:    52,\r
 336                                 format: VALID_BASE64_STR,\r
 337                         },\r
 338                         {\r
 339                                 str:    "dGhpcyBpcyBhCnRlc3=Qgc3RyaW5nCg==",\r
 340                                 min:    0,\r
 341                                 max:    52,\r
 342                                 format: VALID_BASE64_STR,\r
 343                         },\r
 344                         {\r
 345                                 str:    "dGhpcyBpcyBhCnRlc3#Qgc3RyaW5nCg==",\r
 346                                 min:    0,\r
 347                                 max:    52,\r
 348                                 format: VALID_BASE64_STR,\r
 349                         },\r
 350                         {\r
 351                                 str:    "\t\n \n0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()_+-=,.<>/?'\"\\[]{}\n",\r
 352                                 min:    0,\r
 353                                 max:    10,\r
 354                                 format: VALID_ANY_STR,\r
 355                         },\r
 356                         {\r
 357                                 str:    "abc123",\r
 358                                 min:    0,\r
 359                                 max:    10,\r
 360                                 format: "unknownformat",\r
 361                         },\r
 362                 }\r
 363                 for _, test := range inValidStrings {\r
 364                         errs := IsValidString(test.str, test.min, test.max, test.format)\r
 365                         if len(errs) == 0 {\r
 366                                 t.Errorf("Invalid string passed: str:%v, min:%v, max:%v, format:%v", test.str, test.min, test.max, test.format)\r
 367                         }\r
 368                 }\r
 369         })\r
 370 }\r
 371 \r
 372 func TestIsValidLabel(t *testing.T) {\r
 373         t.Run("Valid Labels", func(t *testing.T) {\r
 374                 validlabels := []string{\r
 375                         "kubernetes.io/hostname=localhost",\r
 376                         "hostname=localhost",\r
 377                         "localhost",\r
 378                 }\r
 379                 for _, label := range validlabels {\r
 380                         errs := IsValidLabel(label)\r
 381                         if len(errs) > 0 {\r
 382                                 t.Errorf("Valid label failed to pass: %v %v", label, errs)\r
 383                         }\r
 384                 }\r
 385         })\r
 386 \r
 387         t.Run("Invalid Labels", func(t *testing.T) {\r
 388                 invalidlabels := []string{\r
 389                         "",\r
 390                         "kubernetes$.io/hostname=localhost",\r
 391                         "hostname==localhost",\r
 392                         "=localhost",\r
 393                         "/hostname=localhost",\r
 394                         ".a.b/hostname=localhost",\r
 395                         "kubernetes.io/hostname",\r
 396                         "kubernetes.io/hostname=",\r
 397                         "kubernetes.io/1234567890123456789012345678901234567890123456789012345678901234=localhost",         // too long name\r
 398                         "kubernetes.io/hostname=localhost1234567890123456789012345678901234567890123456789012345678901234", // too long value\r
 399                         "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234/hostname=localhost", // too long prefix\r
 400                 }\r
 401                 for _, label := range invalidlabels {\r
 402                         errs := IsValidLabel(label)\r
 403                         if len(errs) == 0 {\r
 404                                 t.Errorf("Invalid label passed: %v", label)\r
 405                         }\r
 406                 }\r
 407         })\r
 408 }\r
 409 \r
 410 func TestIsValidNumber(t *testing.T) {\r
 411         t.Run("Valid Number", func(t *testing.T) {\r
 412                 validNumbers := []struct {\r
 413                         value int\r
 414                         min   int\r
 415                         max   int\r
 416                 }{\r
 417                         {\r
 418                                 value: 0,\r
 419                                 min:   0,\r
 420                                 max:   5,\r
 421                         },\r
 422                         {\r
 423                                 value: 1000,\r
 424                                 min:   0,\r
 425                                 max:   4095,\r
 426                         },\r
 427                         {\r
 428                                 value: 0,\r
 429                                 min:   0,\r
 430                                 max:   0,\r
 431                         },\r
 432                         {\r
 433                                 value: -100,\r
 434                                 min:   -200,\r
 435                                 max:   -99,\r
 436                         },\r
 437                         {\r
 438                                 value: 123,\r
 439                                 min:   123,\r
 440                                 max:   123,\r
 441                         },\r
 442                 }\r
 443                 for _, test := range validNumbers {\r
 444                         err := IsValidNumber(test.value, test.min, test.max)\r
 445                         if len(err) > 0 {\r
 446                                 t.Errorf("Valid number failed to pass - value:%v, min:%v, max:%v", test.value, test.min, test.max)\r
 447                         }\r
 448                 }\r
 449         })\r
 450 \r
 451         t.Run("Invalid Number", func(t *testing.T) {\r
 452                 inValidNumbers := []struct {\r
 453                         value int\r
 454                         min   int\r
 455                         max   int\r
 456                 }{\r
 457                         {\r
 458                                 value: 6,\r
 459                                 min:   0,\r
 460                                 max:   5,\r
 461                         },\r
 462                         {\r
 463                                 value: 4096,\r
 464                                 min:   0,\r
 465                                 max:   4095,\r
 466                         },\r
 467                         {\r
 468                                 value: 11,\r
 469                                 min:   10,\r
 470                                 max:   10,\r
 471                         },\r
 472                         {\r
 473                                 value: -100,\r
 474                                 min:   -99,\r
 475                                 max:   -200,\r
 476                         },\r
 477                         {\r
 478                                 value: 123,\r
 479                                 min:   223,\r
 480                                 max:   123,\r
 481                         },\r
 482                 }\r
 483                 for _, test := range inValidNumbers {\r
 484                         err := IsValidNumber(test.value, test.min, test.max)\r
 485                         if len(err) == 0 {\r
 486                                 t.Errorf("Invalid number passed - value:%v, min:%v, max:%v", test.value, test.min, test.max)\r
 487                         }\r
 488                 }\r
 489         })\r
 490 }\r