github.com/adacta-ru/mattermost-server@v5.11.1+incompatible/app/import_validators_test.go (about) 1 // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. 2 // See License.txt for license information. 3 4 package app 5 6 import ( 7 "path/filepath" 8 "strings" 9 "testing" 10 11 "github.com/mattermost/mattermost-server/model" 12 "github.com/mattermost/mattermost-server/utils/fileutils" 13 "github.com/stretchr/testify/assert" 14 ) 15 16 func TestImportValidateSchemeImportData(t *testing.T) { 17 // Test with minimum required valid properties and team scope. 18 data := SchemeImportData{ 19 Name: ptrStr("name"), 20 DisplayName: ptrStr("display name"), 21 Scope: ptrStr("team"), 22 DefaultTeamAdminRole: &RoleImportData{ 23 Name: ptrStr("name"), 24 DisplayName: ptrStr("display name"), 25 Permissions: &[]string{"invite_user"}, 26 }, 27 DefaultTeamUserRole: &RoleImportData{ 28 Name: ptrStr("name"), 29 DisplayName: ptrStr("display name"), 30 Permissions: &[]string{"invite_user"}, 31 }, 32 DefaultChannelAdminRole: &RoleImportData{ 33 Name: ptrStr("name"), 34 DisplayName: ptrStr("display name"), 35 Permissions: &[]string{"invite_user"}, 36 }, 37 DefaultChannelUserRole: &RoleImportData{ 38 Name: ptrStr("name"), 39 DisplayName: ptrStr("display name"), 40 Permissions: &[]string{"invite_user"}, 41 }, 42 } 43 if err := validateSchemeImportData(&data); err != nil { 44 t.Fatal("Validation failed but should have been valid.", err) 45 } 46 47 // Test with various invalid names. 48 data.Name = nil 49 if err := validateSchemeImportData(&data); err == nil { 50 t.Fatal("Should have failed due to invalid name.") 51 } 52 53 data.Name = ptrStr("") 54 if err := validateSchemeImportData(&data); err == nil { 55 t.Fatal("Should have failed due to invalid name.") 56 } 57 58 data.Name = ptrStr(strings.Repeat("1234567890", 100)) 59 if err := validateSchemeImportData(&data); err == nil { 60 t.Fatal("Should have failed due to invalid name.") 61 } 62 63 data.Name = ptrStr("name") 64 // Test with invalid display name. 65 data.DisplayName = nil 66 if err := validateSchemeImportData(&data); err == nil { 67 t.Fatal("Should have failed due to invalid display name.") 68 } 69 70 data.DisplayName = ptrStr("") 71 if err := validateSchemeImportData(&data); err == nil { 72 t.Fatal("Should have failed due to invalid display name.") 73 } 74 75 data.DisplayName = ptrStr(strings.Repeat("1234567890", 100)) 76 if err := validateSchemeImportData(&data); err == nil { 77 t.Fatal("Should have failed due to invalid display name.") 78 } 79 80 data.DisplayName = ptrStr("display name") 81 82 // Test with various missing roles. 83 data.DefaultTeamAdminRole = nil 84 if err := validateSchemeImportData(&data); err == nil { 85 t.Fatal("Should have failed due to missing role.") 86 } 87 88 data.DefaultTeamAdminRole = &RoleImportData{ 89 Name: ptrStr("name"), 90 DisplayName: ptrStr("display name"), 91 Permissions: &[]string{"invite_user"}, 92 } 93 data.DefaultTeamUserRole = nil 94 if err := validateSchemeImportData(&data); err == nil { 95 t.Fatal("Should have failed due to missing role.") 96 } 97 98 data.DefaultTeamUserRole = &RoleImportData{ 99 Name: ptrStr("name"), 100 DisplayName: ptrStr("display name"), 101 Permissions: &[]string{"invite_user"}, 102 } 103 data.DefaultChannelAdminRole = nil 104 if err := validateSchemeImportData(&data); err == nil { 105 t.Fatal("Should have failed due to missing role.") 106 } 107 108 data.DefaultChannelAdminRole = &RoleImportData{ 109 Name: ptrStr("name"), 110 DisplayName: ptrStr("display name"), 111 Permissions: &[]string{"invite_user"}, 112 } 113 data.DefaultChannelUserRole = nil 114 if err := validateSchemeImportData(&data); err == nil { 115 t.Fatal("Should have failed due to missing role.") 116 } 117 118 data.DefaultChannelUserRole = &RoleImportData{ 119 Name: ptrStr("name"), 120 DisplayName: ptrStr("display name"), 121 Permissions: &[]string{"invite_user"}, 122 } 123 124 // Test with various invalid roles. 125 data.DefaultTeamAdminRole.Name = nil 126 if err := validateSchemeImportData(&data); err == nil { 127 t.Fatal("Should have failed due to invalid role.") 128 } 129 130 data.DefaultTeamAdminRole.Name = ptrStr("name") 131 data.DefaultTeamUserRole.Name = nil 132 if err := validateSchemeImportData(&data); err == nil { 133 t.Fatal("Should have failed due to invalid role.") 134 } 135 136 data.DefaultTeamUserRole.Name = ptrStr("name") 137 data.DefaultChannelAdminRole.Name = nil 138 if err := validateSchemeImportData(&data); err == nil { 139 t.Fatal("Should have failed due to invalid role.") 140 } 141 142 data.DefaultChannelAdminRole.Name = ptrStr("name") 143 data.DefaultChannelUserRole.Name = nil 144 if err := validateSchemeImportData(&data); err == nil { 145 t.Fatal("Should have failed due to invalid role.") 146 } 147 148 data.DefaultChannelUserRole.Name = ptrStr("name") 149 150 // Change to a Channel scope role, and check with missing or extra roles again. 151 data.Scope = ptrStr("channel") 152 data.DefaultTeamAdminRole = nil 153 if err := validateSchemeImportData(&data); err == nil { 154 t.Fatal("Should have failed due to spurious role.") 155 } 156 157 data.DefaultTeamAdminRole = &RoleImportData{ 158 Name: ptrStr("name"), 159 DisplayName: ptrStr("display name"), 160 Permissions: &[]string{"invite_user"}, 161 } 162 data.DefaultTeamUserRole = nil 163 if err := validateSchemeImportData(&data); err == nil { 164 t.Fatal("Should have failed due to spurious role.") 165 } 166 167 data.DefaultTeamAdminRole = nil 168 if err := validateSchemeImportData(&data); err != nil { 169 t.Fatal("Should have succeeded.") 170 } 171 172 // Test with all combinations of optional parameters. 173 data.Description = ptrStr(strings.Repeat("1234567890", 1024)) 174 if err := validateSchemeImportData(&data); err == nil { 175 t.Fatal("Should have failed due to invalid description.") 176 } 177 178 data.Description = ptrStr("description") 179 if err := validateSchemeImportData(&data); err != nil { 180 t.Fatal("Should have succeeded.") 181 } 182 } 183 184 func TestImportValidateRoleImportData(t *testing.T) { 185 // Test with minimum required valid properties. 186 data := RoleImportData{ 187 Name: ptrStr("name"), 188 DisplayName: ptrStr("display name"), 189 } 190 if err := validateRoleImportData(&data); err != nil { 191 t.Fatal("Validation failed but should have been valid.", err) 192 } 193 194 // Test with various invalid names. 195 data.Name = nil 196 if err := validateRoleImportData(&data); err == nil { 197 t.Fatal("Should have failed due to invalid name.") 198 } 199 200 data.Name = ptrStr("") 201 if err := validateRoleImportData(&data); err == nil { 202 t.Fatal("Should have failed due to invalid name.") 203 } 204 205 data.Name = ptrStr(strings.Repeat("1234567890", 100)) 206 if err := validateRoleImportData(&data); err == nil { 207 t.Fatal("Should have failed due to invalid name.") 208 } 209 210 data.Name = ptrStr("name") 211 // Test with invalid display name. 212 data.DisplayName = nil 213 if err := validateRoleImportData(&data); err == nil { 214 t.Fatal("Should have failed due to invalid display name.") 215 } 216 217 data.DisplayName = ptrStr("") 218 if err := validateRoleImportData(&data); err == nil { 219 t.Fatal("Should have failed due to invalid display name.") 220 } 221 222 data.DisplayName = ptrStr(strings.Repeat("1234567890", 100)) 223 if err := validateRoleImportData(&data); err == nil { 224 t.Fatal("Should have failed due to invalid display name.") 225 } 226 227 data.DisplayName = ptrStr("display name") 228 229 // Test with various valid/invalid permissions. 230 data.Permissions = &[]string{} 231 if err := validateRoleImportData(&data); err != nil { 232 t.Fatal("Validation failed but should have been valid.", err) 233 } 234 235 data.Permissions = &[]string{"invite_user", "add_user_to_team"} 236 if err := validateRoleImportData(&data); err != nil { 237 t.Fatal("Validation failed but should have been valid.", err) 238 } 239 240 data.Permissions = &[]string{"invite_user", "add_user_to_team", "derp"} 241 if err := validateRoleImportData(&data); err == nil { 242 t.Fatal("Validation should have failed due to invalid permission.", err) 243 } 244 245 data.Permissions = &[]string{"invite_user", "add_user_to_team"} 246 247 // Test with various valid/invalid descriptions. 248 data.Description = ptrStr(strings.Repeat("1234567890", 1024)) 249 if err := validateRoleImportData(&data); err == nil { 250 t.Fatal("Validation should have failed due to invalid description.", err) 251 } 252 253 data.Description = ptrStr("description") 254 if err := validateRoleImportData(&data); err != nil { 255 t.Fatal("Validation failed but should have been valid.", err) 256 } 257 } 258 259 func TestImportValidateTeamImportData(t *testing.T) { 260 261 // Test with minimum required valid properties. 262 data := TeamImportData{ 263 Name: ptrStr("teamname"), 264 DisplayName: ptrStr("Display Name"), 265 Type: ptrStr("O"), 266 } 267 if err := validateTeamImportData(&data); err != nil { 268 t.Fatal("Validation failed but should have been valid.") 269 } 270 271 // Test with various invalid names. 272 data = TeamImportData{ 273 DisplayName: ptrStr("Display Name"), 274 Type: ptrStr("O"), 275 } 276 if err := validateTeamImportData(&data); err == nil { 277 t.Fatal("Should have failed due to missing name.") 278 } 279 280 data.Name = ptrStr(strings.Repeat("abcdefghij", 7)) 281 if err := validateTeamImportData(&data); err == nil { 282 t.Fatal("Should have failed due to too long name.") 283 } 284 285 data.Name = ptrStr("login") 286 if err := validateTeamImportData(&data); err == nil { 287 t.Fatal("Should have failed due to reserved word in name.") 288 } 289 290 data.Name = ptrStr("Test::''ASD") 291 if err := validateTeamImportData(&data); err == nil { 292 t.Fatal("Should have failed due to non alphanum characters in name.") 293 } 294 295 data.Name = ptrStr("A") 296 if err := validateTeamImportData(&data); err == nil { 297 t.Fatal("Should have failed due to short name.") 298 } 299 300 // Test team various invalid display names. 301 data = TeamImportData{ 302 Name: ptrStr("teamname"), 303 Type: ptrStr("O"), 304 } 305 if err := validateTeamImportData(&data); err == nil { 306 t.Fatal("Should have failed due to missing display_name.") 307 } 308 309 data.DisplayName = ptrStr("") 310 if err := validateTeamImportData(&data); err == nil { 311 t.Fatal("Should have failed due to empty display_name.") 312 } 313 314 data.DisplayName = ptrStr(strings.Repeat("abcdefghij", 7)) 315 if err := validateTeamImportData(&data); err == nil { 316 t.Fatal("Should have failed due to too long display_name.") 317 } 318 319 // Test with various valid and invalid types. 320 data = TeamImportData{ 321 Name: ptrStr("teamname"), 322 DisplayName: ptrStr("Display Name"), 323 } 324 if err := validateTeamImportData(&data); err == nil { 325 t.Fatal("Should have failed due to missing type.") 326 } 327 328 data.Type = ptrStr("A") 329 if err := validateTeamImportData(&data); err == nil { 330 t.Fatal("Should have failed due to invalid type.") 331 } 332 333 data.Type = ptrStr("I") 334 if err := validateTeamImportData(&data); err != nil { 335 t.Fatal("Should have succeeded with valid type.") 336 } 337 338 // Test with all the combinations of optional parameters. 339 data = TeamImportData{ 340 Name: ptrStr("teamname"), 341 DisplayName: ptrStr("Display Name"), 342 Type: ptrStr("O"), 343 Description: ptrStr("The team description."), 344 AllowOpenInvite: ptrBool(true), 345 } 346 if err := validateTeamImportData(&data); err != nil { 347 t.Fatal("Should have succeeded with valid optional properties.") 348 } 349 350 data.AllowOpenInvite = ptrBool(false) 351 if err := validateTeamImportData(&data); err != nil { 352 t.Fatal("Should have succeeded with allow open invites false.") 353 } 354 355 data.Description = ptrStr(strings.Repeat("abcdefghij ", 26)) 356 if err := validateTeamImportData(&data); err == nil { 357 t.Fatal("Should have failed due to too long description.") 358 } 359 360 // Test with an empty scheme name. 361 data.Description = ptrStr("abcdefg") 362 data.Scheme = ptrStr("") 363 if err := validateTeamImportData(&data); err == nil { 364 t.Fatal("Should have failed due to empty scheme name.") 365 } 366 367 // Test with a valid scheme name. 368 data.Scheme = ptrStr("abcdefg") 369 if err := validateTeamImportData(&data); err != nil { 370 t.Fatal("Should have succeeded with valid scheme name.") 371 } 372 } 373 374 func TestImportValidateChannelImportData(t *testing.T) { 375 376 // Test with minimum required valid properties. 377 data := ChannelImportData{ 378 Team: ptrStr("teamname"), 379 Name: ptrStr("channelname"), 380 DisplayName: ptrStr("Display Name"), 381 Type: ptrStr("O"), 382 } 383 if err := validateChannelImportData(&data); err != nil { 384 t.Fatal("Validation failed but should have been valid.") 385 } 386 387 // Test with missing team. 388 data = ChannelImportData{ 389 Name: ptrStr("channelname"), 390 DisplayName: ptrStr("Display Name"), 391 Type: ptrStr("O"), 392 } 393 if err := validateChannelImportData(&data); err == nil { 394 t.Fatal("Should have failed due to missing team.") 395 } 396 397 // Test with various invalid names. 398 data = ChannelImportData{ 399 Team: ptrStr("teamname"), 400 DisplayName: ptrStr("Display Name"), 401 Type: ptrStr("O"), 402 } 403 if err := validateChannelImportData(&data); err == nil { 404 t.Fatal("Should have failed due to missing name.") 405 } 406 407 data.Name = ptrStr(strings.Repeat("abcdefghij", 7)) 408 if err := validateChannelImportData(&data); err == nil { 409 t.Fatal("Should have failed due to too long name.") 410 } 411 412 data.Name = ptrStr("Test::''ASD") 413 if err := validateChannelImportData(&data); err == nil { 414 t.Fatal("Should have failed due to non alphanum characters in name.") 415 } 416 417 data.Name = ptrStr("A") 418 if err := validateChannelImportData(&data); err == nil { 419 t.Fatal("Should have failed due to short name.") 420 } 421 422 // Test team various invalid display names. 423 data = ChannelImportData{ 424 Team: ptrStr("teamname"), 425 Name: ptrStr("channelname"), 426 Type: ptrStr("O"), 427 } 428 if err := validateChannelImportData(&data); err == nil { 429 t.Fatal("Should have failed due to missing display_name.") 430 } 431 432 data.DisplayName = ptrStr("") 433 if err := validateChannelImportData(&data); err == nil { 434 t.Fatal("Should have failed due to empty display_name.") 435 } 436 437 data.DisplayName = ptrStr(strings.Repeat("abcdefghij", 7)) 438 if err := validateChannelImportData(&data); err == nil { 439 t.Fatal("Should have failed due to too long display_name.") 440 } 441 442 // Test with various valid and invalid types. 443 data = ChannelImportData{ 444 Team: ptrStr("teamname"), 445 Name: ptrStr("channelname"), 446 DisplayName: ptrStr("Display Name"), 447 } 448 if err := validateChannelImportData(&data); err == nil { 449 t.Fatal("Should have failed due to missing type.") 450 } 451 452 data.Type = ptrStr("A") 453 if err := validateChannelImportData(&data); err == nil { 454 t.Fatal("Should have failed due to invalid type.") 455 } 456 457 data.Type = ptrStr("P") 458 if err := validateChannelImportData(&data); err != nil { 459 t.Fatal("Should have succeeded with valid type.") 460 } 461 462 // Test with all the combinations of optional parameters. 463 data = ChannelImportData{ 464 Team: ptrStr("teamname"), 465 Name: ptrStr("channelname"), 466 DisplayName: ptrStr("Display Name"), 467 Type: ptrStr("O"), 468 Header: ptrStr("Channel Header Here"), 469 Purpose: ptrStr("Channel Purpose Here"), 470 } 471 if err := validateChannelImportData(&data); err != nil { 472 t.Fatal("Should have succeeded with valid optional properties.") 473 } 474 475 data.Header = ptrStr(strings.Repeat("abcdefghij ", 103)) 476 if err := validateChannelImportData(&data); err == nil { 477 t.Fatal("Should have failed due to too long header.") 478 } 479 480 data.Header = ptrStr("Channel Header Here") 481 data.Purpose = ptrStr(strings.Repeat("abcdefghij ", 26)) 482 if err := validateChannelImportData(&data); err == nil { 483 t.Fatal("Should have failed due to too long purpose.") 484 } 485 486 // Test with an empty scheme name. 487 data.Purpose = ptrStr("abcdefg") 488 data.Scheme = ptrStr("") 489 if err := validateChannelImportData(&data); err == nil { 490 t.Fatal("Should have failed due to empty scheme name.") 491 } 492 493 // Test with a valid scheme name. 494 data.Scheme = ptrStr("abcdefg") 495 if err := validateChannelImportData(&data); err != nil { 496 t.Fatal("Should have succeeded with valid scheme name.") 497 } 498 } 499 500 func TestImportValidateUserImportData(t *testing.T) { 501 502 // Test with minimum required valid properties. 503 data := UserImportData{ 504 Username: ptrStr("bob"), 505 Email: ptrStr("bob@example.com"), 506 } 507 if err := validateUserImportData(&data); err != nil { 508 t.Fatal("Validation failed but should have been valid.") 509 } 510 511 // Invalid Usernames. 512 data.Username = nil 513 if err := validateUserImportData(&data); err == nil { 514 t.Fatal("Validation should have failed due to nil Username.") 515 } 516 517 data.Username = ptrStr("") 518 if err := validateUserImportData(&data); err == nil { 519 t.Fatal("Validation should have failed due to 0 length Username.") 520 } 521 522 data.Username = ptrStr(strings.Repeat("abcdefghij", 7)) 523 if err := validateUserImportData(&data); err == nil { 524 t.Fatal("Validation should have failed due to too long Username.") 525 } 526 527 data.Username = ptrStr("i am a username with spaces and !!!") 528 if err := validateUserImportData(&data); err == nil { 529 t.Fatal("Validation should have failed due to invalid characters in Username.") 530 } 531 532 data.Username = ptrStr("bob") 533 534 // Unexisting Picture Image 535 data.ProfileImage = ptrStr("not-existing-file") 536 if err := validateUserImportData(&data); err == nil { 537 t.Fatal("Validation should have failed due to not existing profile image file.") 538 } 539 data.ProfileImage = nil 540 541 // Invalid Emails 542 data.Email = nil 543 if err := validateUserImportData(&data); err == nil { 544 t.Fatal("Validation should have failed due to nil Email.") 545 } 546 547 data.Email = ptrStr("") 548 if err := validateUserImportData(&data); err == nil { 549 t.Fatal("Validation should have failed due to 0 length Email.") 550 } 551 552 data.Email = ptrStr(strings.Repeat("abcdefghij", 13)) 553 if err := validateUserImportData(&data); err == nil { 554 t.Fatal("Validation should have failed due to too long Email.") 555 } 556 557 data.Email = ptrStr("bob@example.com") 558 559 // Empty AuthService indicates user/password auth. 560 data.AuthService = ptrStr("") 561 checkNoError(t, validateUserImportData(&data)) 562 563 data.AuthService = ptrStr("saml") 564 data.AuthData = ptrStr(strings.Repeat("abcdefghij", 15)) 565 if err := validateUserImportData(&data); err == nil { 566 t.Fatal("Validation should have failed due to too long auth data.") 567 } 568 569 data.AuthData = ptrStr("bobbytables") 570 if err := validateUserImportData(&data); err != nil { 571 t.Fatal("Validation should have succeeded with valid auth service and auth data.") 572 } 573 574 // Test a valid User with all fields populated. 575 testsDir, _ := fileutils.FindDir("tests") 576 data = UserImportData{ 577 ProfileImage: ptrStr(filepath.Join(testsDir, "test.png")), 578 Username: ptrStr("bob"), 579 Email: ptrStr("bob@example.com"), 580 AuthService: ptrStr("ldap"), 581 AuthData: ptrStr("bob"), 582 Nickname: ptrStr("BobNick"), 583 FirstName: ptrStr("Bob"), 584 LastName: ptrStr("Blob"), 585 Position: ptrStr("The Boss"), 586 Roles: ptrStr("system_user"), 587 Locale: ptrStr("en"), 588 } 589 if err := validateUserImportData(&data); err != nil { 590 t.Fatal("Validation failed but should have been valid.") 591 } 592 593 // Test various invalid optional field values. 594 data.Nickname = ptrStr(strings.Repeat("abcdefghij", 7)) 595 if err := validateUserImportData(&data); err == nil { 596 t.Fatal("Validation should have failed due to too long Nickname.") 597 } 598 data.Nickname = ptrStr("BobNick") 599 600 data.FirstName = ptrStr(strings.Repeat("abcdefghij", 7)) 601 if err := validateUserImportData(&data); err == nil { 602 t.Fatal("Validation should have failed due to too long First Name.") 603 } 604 data.FirstName = ptrStr("Bob") 605 606 data.LastName = ptrStr(strings.Repeat("abcdefghij", 7)) 607 if err := validateUserImportData(&data); err == nil { 608 t.Fatal("Validation should have failed due to too long Last name.") 609 } 610 data.LastName = ptrStr("Blob") 611 612 data.Position = ptrStr(strings.Repeat("abcdefghij", 13)) 613 if err := validateUserImportData(&data); err == nil { 614 t.Fatal("Validation should have failed due to too long Position.") 615 } 616 data.Position = ptrStr("The Boss") 617 618 data.Roles = nil 619 if err := validateUserImportData(&data); err != nil { 620 t.Fatal("Validation failed but should have been valid.") 621 } 622 623 data.Roles = ptrStr("") 624 if err := validateUserImportData(&data); err != nil { 625 t.Fatal("Validation failed but should have been valid.") 626 } 627 data.Roles = ptrStr("system_user") 628 629 // Try various valid/invalid notify props. 630 data.NotifyProps = &UserNotifyPropsImportData{} 631 632 data.NotifyProps.Desktop = ptrStr("invalid") 633 checkError(t, validateUserImportData(&data)) 634 635 data.NotifyProps.Desktop = ptrStr(model.USER_NOTIFY_ALL) 636 data.NotifyProps.DesktopSound = ptrStr("invalid") 637 checkError(t, validateUserImportData(&data)) 638 639 data.NotifyProps.DesktopSound = ptrStr("true") 640 data.NotifyProps.Email = ptrStr("invalid") 641 checkError(t, validateUserImportData(&data)) 642 643 data.NotifyProps.Email = ptrStr("true") 644 data.NotifyProps.Mobile = ptrStr("invalid") 645 checkError(t, validateUserImportData(&data)) 646 647 data.NotifyProps.Mobile = ptrStr(model.USER_NOTIFY_ALL) 648 data.NotifyProps.MobilePushStatus = ptrStr("invalid") 649 checkError(t, validateUserImportData(&data)) 650 651 data.NotifyProps.MobilePushStatus = ptrStr(model.STATUS_ONLINE) 652 data.NotifyProps.ChannelTrigger = ptrStr("invalid") 653 checkError(t, validateUserImportData(&data)) 654 655 data.NotifyProps.ChannelTrigger = ptrStr("true") 656 data.NotifyProps.CommentsTrigger = ptrStr("invalid") 657 checkError(t, validateUserImportData(&data)) 658 659 data.NotifyProps.CommentsTrigger = ptrStr(model.COMMENTS_NOTIFY_ROOT) 660 data.NotifyProps.MentionKeys = ptrStr("valid") 661 checkNoError(t, validateUserImportData(&data)) 662 663 //Test the emai batching interval validators 664 //Happy paths 665 data.EmailInterval = ptrStr("immediately") 666 checkNoError(t, validateUserImportData(&data)) 667 668 data.EmailInterval = ptrStr("fifteen") 669 checkNoError(t, validateUserImportData(&data)) 670 671 data.EmailInterval = ptrStr("hour") 672 checkNoError(t, validateUserImportData(&data)) 673 674 //Invalid values 675 data.EmailInterval = ptrStr("invalid") 676 checkError(t, validateUserImportData(&data)) 677 678 data.EmailInterval = ptrStr("") 679 checkError(t, validateUserImportData(&data)) 680 } 681 682 func TestImportValidateUserTeamsImportData(t *testing.T) { 683 684 // Invalid Name. 685 data := []UserTeamImportData{ 686 { 687 Roles: ptrStr("team_admin team_user"), 688 }, 689 } 690 if err := validateUserTeamsImportData(&data); err == nil { 691 t.Fatal("Should have failed due to invalid name.") 692 } 693 data[0].Name = ptrStr("teamname") 694 695 // Valid (nil roles) 696 data[0].Roles = nil 697 if err := validateUserTeamsImportData(&data); err != nil { 698 t.Fatal("Should have succeeded with empty roles.") 699 } 700 701 // Valid (empty roles) 702 data[0].Roles = ptrStr("") 703 if err := validateUserTeamsImportData(&data); err != nil { 704 t.Fatal("Should have succeeded with empty roles.") 705 } 706 707 // Valid (with roles) 708 data[0].Roles = ptrStr("team_admin team_user") 709 if err := validateUserTeamsImportData(&data); err != nil { 710 t.Fatal("Should have succeeded with valid roles.") 711 } 712 713 // Valid (with JSON string of theme) 714 data[0].Theme = ptrStr(`{"awayIndicator":"#DBBD4E","buttonBg":"#23A1FF","buttonColor":"#FFFFFF","centerChannelBg":"#ffffff","centerChannelColor":"#333333","codeTheme":"github","image":"/static/files/a4a388b38b32678e83823ef1b3e17766.png","linkColor":"#2389d7","mentionBg":"#2389d7","mentionColor":"#ffffff","mentionHighlightBg":"#fff2bb","mentionHighlightLink":"#2f81b7","newMessageSeparator":"#FF8800","onlineIndicator":"#7DBE00","sidebarBg":"#fafafa","sidebarHeaderBg":"#3481B9","sidebarHeaderTextColor":"#ffffff","sidebarText":"#333333","sidebarTextActiveBorder":"#378FD2","sidebarTextActiveColor":"#111111","sidebarTextHoverBg":"#e6f2fa","sidebarUnreadText":"#333333","type":"Mattermost"}`) 715 if err := validateUserTeamsImportData(&data); err != nil { 716 t.Fatal("Should have succeeded with valid theme.") 717 } 718 719 // Invalid (invalid JSON string of theme) 720 data[0].Theme = ptrStr(`This is the invalid string which cannot be marshalled to JSON object :) + {"#DBBD4E","buttonBg", "#23A1FF", buttonColor`) 721 if err := validateUserTeamsImportData(&data); err == nil { 722 t.Fatal("Should have fail with invalid JSON string of theme.") 723 } 724 725 // Invalid (valid JSON but invalid theme description) 726 data[0].Theme = ptrStr(`{"somekey": 25, "json_obj1": {"color": "#DBBD4E","buttonBg": "#23A1FF"}}`) 727 if err := validateUserTeamsImportData(&data); err == nil { 728 t.Fatal("Should have fail with valid JSON which contains invalid string of theme description.") 729 } 730 data[0].Theme = nil 731 } 732 733 func TestImportValidateUserChannelsImportData(t *testing.T) { 734 735 // Invalid Name. 736 data := []UserChannelImportData{ 737 { 738 Roles: ptrStr("channel_admin channel_user"), 739 }, 740 } 741 if err := validateUserChannelsImportData(&data); err == nil { 742 t.Fatal("Should have failed due to invalid name.") 743 } 744 data[0].Name = ptrStr("channelname") 745 746 // Valid (nil roles) 747 data[0].Roles = nil 748 if err := validateUserChannelsImportData(&data); err != nil { 749 t.Fatal("Should have succeeded with empty roles.") 750 } 751 752 // Valid (empty roles) 753 data[0].Roles = ptrStr("") 754 if err := validateUserChannelsImportData(&data); err != nil { 755 t.Fatal("Should have succeeded with empty roles.") 756 } 757 758 // Valid (with roles) 759 data[0].Roles = ptrStr("channel_admin channel_user") 760 if err := validateUserChannelsImportData(&data); err != nil { 761 t.Fatal("Should have succeeded with valid roles.") 762 } 763 764 // Empty notify props. 765 data[0].NotifyProps = &UserChannelNotifyPropsImportData{} 766 if err := validateUserChannelsImportData(&data); err != nil { 767 t.Fatal("Should have succeeded with empty notify props.") 768 } 769 770 // Invalid desktop notify props. 771 data[0].NotifyProps.Desktop = ptrStr("invalid") 772 if err := validateUserChannelsImportData(&data); err == nil { 773 t.Fatal("Should have failed with invalid desktop notify props.") 774 } 775 776 // Invalid mobile notify props. 777 data[0].NotifyProps.Desktop = ptrStr("mention") 778 data[0].NotifyProps.Mobile = ptrStr("invalid") 779 if err := validateUserChannelsImportData(&data); err == nil { 780 t.Fatal("Should have failed with invalid mobile notify props.") 781 } 782 783 // Invalid mark_unread notify props. 784 data[0].NotifyProps.Mobile = ptrStr("mention") 785 data[0].NotifyProps.MarkUnread = ptrStr("invalid") 786 if err := validateUserChannelsImportData(&data); err == nil { 787 t.Fatal("Should have failed with invalid mark_unread notify props.") 788 } 789 790 // Valid notify props. 791 data[0].NotifyProps.MarkUnread = ptrStr("mention") 792 if err := validateUserChannelsImportData(&data); err != nil { 793 t.Fatal("Should have succeeded with valid notify props.") 794 } 795 } 796 797 func TestImportValidateReactionImportData(t *testing.T) { 798 // Test with minimum required valid properties. 799 parentCreateAt := model.GetMillis() - 100 800 data := ReactionImportData{ 801 User: ptrStr("username"), 802 EmojiName: ptrStr("emoji"), 803 CreateAt: ptrInt64(model.GetMillis()), 804 } 805 if err := validateReactionImportData(&data, parentCreateAt); err != nil { 806 t.Fatal("Validation failed but should have been valid.") 807 } 808 809 // Test with missing required properties. 810 data = ReactionImportData{ 811 EmojiName: ptrStr("emoji"), 812 CreateAt: ptrInt64(model.GetMillis()), 813 } 814 if err := validateReactionImportData(&data, parentCreateAt); err == nil { 815 t.Fatal("Should have failed due to missing required property.") 816 } 817 818 data = ReactionImportData{ 819 User: ptrStr("username"), 820 CreateAt: ptrInt64(model.GetMillis()), 821 } 822 if err := validateReactionImportData(&data, parentCreateAt); err == nil { 823 t.Fatal("Should have failed due to missing required property.") 824 } 825 826 data = ReactionImportData{ 827 User: ptrStr("username"), 828 EmojiName: ptrStr("emoji"), 829 } 830 if err := validateReactionImportData(&data, parentCreateAt); err == nil { 831 t.Fatal("Should have failed due to missing required property.") 832 } 833 834 // Test with invalid emoji name. 835 data = ReactionImportData{ 836 User: ptrStr("username"), 837 EmojiName: ptrStr(strings.Repeat("1234567890", 500)), 838 CreateAt: ptrInt64(model.GetMillis()), 839 } 840 if err := validateReactionImportData(&data, parentCreateAt); err == nil { 841 t.Fatal("Should have failed due to too long emoji name.") 842 } 843 844 // Test with invalid CreateAt 845 data = ReactionImportData{ 846 User: ptrStr("username"), 847 EmojiName: ptrStr("emoji"), 848 CreateAt: ptrInt64(0), 849 } 850 if err := validateReactionImportData(&data, parentCreateAt); err == nil { 851 t.Fatal("Should have failed due to 0 create-at value.") 852 } 853 854 data = ReactionImportData{ 855 User: ptrStr("username"), 856 EmojiName: ptrStr("emoji"), 857 CreateAt: ptrInt64(parentCreateAt - 100), 858 } 859 if err := validateReactionImportData(&data, parentCreateAt); err == nil { 860 t.Fatal("Should have failed due parent with newer create-at value.") 861 } 862 } 863 864 func TestImportValidateReplyImportData(t *testing.T) { 865 // Test with minimum required valid properties. 866 parentCreateAt := model.GetMillis() - 100 867 maxPostSize := 10000 868 data := ReplyImportData{ 869 User: ptrStr("username"), 870 Message: ptrStr("message"), 871 CreateAt: ptrInt64(model.GetMillis()), 872 } 873 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err != nil { 874 t.Fatal("Validation failed but should have been valid.") 875 } 876 877 // Test with missing required properties. 878 data = ReplyImportData{ 879 Message: ptrStr("message"), 880 CreateAt: ptrInt64(model.GetMillis()), 881 } 882 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err == nil { 883 t.Fatal("Should have failed due to missing required property.") 884 } 885 886 data = ReplyImportData{ 887 User: ptrStr("username"), 888 CreateAt: ptrInt64(model.GetMillis()), 889 } 890 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err == nil { 891 t.Fatal("Should have failed due to missing required property.") 892 } 893 894 data = ReplyImportData{ 895 User: ptrStr("username"), 896 Message: ptrStr("message"), 897 } 898 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err == nil { 899 t.Fatal("Should have failed due to missing required property.") 900 } 901 902 // Test with invalid message. 903 data = ReplyImportData{ 904 User: ptrStr("username"), 905 Message: ptrStr(strings.Repeat("0", maxPostSize+1)), 906 CreateAt: ptrInt64(model.GetMillis()), 907 } 908 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err == nil { 909 t.Fatal("Should have failed due to too long message.") 910 } 911 912 // Test with invalid CreateAt 913 data = ReplyImportData{ 914 User: ptrStr("username"), 915 Message: ptrStr("message"), 916 CreateAt: ptrInt64(0), 917 } 918 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err == nil { 919 t.Fatal("Should have failed due to 0 create-at value.") 920 } 921 922 data = ReplyImportData{ 923 User: ptrStr("username"), 924 Message: ptrStr("message"), 925 CreateAt: ptrInt64(parentCreateAt - 100), 926 } 927 if err := validateReplyImportData(&data, parentCreateAt, maxPostSize); err == nil { 928 t.Fatal("Should have failed due parent with newer create-at value.") 929 } 930 } 931 932 func TestImportValidatePostImportData(t *testing.T) { 933 maxPostSize := 10000 934 935 // Test with minimum required valid properties. 936 data := PostImportData{ 937 Team: ptrStr("teamname"), 938 Channel: ptrStr("channelname"), 939 User: ptrStr("username"), 940 Message: ptrStr("message"), 941 CreateAt: ptrInt64(model.GetMillis()), 942 } 943 if err := validatePostImportData(&data, maxPostSize); err != nil { 944 t.Fatal("Validation failed but should have been valid.") 945 } 946 947 // Test with missing required properties. 948 data = PostImportData{ 949 Channel: ptrStr("channelname"), 950 User: ptrStr("username"), 951 Message: ptrStr("message"), 952 CreateAt: ptrInt64(model.GetMillis()), 953 } 954 if err := validatePostImportData(&data, maxPostSize); err == nil { 955 t.Fatal("Should have failed due to missing required property.") 956 } 957 958 data = PostImportData{ 959 Team: ptrStr("teamname"), 960 User: ptrStr("username"), 961 Message: ptrStr("message"), 962 CreateAt: ptrInt64(model.GetMillis()), 963 } 964 if err := validatePostImportData(&data, maxPostSize); err == nil { 965 t.Fatal("Should have failed due to missing required property.") 966 } 967 968 data = PostImportData{ 969 Team: ptrStr("teamname"), 970 Channel: ptrStr("channelname"), 971 Message: ptrStr("message"), 972 CreateAt: ptrInt64(model.GetMillis()), 973 } 974 if err := validatePostImportData(&data, maxPostSize); err == nil { 975 t.Fatal("Should have failed due to missing required property.") 976 } 977 978 data = PostImportData{ 979 Team: ptrStr("teamname"), 980 Channel: ptrStr("channelname"), 981 User: ptrStr("username"), 982 CreateAt: ptrInt64(model.GetMillis()), 983 } 984 if err := validatePostImportData(&data, maxPostSize); err == nil { 985 t.Fatal("Should have failed due to missing required property.") 986 } 987 988 data = PostImportData{ 989 Team: ptrStr("teamname"), 990 Channel: ptrStr("channelname"), 991 User: ptrStr("username"), 992 Message: ptrStr("message"), 993 } 994 if err := validatePostImportData(&data, maxPostSize); err == nil { 995 t.Fatal("Should have failed due to missing required property.") 996 } 997 998 // Test with invalid message. 999 data = PostImportData{ 1000 Team: ptrStr("teamname"), 1001 Channel: ptrStr("channelname"), 1002 User: ptrStr("username"), 1003 Message: ptrStr(strings.Repeat("0", maxPostSize+1)), 1004 CreateAt: ptrInt64(model.GetMillis()), 1005 } 1006 if err := validatePostImportData(&data, maxPostSize); err == nil { 1007 t.Fatal("Should have failed due to too long message.") 1008 } 1009 1010 // Test with invalid CreateAt 1011 data = PostImportData{ 1012 Team: ptrStr("teamname"), 1013 Channel: ptrStr("channelname"), 1014 User: ptrStr("username"), 1015 Message: ptrStr("message"), 1016 CreateAt: ptrInt64(0), 1017 } 1018 if err := validatePostImportData(&data, maxPostSize); err == nil { 1019 t.Fatal("Should have failed due to 0 create-at value.") 1020 } 1021 1022 // Test with valid all optional parameters. 1023 reactions := []ReactionImportData{ReactionImportData{ 1024 User: ptrStr("username"), 1025 EmojiName: ptrStr("emoji"), 1026 CreateAt: ptrInt64(model.GetMillis()), 1027 }} 1028 replies := []ReplyImportData{ReplyImportData{ 1029 User: ptrStr("username"), 1030 Message: ptrStr("message"), 1031 CreateAt: ptrInt64(model.GetMillis()), 1032 }} 1033 data = PostImportData{ 1034 Team: ptrStr("teamname"), 1035 Channel: ptrStr("channelname"), 1036 User: ptrStr("username"), 1037 Message: ptrStr("message"), 1038 CreateAt: ptrInt64(model.GetMillis()), 1039 Reactions: &reactions, 1040 Replies: &replies, 1041 } 1042 if err := validatePostImportData(&data, maxPostSize); err != nil { 1043 t.Fatal("Should have succeeded.") 1044 } 1045 } 1046 1047 func TestImportValidateDirectChannelImportData(t *testing.T) { 1048 1049 // Test with valid number of members for direct message. 1050 data := DirectChannelImportData{ 1051 Members: &[]string{ 1052 model.NewId(), 1053 model.NewId(), 1054 }, 1055 } 1056 if err := validateDirectChannelImportData(&data); err != nil { 1057 t.Fatal("Validation failed but should have been valid.") 1058 } 1059 1060 // Test with valid number of members for group message. 1061 data = DirectChannelImportData{ 1062 Members: &[]string{ 1063 model.NewId(), 1064 model.NewId(), 1065 model.NewId(), 1066 }, 1067 } 1068 if err := validateDirectChannelImportData(&data); err != nil { 1069 t.Fatal("Validation failed but should have been valid.") 1070 } 1071 1072 // Test with all the combinations of optional parameters. 1073 data = DirectChannelImportData{ 1074 Members: &[]string{ 1075 model.NewId(), 1076 model.NewId(), 1077 }, 1078 Header: ptrStr("Channel Header Here"), 1079 } 1080 if err := validateDirectChannelImportData(&data); err != nil { 1081 t.Fatal("Should have succeeded with valid optional properties.") 1082 } 1083 1084 // Test with invalid Header. 1085 data.Header = ptrStr(strings.Repeat("abcdefghij ", 103)) 1086 if err := validateDirectChannelImportData(&data); err == nil { 1087 t.Fatal("Should have failed due to too long header.") 1088 } 1089 1090 // Test with different combinations of invalid member counts. 1091 data = DirectChannelImportData{ 1092 Members: &[]string{}, 1093 } 1094 if err := validateDirectChannelImportData(&data); err == nil { 1095 t.Fatal("Validation should have failed due to invalid number of members.") 1096 } 1097 1098 data = DirectChannelImportData{ 1099 Members: &[]string{ 1100 model.NewId(), 1101 }, 1102 } 1103 if err := validateDirectChannelImportData(&data); err == nil { 1104 t.Fatal("Validation should have failed due to invalid number of members.") 1105 } 1106 1107 data = DirectChannelImportData{ 1108 Members: &[]string{ 1109 model.NewId(), 1110 model.NewId(), 1111 model.NewId(), 1112 model.NewId(), 1113 model.NewId(), 1114 model.NewId(), 1115 model.NewId(), 1116 model.NewId(), 1117 model.NewId(), 1118 }, 1119 } 1120 if err := validateDirectChannelImportData(&data); err == nil { 1121 t.Fatal("Validation should have failed due to invalid number of members.") 1122 } 1123 1124 // Test with invalid FavoritedBy 1125 member1 := model.NewId() 1126 member2 := model.NewId() 1127 data = DirectChannelImportData{ 1128 Members: &[]string{ 1129 member1, 1130 member2, 1131 }, 1132 FavoritedBy: &[]string{ 1133 member1, 1134 model.NewId(), 1135 }, 1136 } 1137 if err := validateDirectChannelImportData(&data); err == nil { 1138 t.Fatal("Validation should have failed due to non-member favorited.") 1139 } 1140 1141 // Test with valid FavoritedBy 1142 data = DirectChannelImportData{ 1143 Members: &[]string{ 1144 member1, 1145 member2, 1146 }, 1147 FavoritedBy: &[]string{ 1148 member1, 1149 member2, 1150 }, 1151 } 1152 if err := validateDirectChannelImportData(&data); err != nil { 1153 t.Fatal(err) 1154 } 1155 } 1156 1157 func TestImportValidateDirectPostImportData(t *testing.T) { 1158 maxPostSize := 10000 1159 1160 // Test with minimum required valid properties. 1161 data := DirectPostImportData{ 1162 ChannelMembers: &[]string{ 1163 model.NewId(), 1164 model.NewId(), 1165 }, 1166 User: ptrStr("username"), 1167 Message: ptrStr("message"), 1168 CreateAt: ptrInt64(model.GetMillis()), 1169 } 1170 if err := validateDirectPostImportData(&data, maxPostSize); err != nil { 1171 t.Fatal("Validation failed but should have been valid.") 1172 } 1173 1174 // Test with missing required properties. 1175 data = DirectPostImportData{ 1176 User: ptrStr("username"), 1177 Message: ptrStr("message"), 1178 CreateAt: ptrInt64(model.GetMillis()), 1179 } 1180 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1181 t.Fatal("Should have failed due to missing required property.") 1182 } 1183 1184 data = DirectPostImportData{ 1185 ChannelMembers: &[]string{ 1186 model.NewId(), 1187 model.NewId(), 1188 }, 1189 Message: ptrStr("message"), 1190 CreateAt: ptrInt64(model.GetMillis()), 1191 } 1192 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1193 t.Fatal("Should have failed due to missing required property.") 1194 } 1195 1196 data = DirectPostImportData{ 1197 ChannelMembers: &[]string{ 1198 model.NewId(), 1199 model.NewId(), 1200 }, 1201 User: ptrStr("username"), 1202 CreateAt: ptrInt64(model.GetMillis()), 1203 } 1204 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1205 t.Fatal("Should have failed due to missing required property.") 1206 } 1207 1208 data = DirectPostImportData{ 1209 ChannelMembers: &[]string{ 1210 model.NewId(), 1211 model.NewId(), 1212 }, 1213 User: ptrStr("username"), 1214 Message: ptrStr("message"), 1215 } 1216 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1217 t.Fatal("Should have failed due to missing required property.") 1218 } 1219 1220 // Test with invalid numbers of channel members. 1221 data = DirectPostImportData{ 1222 ChannelMembers: &[]string{}, 1223 User: ptrStr("username"), 1224 Message: ptrStr("message"), 1225 CreateAt: ptrInt64(model.GetMillis()), 1226 } 1227 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1228 t.Fatal("Should have failed due to unsuitable number of members.") 1229 } 1230 1231 data = DirectPostImportData{ 1232 ChannelMembers: &[]string{ 1233 model.NewId(), 1234 }, 1235 User: ptrStr("username"), 1236 Message: ptrStr("message"), 1237 CreateAt: ptrInt64(model.GetMillis()), 1238 } 1239 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1240 t.Fatal("Should have failed due to unsuitable number of members.") 1241 } 1242 1243 data = DirectPostImportData{ 1244 ChannelMembers: &[]string{ 1245 model.NewId(), 1246 model.NewId(), 1247 model.NewId(), 1248 model.NewId(), 1249 model.NewId(), 1250 model.NewId(), 1251 model.NewId(), 1252 model.NewId(), 1253 model.NewId(), 1254 model.NewId(), 1255 }, 1256 User: ptrStr("username"), 1257 Message: ptrStr("message"), 1258 CreateAt: ptrInt64(model.GetMillis()), 1259 } 1260 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1261 t.Fatal("Should have failed due to unsuitable number of members.") 1262 } 1263 1264 // Test with group message number of members. 1265 data = DirectPostImportData{ 1266 ChannelMembers: &[]string{ 1267 model.NewId(), 1268 model.NewId(), 1269 model.NewId(), 1270 }, 1271 User: ptrStr("username"), 1272 Message: ptrStr("message"), 1273 CreateAt: ptrInt64(model.GetMillis()), 1274 } 1275 if err := validateDirectPostImportData(&data, maxPostSize); err != nil { 1276 t.Fatal("Validation failed but should have been valid.") 1277 } 1278 1279 // Test with invalid message. 1280 data = DirectPostImportData{ 1281 ChannelMembers: &[]string{ 1282 model.NewId(), 1283 model.NewId(), 1284 }, 1285 User: ptrStr("username"), 1286 Message: ptrStr(strings.Repeat("0", maxPostSize+1)), 1287 CreateAt: ptrInt64(model.GetMillis()), 1288 } 1289 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1290 t.Fatal("Should have failed due to too long message.") 1291 } 1292 1293 // Test with invalid CreateAt 1294 data = DirectPostImportData{ 1295 ChannelMembers: &[]string{ 1296 model.NewId(), 1297 model.NewId(), 1298 }, 1299 User: ptrStr("username"), 1300 Message: ptrStr("message"), 1301 CreateAt: ptrInt64(0), 1302 } 1303 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1304 t.Fatal("Should have failed due to 0 create-at value.") 1305 } 1306 1307 // Test with invalid FlaggedBy 1308 member1 := model.NewId() 1309 member2 := model.NewId() 1310 data = DirectPostImportData{ 1311 ChannelMembers: &[]string{ 1312 member1, 1313 member2, 1314 }, 1315 FlaggedBy: &[]string{ 1316 member1, 1317 model.NewId(), 1318 }, 1319 User: ptrStr("username"), 1320 Message: ptrStr("message"), 1321 CreateAt: ptrInt64(model.GetMillis()), 1322 } 1323 if err := validateDirectPostImportData(&data, maxPostSize); err == nil { 1324 t.Fatal("Validation should have failed due to non-member flagged.") 1325 } 1326 1327 // Test with valid FlaggedBy 1328 data = DirectPostImportData{ 1329 ChannelMembers: &[]string{ 1330 member1, 1331 member2, 1332 }, 1333 FlaggedBy: &[]string{ 1334 member1, 1335 member2, 1336 }, 1337 User: ptrStr("username"), 1338 Message: ptrStr("message"), 1339 CreateAt: ptrInt64(model.GetMillis()), 1340 } 1341 if err := validateDirectPostImportData(&data, maxPostSize); err != nil { 1342 t.Fatal(err) 1343 } 1344 1345 // Test with valid all optional parameters. 1346 reactions := []ReactionImportData{ReactionImportData{ 1347 User: ptrStr("username"), 1348 EmojiName: ptrStr("emoji"), 1349 CreateAt: ptrInt64(model.GetMillis()), 1350 }} 1351 replies := []ReplyImportData{ReplyImportData{ 1352 User: ptrStr("username"), 1353 Message: ptrStr("message"), 1354 CreateAt: ptrInt64(model.GetMillis()), 1355 }} 1356 data = DirectPostImportData{ 1357 ChannelMembers: &[]string{ 1358 member1, 1359 member2, 1360 }, 1361 FlaggedBy: &[]string{ 1362 member1, 1363 member2, 1364 }, 1365 User: ptrStr("username"), 1366 Message: ptrStr("message"), 1367 CreateAt: ptrInt64(model.GetMillis()), 1368 Reactions: &reactions, 1369 Replies: &replies, 1370 } 1371 1372 if err := validateDirectPostImportData(&data, maxPostSize); err != nil { 1373 t.Fatal(err) 1374 } 1375 } 1376 1377 func TestImportValidateEmojiImportData(t *testing.T) { 1378 data := EmojiImportData{ 1379 Name: ptrStr("parrot"), 1380 Image: ptrStr("/path/to/image"), 1381 } 1382 1383 err := validateEmojiImportData(&data) 1384 assert.Nil(t, err, "Validation should succeed") 1385 1386 *data.Name = "smiley" 1387 err = validateEmojiImportData(&data) 1388 assert.NotNil(t, err) 1389 1390 *data.Name = "" 1391 err = validateEmojiImportData(&data) 1392 assert.NotNil(t, err) 1393 1394 *data.Name = "" 1395 *data.Image = "" 1396 err = validateEmojiImportData(&data) 1397 assert.NotNil(t, err) 1398 1399 *data.Image = "/path/to/image" 1400 data.Name = nil 1401 err = validateEmojiImportData(&data) 1402 assert.NotNil(t, err) 1403 1404 data.Name = ptrStr("parrot") 1405 data.Image = nil 1406 err = validateEmojiImportData(&data) 1407 assert.NotNil(t, err) 1408 }