github.com/perimeterx/marshmallow@v1.1.5/unmarshal_test.go (about) 1 // Copyright 2022 PerimeterX. All rights reserved. 2 // Use of this source code is governed by a MIT style 3 // license that can be found in the LICENSE file. 4 5 package marshmallow 6 7 import ( 8 "encoding/json" 9 "errors" 10 "fmt" 11 "github.com/go-test/deep" 12 "github.com/mailru/easyjson/jlexer" 13 "reflect" 14 "strings" 15 "testing" 16 ) 17 18 func TestUnmarshalInputVariations(t *testing.T) { 19 EnableCache() 20 tests := []struct { 21 name string 22 mode Mode 23 expectedErr bool 24 expectedResult bool 25 structModifier func(*parentStruct) 26 inputMapModifier func(map[string]interface{}) 27 expectedMapModifier func(map[string]interface{}) 28 }{ 29 { 30 name: "ModeFailOnFirstError_happy_flow", 31 mode: ModeFailOnFirstError, 32 expectedErr: false, 33 expectedResult: true, 34 structModifier: nil, 35 inputMapModifier: nil, 36 expectedMapModifier: nil, 37 }, 38 { 39 name: "ModeFailOnFirstError_zero_struct_value", 40 mode: ModeFailOnFirstError, 41 expectedErr: false, 42 expectedResult: true, 43 structModifier: func(p *parentStruct) { 44 p.ParentField1 = childStruct{} 45 }, 46 inputMapModifier: nil, 47 expectedMapModifier: nil, 48 }, 49 { 50 name: "ModeFailOnFirstError_null_on_struct", 51 mode: ModeFailOnFirstError, 52 expectedErr: false, 53 expectedResult: true, 54 structModifier: func(p *parentStruct) { 55 p.ParentField1 = childStruct{} 56 }, 57 inputMapModifier: func(m map[string]interface{}) { 58 m["parent_field1"] = nil 59 }, 60 expectedMapModifier: func(m map[string]interface{}) { 61 m["parent_field1"] = nil 62 }, 63 }, 64 { 65 name: "ModeFailOnFirstError_null_on_string", 66 mode: ModeFailOnFirstError, 67 expectedErr: false, 68 expectedResult: true, 69 structModifier: func(p *parentStruct) { 70 p.ParentField1 = childStruct{} 71 }, 72 inputMapModifier: func(m map[string]interface{}) { 73 m["parent_field1"].(map[string]interface{})["child_field1"] = nil 74 }, 75 expectedMapModifier: func(m map[string]interface{}) { 76 c := m["parent_field1"].(childStruct) 77 c.ChildField1 = "" 78 }, 79 }, 80 { 81 name: "ModeFailOnFirstError_null_on_slice", 82 mode: ModeFailOnFirstError, 83 expectedErr: false, 84 expectedResult: true, 85 structModifier: func(p *parentStruct) { 86 p.ParentField1 = childStruct{} 87 }, 88 inputMapModifier: func(m map[string]interface{}) { 89 m["parent_field1"].(map[string]interface{})["child_field30"] = nil 90 }, 91 expectedMapModifier: func(m map[string]interface{}) { 92 c := m["parent_field1"].(childStruct) 93 c.ChildField30 = nil 94 }, 95 }, 96 { 97 name: "ModeFailOnFirstError_null_on_array", 98 mode: ModeFailOnFirstError, 99 expectedErr: false, 100 expectedResult: true, 101 structModifier: func(p *parentStruct) { 102 p.ParentField1 = childStruct{} 103 }, 104 inputMapModifier: func(m map[string]interface{}) { 105 m["parent_field1"].(map[string]interface{})["child_field31"] = nil 106 }, 107 expectedMapModifier: func(m map[string]interface{}) { 108 c := m["parent_field1"].(childStruct) 109 c.ChildField31 = [4]string{} 110 }, 111 }, 112 { 113 name: "ModeFailOnFirstError_null_on_map", 114 mode: ModeFailOnFirstError, 115 expectedErr: false, 116 expectedResult: true, 117 structModifier: func(p *parentStruct) { 118 p.ParentField7 = nil 119 }, 120 inputMapModifier: nil, 121 expectedMapModifier: func(m map[string]interface{}) { 122 m["parent_field7"] = nil 123 }, 124 }, 125 { 126 name: "ModeFailOnFirstError_invalid_struct_value", 127 mode: ModeFailOnFirstError, 128 expectedErr: true, 129 expectedResult: false, 130 structModifier: nil, 131 inputMapModifier: func(m map[string]interface{}) { 132 m["parent_field1"] = 12 133 }, 134 expectedMapModifier: nil, 135 }, 136 { 137 name: "ModeFailOnFirstError_invalid_struct_ptr_value", 138 mode: ModeFailOnFirstError, 139 expectedErr: true, 140 expectedResult: false, 141 structModifier: nil, 142 inputMapModifier: func(m map[string]interface{}) { 143 m["parent_field2"] = 12 144 }, 145 expectedMapModifier: nil, 146 }, 147 { 148 name: "ModeFailOnFirstError_invalid_slice_value", 149 mode: ModeFailOnFirstError, 150 expectedErr: true, 151 expectedResult: false, 152 structModifier: nil, 153 inputMapModifier: func(m map[string]interface{}) { 154 m["parent_field3"] = 12 155 }, 156 expectedMapModifier: nil, 157 }, 158 { 159 name: "ModeFailOnFirstError_invalid_array_value", 160 mode: ModeFailOnFirstError, 161 expectedErr: true, 162 expectedResult: false, 163 structModifier: nil, 164 inputMapModifier: func(m map[string]interface{}) { 165 m["parent_field4"] = 12 166 }, 167 expectedMapModifier: nil, 168 }, 169 { 170 name: "ModeFailOnFirstError_invalid_ptr_slice_value", 171 mode: ModeFailOnFirstError, 172 expectedErr: true, 173 expectedResult: false, 174 structModifier: nil, 175 inputMapModifier: func(m map[string]interface{}) { 176 m["parent_field5"] = 12 177 }, 178 expectedMapModifier: nil, 179 }, 180 { 181 name: "ModeFailOnFirstError_invalid_ptr_array_value", 182 mode: ModeFailOnFirstError, 183 expectedErr: true, 184 expectedResult: false, 185 structModifier: nil, 186 inputMapModifier: func(m map[string]interface{}) { 187 m["parent_field6"] = 12 188 }, 189 expectedMapModifier: nil, 190 }, 191 { 192 name: "ModeFailOnFirstError_invalid_primitive_map_value", 193 mode: ModeFailOnFirstError, 194 expectedErr: true, 195 expectedResult: false, 196 structModifier: nil, 197 inputMapModifier: func(m map[string]interface{}) { 198 m["parent_field7"] = 12 199 }, 200 expectedMapModifier: nil, 201 }, 202 { 203 name: "ModeFailOnFirstError_invalid_struct_map_value", 204 mode: ModeFailOnFirstError, 205 expectedErr: true, 206 expectedResult: false, 207 structModifier: nil, 208 inputMapModifier: func(m map[string]interface{}) { 209 m["parent_field8"] = 12 210 }, 211 expectedMapModifier: nil, 212 }, 213 { 214 name: "ModeFailOnFirstError_invalid_struct_ptr_map_value", 215 mode: ModeFailOnFirstError, 216 expectedErr: true, 217 expectedResult: false, 218 structModifier: nil, 219 inputMapModifier: func(m map[string]interface{}) { 220 m["parent_field9"] = 12 221 }, 222 expectedMapModifier: nil, 223 }, 224 { 225 name: "ModeFailOnFirstError_invalid_string_value", 226 mode: ModeFailOnFirstError, 227 expectedErr: true, 228 expectedResult: false, 229 structModifier: nil, 230 inputMapModifier: func(m map[string]interface{}) { 231 m["parent_field1"].(map[string]interface{})["child_field1"] = map[string]interface{}{"foo": "boo"} 232 }, 233 expectedMapModifier: nil, 234 }, 235 { 236 name: "ModeFailOnFirstError_invalid_bool_value", 237 mode: ModeFailOnFirstError, 238 expectedErr: true, 239 expectedResult: false, 240 structModifier: nil, 241 inputMapModifier: func(m map[string]interface{}) { 242 m["parent_field1"].(map[string]interface{})["child_field2"] = map[string]interface{}{"foo": "boo"} 243 }, 244 expectedMapModifier: nil, 245 }, 246 { 247 name: "ModeFailOnFirstError_invalid_int_value", 248 mode: ModeFailOnFirstError, 249 expectedErr: true, 250 expectedResult: false, 251 structModifier: nil, 252 inputMapModifier: func(m map[string]interface{}) { 253 m["parent_field1"].(map[string]interface{})["child_field3"] = map[string]interface{}{"foo": "boo"} 254 }, 255 expectedMapModifier: nil, 256 }, 257 { 258 name: "ModeFailOnFirstError_invalid_int8_value", 259 mode: ModeFailOnFirstError, 260 expectedErr: true, 261 expectedResult: false, 262 structModifier: nil, 263 inputMapModifier: func(m map[string]interface{}) { 264 m["parent_field1"].(map[string]interface{})["child_field4"] = map[string]interface{}{"foo": "boo"} 265 }, 266 expectedMapModifier: nil, 267 }, 268 { 269 name: "ModeFailOnFirstError_invalid_int16_value", 270 mode: ModeFailOnFirstError, 271 expectedErr: true, 272 expectedResult: false, 273 structModifier: nil, 274 inputMapModifier: func(m map[string]interface{}) { 275 m["parent_field1"].(map[string]interface{})["child_field5"] = map[string]interface{}{"foo": "boo"} 276 }, 277 expectedMapModifier: nil, 278 }, 279 { 280 name: "ModeFailOnFirstError_invalid_int32_value", 281 mode: ModeFailOnFirstError, 282 expectedErr: true, 283 expectedResult: false, 284 structModifier: nil, 285 inputMapModifier: func(m map[string]interface{}) { 286 m["parent_field1"].(map[string]interface{})["child_field6"] = map[string]interface{}{"foo": "boo"} 287 }, 288 expectedMapModifier: nil, 289 }, 290 { 291 name: "ModeFailOnFirstError_invalid_int64_value", 292 mode: ModeFailOnFirstError, 293 expectedErr: true, 294 expectedResult: false, 295 structModifier: nil, 296 inputMapModifier: func(m map[string]interface{}) { 297 m["parent_field1"].(map[string]interface{})["child_field7"] = map[string]interface{}{"foo": "boo"} 298 }, 299 expectedMapModifier: nil, 300 }, 301 { 302 name: "ModeFailOnFirstError_invalid_uint_value", 303 mode: ModeFailOnFirstError, 304 expectedErr: true, 305 expectedResult: false, 306 structModifier: nil, 307 inputMapModifier: func(m map[string]interface{}) { 308 m["parent_field1"].(map[string]interface{})["child_field8"] = map[string]interface{}{"foo": "boo"} 309 }, 310 expectedMapModifier: nil, 311 }, 312 { 313 name: "ModeFailOnFirstError_invalid_uint8_value", 314 mode: ModeFailOnFirstError, 315 expectedErr: true, 316 expectedResult: false, 317 structModifier: nil, 318 inputMapModifier: func(m map[string]interface{}) { 319 m["parent_field1"].(map[string]interface{})["child_field9"] = map[string]interface{}{"foo": "boo"} 320 }, 321 expectedMapModifier: nil, 322 }, 323 { 324 name: "ModeFailOnFirstError_invalid_uint16_value", 325 mode: ModeFailOnFirstError, 326 expectedErr: true, 327 expectedResult: false, 328 structModifier: nil, 329 inputMapModifier: func(m map[string]interface{}) { 330 m["parent_field1"].(map[string]interface{})["child_field10"] = map[string]interface{}{"foo": "boo"} 331 }, 332 expectedMapModifier: nil, 333 }, 334 { 335 name: "ModeFailOnFirstError_invalid_uint32_value", 336 mode: ModeFailOnFirstError, 337 expectedErr: true, 338 expectedResult: false, 339 structModifier: nil, 340 inputMapModifier: func(m map[string]interface{}) { 341 m["parent_field1"].(map[string]interface{})["child_field11"] = map[string]interface{}{"foo": "boo"} 342 }, 343 expectedMapModifier: nil, 344 }, 345 { 346 name: "ModeFailOnFirstError_invalid_uint64_value", 347 mode: ModeFailOnFirstError, 348 expectedErr: true, 349 expectedResult: false, 350 structModifier: nil, 351 inputMapModifier: func(m map[string]interface{}) { 352 m["parent_field1"].(map[string]interface{})["child_field12"] = map[string]interface{}{"foo": "boo"} 353 }, 354 expectedMapModifier: nil, 355 }, 356 { 357 name: "ModeFailOnFirstError_invalid_float32_value", 358 mode: ModeFailOnFirstError, 359 expectedErr: true, 360 expectedResult: false, 361 structModifier: nil, 362 inputMapModifier: func(m map[string]interface{}) { 363 m["parent_field1"].(map[string]interface{})["child_field13"] = map[string]interface{}{"foo": "boo"} 364 }, 365 expectedMapModifier: nil, 366 }, 367 { 368 name: "ModeFailOnFirstError_invalid_float64_value", 369 mode: ModeFailOnFirstError, 370 expectedErr: true, 371 expectedResult: false, 372 structModifier: nil, 373 inputMapModifier: func(m map[string]interface{}) { 374 m["parent_field1"].(map[string]interface{})["child_field14"] = map[string]interface{}{"foo": "boo"} 375 }, 376 expectedMapModifier: nil, 377 }, 378 { 379 name: "ModeFailOnFirstError_invalid_string_ptr_value", 380 mode: ModeFailOnFirstError, 381 expectedErr: true, 382 expectedResult: false, 383 structModifier: nil, 384 inputMapModifier: func(m map[string]interface{}) { 385 m["parent_field1"].(map[string]interface{})["child_field15"] = map[string]interface{}{"foo": "boo"} 386 }, 387 expectedMapModifier: nil, 388 }, 389 { 390 name: "ModeFailOnFirstError_invalid_bool_ptr_value", 391 mode: ModeFailOnFirstError, 392 expectedErr: true, 393 expectedResult: false, 394 structModifier: nil, 395 inputMapModifier: func(m map[string]interface{}) { 396 m["parent_field1"].(map[string]interface{})["child_field16"] = map[string]interface{}{"foo": "boo"} 397 }, 398 expectedMapModifier: nil, 399 }, 400 { 401 name: "ModeFailOnFirstError_invalid_int_ptr_value", 402 mode: ModeFailOnFirstError, 403 expectedErr: true, 404 expectedResult: false, 405 structModifier: nil, 406 inputMapModifier: func(m map[string]interface{}) { 407 m["parent_field1"].(map[string]interface{})["child_field17"] = map[string]interface{}{"foo": "boo"} 408 }, 409 expectedMapModifier: nil, 410 }, 411 { 412 name: "ModeFailOnFirstError_invalid_int8_ptr_value", 413 mode: ModeFailOnFirstError, 414 expectedErr: true, 415 expectedResult: false, 416 structModifier: nil, 417 inputMapModifier: func(m map[string]interface{}) { 418 m["parent_field1"].(map[string]interface{})["child_field18"] = map[string]interface{}{"foo": "boo"} 419 }, 420 expectedMapModifier: nil, 421 }, 422 { 423 name: "ModeFailOnFirstError_invalid_int16_ptr_value", 424 mode: ModeFailOnFirstError, 425 expectedErr: true, 426 expectedResult: false, 427 structModifier: nil, 428 inputMapModifier: func(m map[string]interface{}) { 429 m["parent_field1"].(map[string]interface{})["child_field19"] = map[string]interface{}{"foo": "boo"} 430 }, 431 expectedMapModifier: nil, 432 }, 433 { 434 name: "ModeFailOnFirstError_invalid_int32_ptr_value", 435 mode: ModeFailOnFirstError, 436 expectedErr: true, 437 expectedResult: false, 438 structModifier: nil, 439 inputMapModifier: func(m map[string]interface{}) { 440 m["parent_field1"].(map[string]interface{})["child_field20"] = map[string]interface{}{"foo": "boo"} 441 }, 442 expectedMapModifier: nil, 443 }, 444 { 445 name: "ModeFailOnFirstError_invalid_int64_ptr_value", 446 mode: ModeFailOnFirstError, 447 expectedErr: true, 448 expectedResult: false, 449 structModifier: nil, 450 inputMapModifier: func(m map[string]interface{}) { 451 m["parent_field1"].(map[string]interface{})["child_field21"] = map[string]interface{}{"foo": "boo"} 452 }, 453 expectedMapModifier: nil, 454 }, 455 { 456 name: "ModeFailOnFirstError_invalid_uint_ptr_value", 457 mode: ModeFailOnFirstError, 458 expectedErr: true, 459 expectedResult: false, 460 structModifier: nil, 461 inputMapModifier: func(m map[string]interface{}) { 462 m["parent_field1"].(map[string]interface{})["child_field22"] = map[string]interface{}{"foo": "boo"} 463 }, 464 expectedMapModifier: nil, 465 }, 466 { 467 name: "ModeFailOnFirstError_invalid_uint8_ptr_value", 468 mode: ModeFailOnFirstError, 469 expectedErr: true, 470 expectedResult: false, 471 structModifier: nil, 472 inputMapModifier: func(m map[string]interface{}) { 473 m["parent_field1"].(map[string]interface{})["child_field23"] = map[string]interface{}{"foo": "boo"} 474 }, 475 expectedMapModifier: nil, 476 }, 477 { 478 name: "ModeFailOnFirstError_invalid_uint16_ptr_value", 479 mode: ModeFailOnFirstError, 480 expectedErr: true, 481 expectedResult: false, 482 structModifier: nil, 483 inputMapModifier: func(m map[string]interface{}) { 484 m["parent_field1"].(map[string]interface{})["child_field24"] = map[string]interface{}{"foo": "boo"} 485 }, 486 expectedMapModifier: nil, 487 }, 488 { 489 name: "ModeFailOnFirstError_invalid_uint32_ptr_value", 490 mode: ModeFailOnFirstError, 491 expectedErr: true, 492 expectedResult: false, 493 structModifier: nil, 494 inputMapModifier: func(m map[string]interface{}) { 495 m["parent_field1"].(map[string]interface{})["child_field25"] = map[string]interface{}{"foo": "boo"} 496 }, 497 expectedMapModifier: nil, 498 }, 499 { 500 name: "ModeFailOnFirstError_invalid_uint64_ptr_value", 501 mode: ModeFailOnFirstError, 502 expectedErr: true, 503 expectedResult: false, 504 structModifier: nil, 505 inputMapModifier: func(m map[string]interface{}) { 506 m["parent_field1"].(map[string]interface{})["child_field26"] = map[string]interface{}{"foo": "boo"} 507 }, 508 expectedMapModifier: nil, 509 }, 510 { 511 name: "ModeFailOnFirstError_invalid_float32_ptr_value", 512 mode: ModeFailOnFirstError, 513 expectedErr: true, 514 expectedResult: false, 515 structModifier: nil, 516 inputMapModifier: func(m map[string]interface{}) { 517 m["parent_field1"].(map[string]interface{})["child_field27"] = map[string]interface{}{"foo": "boo"} 518 }, 519 expectedMapModifier: nil, 520 }, 521 { 522 name: "ModeFailOnFirstError_invalid_float64_ptr_value", 523 mode: ModeFailOnFirstError, 524 expectedErr: true, 525 expectedResult: false, 526 structModifier: nil, 527 inputMapModifier: func(m map[string]interface{}) { 528 m["parent_field1"].(map[string]interface{})["child_field28"] = map[string]interface{}{"foo": "boo"} 529 }, 530 expectedMapModifier: nil, 531 }, 532 { 533 name: "ModeFailOnFirstError_invalid_string_slice_value", 534 mode: ModeFailOnFirstError, 535 expectedErr: true, 536 expectedResult: false, 537 structModifier: nil, 538 inputMapModifier: func(m map[string]interface{}) { 539 m["parent_field1"].(map[string]interface{})["child_field30"] = map[string]interface{}{"foo": "boo"} 540 }, 541 expectedMapModifier: nil, 542 }, 543 { 544 name: "ModeFailOnFirstError_invalid_string_array_value", 545 mode: ModeFailOnFirstError, 546 expectedErr: true, 547 expectedResult: false, 548 structModifier: nil, 549 inputMapModifier: func(m map[string]interface{}) { 550 m["parent_field1"].(map[string]interface{})["child_field31"] = map[string]interface{}{"foo": "boo"} 551 }, 552 expectedMapModifier: nil, 553 }, 554 { 555 name: "ModeFailOnFirstError_invalid_slice_element", 556 mode: ModeFailOnFirstError, 557 expectedErr: true, 558 expectedResult: false, 559 structModifier: nil, 560 inputMapModifier: func(m map[string]interface{}) { 561 m["parent_field3"] = []interface{}{nil, "foo", nil, nil} 562 }, 563 expectedMapModifier: nil, 564 }, 565 { 566 name: "ModeFailOnFirstError_invalid_array_element", 567 mode: ModeFailOnFirstError, 568 expectedErr: true, 569 expectedResult: false, 570 structModifier: nil, 571 inputMapModifier: func(m map[string]interface{}) { 572 m["parent_field4"] = []interface{}{nil, "foo", nil, nil} 573 }, 574 expectedMapModifier: nil, 575 }, 576 { 577 name: "ModeFailOnFirstError_invalid_map_entry", 578 mode: ModeFailOnFirstError, 579 expectedErr: true, 580 expectedResult: false, 581 structModifier: nil, 582 inputMapModifier: func(m map[string]interface{}) { 583 m["parent_field7"] = map[string]interface{}{"foo": "a", "goo": 12, "boo": "c"} 584 }, 585 expectedMapModifier: nil, 586 }, 587 { 588 name: "ModeAllowMultipleErrors_happy_flow", 589 mode: ModeAllowMultipleErrors, 590 expectedErr: false, 591 expectedResult: true, 592 structModifier: nil, 593 inputMapModifier: nil, 594 expectedMapModifier: nil, 595 }, 596 { 597 name: "ModeAllowMultipleErrors_zero_struct_value", 598 mode: ModeAllowMultipleErrors, 599 expectedErr: false, 600 expectedResult: true, 601 structModifier: func(p *parentStruct) { 602 p.ParentField1 = childStruct{} 603 }, 604 inputMapModifier: nil, 605 expectedMapModifier: nil, 606 }, 607 { 608 name: "ModeAllowMultipleErrors_null_on_struct", 609 mode: ModeAllowMultipleErrors, 610 expectedErr: false, 611 expectedResult: true, 612 structModifier: func(p *parentStruct) { 613 p.ParentField1 = childStruct{} 614 }, 615 inputMapModifier: func(m map[string]interface{}) { 616 m["parent_field1"] = nil 617 }, 618 expectedMapModifier: func(m map[string]interface{}) { 619 m["parent_field1"] = nil 620 }, 621 }, 622 { 623 name: "ModeAllowMultipleErrors_null_on_string", 624 mode: ModeAllowMultipleErrors, 625 expectedErr: false, 626 expectedResult: true, 627 structModifier: func(p *parentStruct) { 628 p.ParentField1 = childStruct{} 629 }, 630 inputMapModifier: func(m map[string]interface{}) { 631 m["parent_field1"].(map[string]interface{})["child_field1"] = nil 632 }, 633 expectedMapModifier: func(m map[string]interface{}) { 634 c := m["parent_field1"].(childStruct) 635 c.ChildField1 = "" 636 }, 637 }, 638 { 639 name: "ModeAllowMultipleErrors_null_on_slice", 640 mode: ModeAllowMultipleErrors, 641 expectedErr: false, 642 expectedResult: true, 643 structModifier: func(p *parentStruct) { 644 p.ParentField1 = childStruct{} 645 }, 646 inputMapModifier: func(m map[string]interface{}) { 647 m["parent_field1"].(map[string]interface{})["child_field30"] = nil 648 }, 649 expectedMapModifier: func(m map[string]interface{}) { 650 c := m["parent_field1"].(childStruct) 651 c.ChildField30 = nil 652 }, 653 }, 654 { 655 name: "ModeAllowMultipleErrors_null_on_array", 656 mode: ModeAllowMultipleErrors, 657 expectedErr: false, 658 expectedResult: true, 659 structModifier: func(p *parentStruct) { 660 p.ParentField1 = childStruct{} 661 }, 662 inputMapModifier: func(m map[string]interface{}) { 663 m["parent_field1"].(map[string]interface{})["child_field31"] = nil 664 }, 665 expectedMapModifier: func(m map[string]interface{}) { 666 c := m["parent_field1"].(childStruct) 667 c.ChildField31 = [4]string{} 668 }, 669 }, 670 { 671 name: "ModeAllowMultipleErrors_null_on_map", 672 mode: ModeAllowMultipleErrors, 673 expectedErr: false, 674 expectedResult: true, 675 structModifier: func(p *parentStruct) { 676 p.ParentField7 = nil 677 }, 678 inputMapModifier: nil, 679 expectedMapModifier: func(m map[string]interface{}) { 680 m["parent_field7"] = nil 681 }, 682 }, 683 { 684 name: "ModeAllowMultipleErrors_invalid_struct_value", 685 mode: ModeAllowMultipleErrors, 686 expectedErr: true, 687 expectedResult: true, 688 structModifier: func(p *parentStruct) { 689 p.ParentField1 = childStruct{} 690 }, 691 inputMapModifier: func(m map[string]interface{}) { 692 m["parent_field1"] = 12 693 }, 694 expectedMapModifier: func(m map[string]interface{}) { 695 delete(m, "parent_field1") 696 }, 697 }, 698 { 699 name: "ModeAllowMultipleErrors_invalid_struct_ptr_value", 700 mode: ModeAllowMultipleErrors, 701 expectedErr: true, 702 expectedResult: true, 703 structModifier: func(p *parentStruct) { 704 p.ParentField2 = nil 705 }, 706 inputMapModifier: func(m map[string]interface{}) { 707 m["parent_field2"] = 12 708 }, 709 expectedMapModifier: func(m map[string]interface{}) { 710 delete(m, "parent_field2") 711 }, 712 }, 713 { 714 name: "ModeAllowMultipleErrors_invalid_slice_value", 715 mode: ModeAllowMultipleErrors, 716 expectedErr: true, 717 expectedResult: true, 718 structModifier: func(p *parentStruct) { 719 p.ParentField3 = nil 720 }, 721 inputMapModifier: func(m map[string]interface{}) { 722 m["parent_field3"] = 12 723 }, 724 expectedMapModifier: func(m map[string]interface{}) { 725 delete(m, "parent_field3") 726 }, 727 }, 728 { 729 name: "ModeAllowMultipleErrors_invalid_array_value", 730 mode: ModeAllowMultipleErrors, 731 expectedErr: true, 732 expectedResult: true, 733 structModifier: func(p *parentStruct) { 734 p.ParentField4 = [4]childStruct{} 735 }, 736 inputMapModifier: func(m map[string]interface{}) { 737 m["parent_field4"] = 12 738 }, 739 expectedMapModifier: func(m map[string]interface{}) { 740 delete(m, "parent_field4") 741 }, 742 }, 743 { 744 name: "ModeAllowMultipleErrors_invalid_ptr_slice_value", 745 mode: ModeAllowMultipleErrors, 746 expectedErr: true, 747 expectedResult: true, 748 structModifier: func(p *parentStruct) { 749 p.ParentField5 = nil 750 }, 751 inputMapModifier: func(m map[string]interface{}) { 752 m["parent_field5"] = 12 753 }, 754 expectedMapModifier: func(m map[string]interface{}) { 755 delete(m, "parent_field5") 756 }, 757 }, 758 { 759 name: "ModeAllowMultipleErrors_invalid_ptr_array_value", 760 mode: ModeAllowMultipleErrors, 761 expectedErr: true, 762 expectedResult: true, 763 structModifier: func(p *parentStruct) { 764 p.ParentField6 = [4]*childStruct{} 765 }, 766 inputMapModifier: func(m map[string]interface{}) { 767 m["parent_field6"] = 12 768 }, 769 expectedMapModifier: func(m map[string]interface{}) { 770 delete(m, "parent_field6") 771 }, 772 }, 773 { 774 name: "ModeAllowMultipleErrors_invalid_primitive_map_value", 775 mode: ModeAllowMultipleErrors, 776 expectedErr: true, 777 expectedResult: true, 778 structModifier: func(p *parentStruct) { 779 p.ParentField7 = nil 780 }, 781 inputMapModifier: func(m map[string]interface{}) { 782 m["parent_field7"] = 12 783 }, 784 expectedMapModifier: func(m map[string]interface{}) { 785 delete(m, "parent_field7") 786 }, 787 }, 788 { 789 name: "ModeAllowMultipleErrors_invalid_struct_map_value", 790 mode: ModeAllowMultipleErrors, 791 expectedErr: true, 792 expectedResult: true, 793 structModifier: func(p *parentStruct) { 794 p.ParentField8 = nil 795 }, 796 inputMapModifier: func(m map[string]interface{}) { 797 m["parent_field8"] = 12 798 }, 799 expectedMapModifier: func(m map[string]interface{}) { 800 delete(m, "parent_field8") 801 }, 802 }, 803 { 804 name: "ModeAllowMultipleErrors_invalid_struct_ptr_map_value", 805 mode: ModeAllowMultipleErrors, 806 expectedErr: true, 807 expectedResult: true, 808 structModifier: func(p *parentStruct) { 809 p.ParentField9 = nil 810 }, 811 inputMapModifier: func(m map[string]interface{}) { 812 m["parent_field9"] = 12 813 }, 814 expectedMapModifier: func(m map[string]interface{}) { 815 delete(m, "parent_field9") 816 }, 817 }, 818 { 819 name: "ModeAllowMultipleErrors_invalid_string_value", 820 mode: ModeAllowMultipleErrors, 821 expectedErr: true, 822 expectedResult: true, 823 structModifier: func(p *parentStruct) { 824 p.ParentField1.ChildField1 = "" 825 }, 826 inputMapModifier: func(m map[string]interface{}) { 827 m["parent_field1"].(map[string]interface{})["child_field1"] = map[string]interface{}{"foo": "boo"} 828 }, 829 expectedMapModifier: func(m map[string]interface{}) { 830 c := m["parent_field1"].(childStruct) 831 c.ChildField1 = "" 832 }, 833 }, 834 { 835 name: "ModeAllowMultipleErrors_invalid_bool_value", 836 mode: ModeAllowMultipleErrors, 837 expectedErr: true, 838 expectedResult: true, 839 structModifier: func(p *parentStruct) { 840 p.ParentField1.ChildField2 = false 841 }, 842 inputMapModifier: func(m map[string]interface{}) { 843 m["parent_field1"].(map[string]interface{})["child_field2"] = map[string]interface{}{"foo": "boo"} 844 }, 845 expectedMapModifier: func(m map[string]interface{}) { 846 c := m["parent_field1"].(childStruct) 847 c.ChildField2 = false 848 }, 849 }, 850 { 851 name: "ModeAllowMultipleErrors_invalid_int_value", 852 mode: ModeAllowMultipleErrors, 853 expectedErr: true, 854 expectedResult: true, 855 structModifier: func(p *parentStruct) { 856 p.ParentField1.ChildField3 = 0 857 }, 858 inputMapModifier: func(m map[string]interface{}) { 859 m["parent_field1"].(map[string]interface{})["child_field3"] = map[string]interface{}{"foo": "boo"} 860 }, 861 expectedMapModifier: func(m map[string]interface{}) { 862 c := m["parent_field1"].(childStruct) 863 c.ChildField3 = 0 864 }, 865 }, 866 { 867 name: "ModeAllowMultipleErrors_invalid_int8_value", 868 mode: ModeAllowMultipleErrors, 869 expectedErr: true, 870 expectedResult: true, 871 structModifier: func(p *parentStruct) { 872 p.ParentField1.ChildField4 = int8(0) 873 }, 874 inputMapModifier: func(m map[string]interface{}) { 875 m["parent_field1"].(map[string]interface{})["child_field4"] = map[string]interface{}{"foo": "boo"} 876 }, 877 expectedMapModifier: func(m map[string]interface{}) { 878 c := m["parent_field1"].(childStruct) 879 c.ChildField4 = int8(0) 880 }, 881 }, 882 { 883 name: "ModeAllowMultipleErrors_invalid_int16_value", 884 mode: ModeAllowMultipleErrors, 885 expectedErr: true, 886 expectedResult: true, 887 structModifier: func(p *parentStruct) { 888 p.ParentField1.ChildField5 = int16(0) 889 }, 890 inputMapModifier: func(m map[string]interface{}) { 891 m["parent_field1"].(map[string]interface{})["child_field5"] = map[string]interface{}{"foo": "boo"} 892 }, 893 expectedMapModifier: func(m map[string]interface{}) { 894 c := m["parent_field1"].(childStruct) 895 c.ChildField5 = int16(0) 896 }, 897 }, 898 { 899 name: "ModeAllowMultipleErrors_invalid_int32_value", 900 mode: ModeAllowMultipleErrors, 901 expectedErr: true, 902 expectedResult: true, 903 structModifier: func(p *parentStruct) { 904 p.ParentField1.ChildField6 = int32(0) 905 }, 906 inputMapModifier: func(m map[string]interface{}) { 907 m["parent_field1"].(map[string]interface{})["child_field6"] = map[string]interface{}{"foo": "boo"} 908 }, 909 expectedMapModifier: func(m map[string]interface{}) { 910 c := m["parent_field1"].(childStruct) 911 c.ChildField6 = int32(0) 912 }, 913 }, 914 { 915 name: "ModeAllowMultipleErrors_invalid_int64_value", 916 mode: ModeAllowMultipleErrors, 917 expectedErr: true, 918 expectedResult: true, 919 structModifier: func(p *parentStruct) { 920 p.ParentField1.ChildField7 = int64(0) 921 }, 922 inputMapModifier: func(m map[string]interface{}) { 923 m["parent_field1"].(map[string]interface{})["child_field7"] = map[string]interface{}{"foo": "boo"} 924 }, 925 expectedMapModifier: func(m map[string]interface{}) { 926 c := m["parent_field1"].(childStruct) 927 c.ChildField7 = int64(0) 928 }, 929 }, 930 { 931 name: "ModeAllowMultipleErrors_invalid_uint_value", 932 mode: ModeAllowMultipleErrors, 933 expectedErr: true, 934 expectedResult: true, 935 structModifier: func(p *parentStruct) { 936 p.ParentField1.ChildField8 = uint(0) 937 }, 938 inputMapModifier: func(m map[string]interface{}) { 939 m["parent_field1"].(map[string]interface{})["child_field8"] = map[string]interface{}{"foo": "boo"} 940 }, 941 expectedMapModifier: func(m map[string]interface{}) { 942 c := m["parent_field1"].(childStruct) 943 c.ChildField8 = uint(0) 944 }, 945 }, 946 { 947 name: "ModeAllowMultipleErrors_invalid_uint8_value", 948 mode: ModeAllowMultipleErrors, 949 expectedErr: true, 950 expectedResult: true, 951 structModifier: func(p *parentStruct) { 952 p.ParentField1.ChildField9 = uint8(0) 953 }, 954 inputMapModifier: func(m map[string]interface{}) { 955 m["parent_field1"].(map[string]interface{})["child_field9"] = map[string]interface{}{"foo": "boo"} 956 }, 957 expectedMapModifier: func(m map[string]interface{}) { 958 c := m["parent_field1"].(childStruct) 959 c.ChildField9 = uint8(0) 960 }, 961 }, 962 { 963 name: "ModeAllowMultipleErrors_invalid_uint16_value", 964 mode: ModeAllowMultipleErrors, 965 expectedErr: true, 966 expectedResult: true, 967 structModifier: func(p *parentStruct) { 968 p.ParentField1.ChildField10 = uint16(0) 969 }, 970 inputMapModifier: func(m map[string]interface{}) { 971 m["parent_field1"].(map[string]interface{})["child_field10"] = map[string]interface{}{"foo": "boo"} 972 }, 973 expectedMapModifier: func(m map[string]interface{}) { 974 c := m["parent_field1"].(childStruct) 975 c.ChildField10 = uint16(0) 976 }, 977 }, 978 { 979 name: "ModeAllowMultipleErrors_invalid_uint32_value", 980 mode: ModeAllowMultipleErrors, 981 expectedErr: true, 982 expectedResult: true, 983 structModifier: func(p *parentStruct) { 984 p.ParentField1.ChildField11 = uint32(0) 985 }, 986 inputMapModifier: func(m map[string]interface{}) { 987 m["parent_field1"].(map[string]interface{})["child_field11"] = map[string]interface{}{"foo": "boo"} 988 }, 989 expectedMapModifier: func(m map[string]interface{}) { 990 c := m["parent_field1"].(childStruct) 991 c.ChildField11 = uint32(0) 992 }, 993 }, 994 { 995 name: "ModeAllowMultipleErrors_invalid_uint64_value", 996 mode: ModeAllowMultipleErrors, 997 expectedErr: true, 998 expectedResult: true, 999 structModifier: func(p *parentStruct) { 1000 p.ParentField1.ChildField12 = uint64(0) 1001 }, 1002 inputMapModifier: func(m map[string]interface{}) { 1003 m["parent_field1"].(map[string]interface{})["child_field12"] = map[string]interface{}{"foo": "boo"} 1004 }, 1005 expectedMapModifier: func(m map[string]interface{}) { 1006 c := m["parent_field1"].(childStruct) 1007 c.ChildField12 = uint64(0) 1008 }, 1009 }, 1010 { 1011 name: "ModeAllowMultipleErrors_invalid_float32_value", 1012 mode: ModeAllowMultipleErrors, 1013 expectedErr: true, 1014 expectedResult: true, 1015 structModifier: func(p *parentStruct) { 1016 p.ParentField1.ChildField13 = float32(0) 1017 }, 1018 inputMapModifier: func(m map[string]interface{}) { 1019 m["parent_field1"].(map[string]interface{})["child_field13"] = map[string]interface{}{"foo": "boo"} 1020 }, 1021 expectedMapModifier: func(m map[string]interface{}) { 1022 c := m["parent_field1"].(childStruct) 1023 c.ChildField13 = float32(0) 1024 }, 1025 }, 1026 { 1027 name: "ModeAllowMultipleErrors_invalid_float64_value", 1028 mode: ModeAllowMultipleErrors, 1029 expectedErr: true, 1030 expectedResult: true, 1031 structModifier: func(p *parentStruct) { 1032 p.ParentField1.ChildField14 = float64(0) 1033 }, 1034 inputMapModifier: func(m map[string]interface{}) { 1035 m["parent_field1"].(map[string]interface{})["child_field14"] = map[string]interface{}{"foo": "boo"} 1036 }, 1037 expectedMapModifier: func(m map[string]interface{}) { 1038 c := m["parent_field1"].(childStruct) 1039 c.ChildField14 = float64(0) 1040 }, 1041 }, 1042 { 1043 name: "ModeAllowMultipleErrors_invalid_string_ptr_value", 1044 mode: ModeAllowMultipleErrors, 1045 expectedErr: true, 1046 expectedResult: true, 1047 structModifier: func(p *parentStruct) { 1048 p.ParentField1.ChildField15 = nil 1049 }, 1050 inputMapModifier: func(m map[string]interface{}) { 1051 m["parent_field1"].(map[string]interface{})["child_field15"] = map[string]interface{}{"foo": "boo"} 1052 }, 1053 expectedMapModifier: func(m map[string]interface{}) { 1054 c := m["parent_field1"].(childStruct) 1055 c.ChildField15 = nil 1056 }, 1057 }, 1058 { 1059 name: "ModeAllowMultipleErrors_invalid_bool_ptr_value", 1060 mode: ModeAllowMultipleErrors, 1061 expectedErr: true, 1062 expectedResult: true, 1063 structModifier: func(p *parentStruct) { 1064 p.ParentField1.ChildField16 = nil 1065 }, 1066 inputMapModifier: func(m map[string]interface{}) { 1067 m["parent_field1"].(map[string]interface{})["child_field16"] = map[string]interface{}{"foo": "boo"} 1068 }, 1069 expectedMapModifier: func(m map[string]interface{}) { 1070 c := m["parent_field1"].(childStruct) 1071 c.ChildField16 = nil 1072 }, 1073 }, 1074 { 1075 name: "ModeAllowMultipleErrors_invalid_int_ptr_value", 1076 mode: ModeAllowMultipleErrors, 1077 expectedErr: true, 1078 expectedResult: true, 1079 structModifier: func(p *parentStruct) { 1080 p.ParentField1.ChildField17 = nil 1081 }, 1082 inputMapModifier: func(m map[string]interface{}) { 1083 m["parent_field1"].(map[string]interface{})["child_field17"] = map[string]interface{}{"foo": "boo"} 1084 }, 1085 expectedMapModifier: func(m map[string]interface{}) { 1086 c := m["parent_field1"].(childStruct) 1087 c.ChildField17 = nil 1088 }, 1089 }, 1090 { 1091 name: "ModeAllowMultipleErrors_invalid_int8_ptr_value", 1092 mode: ModeAllowMultipleErrors, 1093 expectedErr: true, 1094 expectedResult: true, 1095 structModifier: func(p *parentStruct) { 1096 p.ParentField1.ChildField18 = nil 1097 }, 1098 inputMapModifier: func(m map[string]interface{}) { 1099 m["parent_field1"].(map[string]interface{})["child_field18"] = map[string]interface{}{"foo": "boo"} 1100 }, 1101 expectedMapModifier: func(m map[string]interface{}) { 1102 c := m["parent_field1"].(childStruct) 1103 c.ChildField18 = nil 1104 }, 1105 }, 1106 { 1107 name: "ModeAllowMultipleErrors_invalid_int16_ptr_value", 1108 mode: ModeAllowMultipleErrors, 1109 expectedErr: true, 1110 expectedResult: true, 1111 structModifier: func(p *parentStruct) { 1112 p.ParentField1.ChildField19 = nil 1113 }, 1114 inputMapModifier: func(m map[string]interface{}) { 1115 m["parent_field1"].(map[string]interface{})["child_field19"] = map[string]interface{}{"foo": "boo"} 1116 }, 1117 expectedMapModifier: func(m map[string]interface{}) { 1118 c := m["parent_field1"].(childStruct) 1119 c.ChildField19 = nil 1120 }, 1121 }, 1122 { 1123 name: "ModeAllowMultipleErrors_invalid_int32_ptr_value", 1124 mode: ModeAllowMultipleErrors, 1125 expectedErr: true, 1126 expectedResult: true, 1127 structModifier: func(p *parentStruct) { 1128 p.ParentField1.ChildField20 = nil 1129 }, 1130 inputMapModifier: func(m map[string]interface{}) { 1131 m["parent_field1"].(map[string]interface{})["child_field20"] = map[string]interface{}{"foo": "boo"} 1132 }, 1133 expectedMapModifier: func(m map[string]interface{}) { 1134 c := m["parent_field1"].(childStruct) 1135 c.ChildField20 = nil 1136 }, 1137 }, 1138 { 1139 name: "ModeAllowMultipleErrors_invalid_int64_ptr_value", 1140 mode: ModeAllowMultipleErrors, 1141 expectedErr: true, 1142 expectedResult: true, 1143 structModifier: func(p *parentStruct) { 1144 p.ParentField1.ChildField21 = nil 1145 }, 1146 inputMapModifier: func(m map[string]interface{}) { 1147 m["parent_field1"].(map[string]interface{})["child_field21"] = map[string]interface{}{"foo": "boo"} 1148 }, 1149 expectedMapModifier: func(m map[string]interface{}) { 1150 c := m["parent_field1"].(childStruct) 1151 c.ChildField21 = nil 1152 }, 1153 }, 1154 { 1155 name: "ModeAllowMultipleErrors_invalid_uint_ptr_value", 1156 mode: ModeAllowMultipleErrors, 1157 expectedErr: true, 1158 expectedResult: true, 1159 structModifier: func(p *parentStruct) { 1160 p.ParentField1.ChildField22 = nil 1161 }, 1162 inputMapModifier: func(m map[string]interface{}) { 1163 m["parent_field1"].(map[string]interface{})["child_field22"] = map[string]interface{}{"foo": "boo"} 1164 }, 1165 expectedMapModifier: func(m map[string]interface{}) { 1166 c := m["parent_field1"].(childStruct) 1167 c.ChildField22 = nil 1168 }, 1169 }, 1170 { 1171 name: "ModeAllowMultipleErrors_invalid_uint8_ptr_value", 1172 mode: ModeAllowMultipleErrors, 1173 expectedErr: true, 1174 expectedResult: true, 1175 structModifier: func(p *parentStruct) { 1176 p.ParentField1.ChildField23 = nil 1177 }, 1178 inputMapModifier: func(m map[string]interface{}) { 1179 m["parent_field1"].(map[string]interface{})["child_field23"] = map[string]interface{}{"foo": "boo"} 1180 }, 1181 expectedMapModifier: func(m map[string]interface{}) { 1182 c := m["parent_field1"].(childStruct) 1183 c.ChildField23 = nil 1184 }, 1185 }, 1186 { 1187 name: "ModeAllowMultipleErrors_invalid_uint16_ptr_value", 1188 mode: ModeAllowMultipleErrors, 1189 expectedErr: true, 1190 expectedResult: true, 1191 structModifier: func(p *parentStruct) { 1192 p.ParentField1.ChildField24 = nil 1193 }, 1194 inputMapModifier: func(m map[string]interface{}) { 1195 m["parent_field1"].(map[string]interface{})["child_field24"] = map[string]interface{}{"foo": "boo"} 1196 }, 1197 expectedMapModifier: func(m map[string]interface{}) { 1198 c := m["parent_field1"].(childStruct) 1199 c.ChildField24 = nil 1200 }, 1201 }, 1202 { 1203 name: "ModeAllowMultipleErrors_invalid_uint32_ptr_value", 1204 mode: ModeAllowMultipleErrors, 1205 expectedErr: true, 1206 expectedResult: true, 1207 structModifier: func(p *parentStruct) { 1208 p.ParentField1.ChildField25 = nil 1209 }, 1210 inputMapModifier: func(m map[string]interface{}) { 1211 m["parent_field1"].(map[string]interface{})["child_field25"] = map[string]interface{}{"foo": "boo"} 1212 }, 1213 expectedMapModifier: func(m map[string]interface{}) { 1214 c := m["parent_field1"].(childStruct) 1215 c.ChildField25 = nil 1216 }, 1217 }, 1218 { 1219 name: "ModeAllowMultipleErrors_invalid_uint64_ptr_value", 1220 mode: ModeAllowMultipleErrors, 1221 expectedErr: true, 1222 expectedResult: true, 1223 structModifier: func(p *parentStruct) { 1224 p.ParentField1.ChildField26 = nil 1225 }, 1226 inputMapModifier: func(m map[string]interface{}) { 1227 m["parent_field1"].(map[string]interface{})["child_field26"] = map[string]interface{}{"foo": "boo"} 1228 }, 1229 expectedMapModifier: func(m map[string]interface{}) { 1230 c := m["parent_field1"].(childStruct) 1231 c.ChildField26 = nil 1232 }, 1233 }, 1234 { 1235 name: "ModeAllowMultipleErrors_invalid_float32_ptr_value", 1236 mode: ModeAllowMultipleErrors, 1237 expectedErr: true, 1238 expectedResult: true, 1239 structModifier: func(p *parentStruct) { 1240 p.ParentField1.ChildField27 = nil 1241 }, 1242 inputMapModifier: func(m map[string]interface{}) { 1243 m["parent_field1"].(map[string]interface{})["child_field27"] = map[string]interface{}{"foo": "boo"} 1244 }, 1245 expectedMapModifier: func(m map[string]interface{}) { 1246 c := m["parent_field1"].(childStruct) 1247 c.ChildField27 = nil 1248 }, 1249 }, 1250 { 1251 name: "ModeAllowMultipleErrors_invalid_float64_ptr_value", 1252 mode: ModeAllowMultipleErrors, 1253 expectedErr: true, 1254 expectedResult: true, 1255 structModifier: func(p *parentStruct) { 1256 p.ParentField1.ChildField28 = nil 1257 }, 1258 inputMapModifier: func(m map[string]interface{}) { 1259 m["parent_field1"].(map[string]interface{})["child_field28"] = map[string]interface{}{"foo": "boo"} 1260 }, 1261 expectedMapModifier: func(m map[string]interface{}) { 1262 c := m["parent_field1"].(childStruct) 1263 c.ChildField28 = nil 1264 }, 1265 }, 1266 { 1267 name: "ModeAllowMultipleErrors_invalid_string_slice_value", 1268 mode: ModeAllowMultipleErrors, 1269 expectedErr: true, 1270 expectedResult: true, 1271 structModifier: func(p *parentStruct) { 1272 p.ParentField1.ChildField30 = nil 1273 }, 1274 inputMapModifier: func(m map[string]interface{}) { 1275 m["parent_field1"].(map[string]interface{})["child_field30"] = map[string]interface{}{"foo": "boo"} 1276 }, 1277 expectedMapModifier: func(m map[string]interface{}) { 1278 c := m["parent_field1"].(childStruct) 1279 c.ChildField30 = nil 1280 }, 1281 }, 1282 { 1283 name: "ModeAllowMultipleErrors_invalid_string_array_value", 1284 mode: ModeAllowMultipleErrors, 1285 expectedErr: true, 1286 expectedResult: true, 1287 structModifier: func(p *parentStruct) { 1288 p.ParentField1.ChildField31 = [4]string{} 1289 }, 1290 inputMapModifier: func(m map[string]interface{}) { 1291 m["parent_field1"].(map[string]interface{})["child_field31"] = map[string]interface{}{"foo": "boo"} 1292 }, 1293 expectedMapModifier: func(m map[string]interface{}) { 1294 c := m["parent_field1"].(childStruct) 1295 c.ChildField31 = [4]string{} 1296 }, 1297 }, 1298 { 1299 name: "ModeAllowMultipleErrors_invalid_slice_element", 1300 mode: ModeAllowMultipleErrors, 1301 expectedErr: true, 1302 expectedResult: true, 1303 structModifier: func(p *parentStruct) { 1304 p.ParentField3 = nil 1305 }, 1306 inputMapModifier: func(m map[string]interface{}) { 1307 m["parent_field3"] = []interface{}{nil, "foo", nil, nil} 1308 }, 1309 expectedMapModifier: func(m map[string]interface{}) { 1310 m["parent_field3"] = nil 1311 }, 1312 }, 1313 { 1314 name: "ModeAllowMultipleErrors_invalid_array_element", 1315 mode: ModeAllowMultipleErrors, 1316 expectedErr: true, 1317 expectedResult: true, 1318 structModifier: func(p *parentStruct) { 1319 p.ParentField4 = [4]childStruct{} 1320 }, 1321 inputMapModifier: func(m map[string]interface{}) { 1322 m["parent_field4"] = []interface{}{nil, "foo", nil, nil} 1323 }, 1324 expectedMapModifier: func(m map[string]interface{}) { 1325 m["parent_field4"] = nil 1326 }, 1327 }, 1328 { 1329 name: "ModeAllowMultipleErrors_invalid_map_entry", 1330 mode: ModeAllowMultipleErrors, 1331 expectedErr: true, 1332 expectedResult: true, 1333 structModifier: func(p *parentStruct) { 1334 p.ParentField7 = nil 1335 }, 1336 inputMapModifier: func(m map[string]interface{}) { 1337 m["parent_field7"] = map[string]interface{}{"foo": "a", "goo": 12, "boo": "c"} 1338 }, 1339 expectedMapModifier: func(m map[string]interface{}) { 1340 m["parent_field7"] = nil 1341 }, 1342 }, 1343 { 1344 name: "ModeFailOverToOriginalValue_happy_flow", 1345 mode: ModeFailOverToOriginalValue, 1346 expectedErr: false, 1347 expectedResult: true, 1348 structModifier: nil, 1349 inputMapModifier: nil, 1350 expectedMapModifier: nil, 1351 }, 1352 { 1353 name: "ModeFailOverToOriginalValue_zero_struct_value", 1354 mode: ModeFailOverToOriginalValue, 1355 expectedErr: false, 1356 expectedResult: true, 1357 structModifier: func(p *parentStruct) { 1358 p.ParentField1 = childStruct{} 1359 }, 1360 inputMapModifier: nil, 1361 expectedMapModifier: nil, 1362 }, 1363 { 1364 name: "ModeFailOverToOriginalValue_null_on_struct", 1365 mode: ModeFailOverToOriginalValue, 1366 expectedErr: false, 1367 expectedResult: true, 1368 structModifier: func(p *parentStruct) { 1369 p.ParentField1 = childStruct{} 1370 }, 1371 inputMapModifier: func(m map[string]interface{}) { 1372 m["parent_field1"] = nil 1373 }, 1374 expectedMapModifier: func(m map[string]interface{}) { 1375 m["parent_field1"] = nil 1376 }, 1377 }, 1378 { 1379 name: "ModeFailOverToOriginalValue_null_on_string", 1380 mode: ModeFailOverToOriginalValue, 1381 expectedErr: false, 1382 expectedResult: true, 1383 structModifier: func(p *parentStruct) { 1384 p.ParentField1 = childStruct{} 1385 }, 1386 inputMapModifier: func(m map[string]interface{}) { 1387 m["parent_field1"].(map[string]interface{})["child_field1"] = nil 1388 }, 1389 expectedMapModifier: func(m map[string]interface{}) { 1390 c := m["parent_field1"].(childStruct) 1391 c.ChildField1 = "" 1392 }, 1393 }, 1394 { 1395 name: "ModeFailOverToOriginalValue_null_on_slice", 1396 mode: ModeFailOverToOriginalValue, 1397 expectedErr: false, 1398 expectedResult: true, 1399 structModifier: func(p *parentStruct) { 1400 p.ParentField1 = childStruct{} 1401 }, 1402 inputMapModifier: func(m map[string]interface{}) { 1403 m["parent_field1"].(map[string]interface{})["child_field30"] = nil 1404 }, 1405 expectedMapModifier: func(m map[string]interface{}) { 1406 c := m["parent_field1"].(childStruct) 1407 c.ChildField30 = nil 1408 }, 1409 }, 1410 { 1411 name: "ModeFailOverToOriginalValue_null_on_array", 1412 mode: ModeFailOverToOriginalValue, 1413 expectedErr: false, 1414 expectedResult: true, 1415 structModifier: func(p *parentStruct) { 1416 p.ParentField1 = childStruct{} 1417 }, 1418 inputMapModifier: func(m map[string]interface{}) { 1419 m["parent_field1"].(map[string]interface{})["child_field31"] = nil 1420 }, 1421 expectedMapModifier: func(m map[string]interface{}) { 1422 c := m["parent_field1"].(childStruct) 1423 c.ChildField31 = [4]string{} 1424 }, 1425 }, 1426 { 1427 name: "ModeFailOverToOriginalValue_null_on_map", 1428 mode: ModeFailOverToOriginalValue, 1429 expectedErr: false, 1430 expectedResult: true, 1431 structModifier: func(p *parentStruct) { 1432 p.ParentField7 = nil 1433 }, 1434 inputMapModifier: nil, 1435 expectedMapModifier: func(m map[string]interface{}) { 1436 m["parent_field7"] = nil 1437 }, 1438 }, 1439 { 1440 name: "ModeFailOverToOriginalValue_invalid_struct_value", 1441 mode: ModeFailOverToOriginalValue, 1442 expectedErr: true, 1443 expectedResult: true, 1444 structModifier: func(p *parentStruct) { 1445 p.ParentField1 = childStruct{} 1446 }, 1447 inputMapModifier: func(m map[string]interface{}) { 1448 m["parent_field1"] = 12 1449 }, 1450 expectedMapModifier: func(m map[string]interface{}) { 1451 m["parent_field1"] = float64(12) 1452 }, 1453 }, 1454 { 1455 name: "ModeFailOverToOriginalValue_invalid_struct_ptr_value", 1456 mode: ModeFailOverToOriginalValue, 1457 expectedErr: true, 1458 expectedResult: true, 1459 structModifier: func(p *parentStruct) { 1460 p.ParentField2 = nil 1461 }, 1462 inputMapModifier: func(m map[string]interface{}) { 1463 m["parent_field2"] = 12 1464 }, 1465 expectedMapModifier: func(m map[string]interface{}) { 1466 m["parent_field2"] = float64(12) 1467 }, 1468 }, 1469 { 1470 name: "ModeFailOverToOriginalValue_invalid_slice_value", 1471 mode: ModeFailOverToOriginalValue, 1472 expectedErr: true, 1473 expectedResult: true, 1474 structModifier: func(p *parentStruct) { 1475 p.ParentField3 = nil 1476 }, 1477 inputMapModifier: func(m map[string]interface{}) { 1478 m["parent_field3"] = 12 1479 }, 1480 expectedMapModifier: func(m map[string]interface{}) { 1481 m["parent_field3"] = float64(12) 1482 }, 1483 }, 1484 { 1485 name: "ModeFailOverToOriginalValue_invalid_array_value", 1486 mode: ModeFailOverToOriginalValue, 1487 expectedErr: true, 1488 expectedResult: true, 1489 structModifier: func(p *parentStruct) { 1490 p.ParentField4 = [4]childStruct{} 1491 }, 1492 inputMapModifier: func(m map[string]interface{}) { 1493 m["parent_field4"] = 12 1494 }, 1495 expectedMapModifier: func(m map[string]interface{}) { 1496 m["parent_field4"] = float64(12) 1497 }, 1498 }, 1499 { 1500 name: "ModeFailOverToOriginalValue_invalid_ptr_slice_value", 1501 mode: ModeFailOverToOriginalValue, 1502 expectedErr: true, 1503 expectedResult: true, 1504 structModifier: func(p *parentStruct) { 1505 p.ParentField5 = nil 1506 }, 1507 inputMapModifier: func(m map[string]interface{}) { 1508 m["parent_field5"] = 12 1509 }, 1510 expectedMapModifier: func(m map[string]interface{}) { 1511 m["parent_field5"] = float64(12) 1512 }, 1513 }, 1514 { 1515 name: "ModeFailOverToOriginalValue_invalid_ptr_array_value", 1516 mode: ModeFailOverToOriginalValue, 1517 expectedErr: true, 1518 expectedResult: true, 1519 structModifier: func(p *parentStruct) { 1520 p.ParentField6 = [4]*childStruct{} 1521 }, 1522 inputMapModifier: func(m map[string]interface{}) { 1523 m["parent_field6"] = 12 1524 }, 1525 expectedMapModifier: func(m map[string]interface{}) { 1526 m["parent_field6"] = float64(12) 1527 }, 1528 }, 1529 { 1530 name: "ModeFailOverToOriginalValue_invalid_primitive_map_value", 1531 mode: ModeFailOverToOriginalValue, 1532 expectedErr: true, 1533 expectedResult: true, 1534 structModifier: func(p *parentStruct) { 1535 p.ParentField7 = nil 1536 }, 1537 inputMapModifier: func(m map[string]interface{}) { 1538 m["parent_field7"] = 12 1539 }, 1540 expectedMapModifier: func(m map[string]interface{}) { 1541 m["parent_field7"] = float64(12) 1542 }, 1543 }, 1544 { 1545 name: "ModeFailOverToOriginalValue_invalid_struct_map_value", 1546 mode: ModeFailOverToOriginalValue, 1547 expectedErr: true, 1548 expectedResult: true, 1549 structModifier: func(p *parentStruct) { 1550 p.ParentField8 = nil 1551 }, 1552 inputMapModifier: func(m map[string]interface{}) { 1553 m["parent_field8"] = 12 1554 }, 1555 expectedMapModifier: func(m map[string]interface{}) { 1556 m["parent_field8"] = float64(12) 1557 }, 1558 }, 1559 { 1560 name: "ModeFailOverToOriginalValue_invalid_struct_ptr_map_value", 1561 mode: ModeFailOverToOriginalValue, 1562 expectedErr: true, 1563 expectedResult: true, 1564 structModifier: func(p *parentStruct) { 1565 p.ParentField9 = nil 1566 }, 1567 inputMapModifier: func(m map[string]interface{}) { 1568 m["parent_field9"] = 12 1569 }, 1570 expectedMapModifier: func(m map[string]interface{}) { 1571 m["parent_field9"] = float64(12) 1572 }, 1573 }, 1574 { 1575 name: "ModeFailOverToOriginalValue_invalid_string_value", 1576 mode: ModeFailOverToOriginalValue, 1577 expectedErr: true, 1578 expectedResult: true, 1579 structModifier: func(p *parentStruct) { 1580 p.ParentField1 = childStruct{} 1581 }, 1582 inputMapModifier: func(m map[string]interface{}) { 1583 m["parent_field1"].(map[string]interface{})["child_field1"] = map[string]interface{}{"foo": "boo"} 1584 }, 1585 expectedMapModifier: func(m map[string]interface{}) { 1586 m["parent_field1"] = toMap(m["parent_field1"]) 1587 m["parent_field1"].(map[string]interface{})["child_field1"] = map[string]interface{}{"foo": "boo"} 1588 }, 1589 }, 1590 { 1591 name: "ModeFailOverToOriginalValue_invalid_bool_value", 1592 mode: ModeFailOverToOriginalValue, 1593 expectedErr: true, 1594 expectedResult: true, 1595 structModifier: func(p *parentStruct) { 1596 p.ParentField1 = childStruct{} 1597 }, 1598 inputMapModifier: func(m map[string]interface{}) { 1599 m["parent_field1"].(map[string]interface{})["child_field2"] = map[string]interface{}{"foo": "boo"} 1600 }, 1601 expectedMapModifier: func(m map[string]interface{}) { 1602 m["parent_field1"] = toMap(m["parent_field1"]) 1603 m["parent_field1"].(map[string]interface{})["child_field2"] = map[string]interface{}{"foo": "boo"} 1604 }, 1605 }, 1606 { 1607 name: "ModeFailOverToOriginalValue_invalid_int_value", 1608 mode: ModeFailOverToOriginalValue, 1609 expectedErr: true, 1610 expectedResult: true, 1611 structModifier: func(p *parentStruct) { 1612 p.ParentField1 = childStruct{} 1613 }, 1614 inputMapModifier: func(m map[string]interface{}) { 1615 m["parent_field1"].(map[string]interface{})["child_field3"] = map[string]interface{}{"foo": "boo"} 1616 }, 1617 expectedMapModifier: func(m map[string]interface{}) { 1618 m["parent_field1"] = toMap(m["parent_field1"]) 1619 m["parent_field1"].(map[string]interface{})["child_field3"] = map[string]interface{}{"foo": "boo"} 1620 }, 1621 }, 1622 { 1623 name: "ModeFailOverToOriginalValue_invalid_int8_value", 1624 mode: ModeFailOverToOriginalValue, 1625 expectedErr: true, 1626 expectedResult: true, 1627 structModifier: func(p *parentStruct) { 1628 p.ParentField1 = childStruct{} 1629 }, 1630 inputMapModifier: func(m map[string]interface{}) { 1631 m["parent_field1"].(map[string]interface{})["child_field4"] = map[string]interface{}{"foo": "boo"} 1632 }, 1633 expectedMapModifier: func(m map[string]interface{}) { 1634 m["parent_field1"] = toMap(m["parent_field1"]) 1635 m["parent_field1"].(map[string]interface{})["child_field4"] = map[string]interface{}{"foo": "boo"} 1636 }, 1637 }, 1638 { 1639 name: "ModeFailOverToOriginalValue_invalid_int16_value", 1640 mode: ModeFailOverToOriginalValue, 1641 expectedErr: true, 1642 expectedResult: true, 1643 structModifier: func(p *parentStruct) { 1644 p.ParentField1 = childStruct{} 1645 }, 1646 inputMapModifier: func(m map[string]interface{}) { 1647 m["parent_field1"].(map[string]interface{})["child_field5"] = map[string]interface{}{"foo": "boo"} 1648 }, 1649 expectedMapModifier: func(m map[string]interface{}) { 1650 m["parent_field1"] = toMap(m["parent_field1"]) 1651 m["parent_field1"].(map[string]interface{})["child_field5"] = map[string]interface{}{"foo": "boo"} 1652 }, 1653 }, 1654 { 1655 name: "ModeFailOverToOriginalValue_invalid_int32_value", 1656 mode: ModeFailOverToOriginalValue, 1657 expectedErr: true, 1658 expectedResult: true, 1659 structModifier: func(p *parentStruct) { 1660 p.ParentField1 = childStruct{} 1661 }, 1662 inputMapModifier: func(m map[string]interface{}) { 1663 m["parent_field1"].(map[string]interface{})["child_field6"] = map[string]interface{}{"foo": "boo"} 1664 }, 1665 expectedMapModifier: func(m map[string]interface{}) { 1666 m["parent_field1"] = toMap(m["parent_field1"]) 1667 m["parent_field1"].(map[string]interface{})["child_field6"] = map[string]interface{}{"foo": "boo"} 1668 }, 1669 }, 1670 { 1671 name: "ModeFailOverToOriginalValue_invalid_int64_value", 1672 mode: ModeFailOverToOriginalValue, 1673 expectedErr: true, 1674 expectedResult: true, 1675 structModifier: func(p *parentStruct) { 1676 p.ParentField1 = childStruct{} 1677 }, 1678 inputMapModifier: func(m map[string]interface{}) { 1679 m["parent_field1"].(map[string]interface{})["child_field7"] = map[string]interface{}{"foo": "boo"} 1680 }, 1681 expectedMapModifier: func(m map[string]interface{}) { 1682 m["parent_field1"] = toMap(m["parent_field1"]) 1683 m["parent_field1"].(map[string]interface{})["child_field7"] = map[string]interface{}{"foo": "boo"} 1684 }, 1685 }, 1686 { 1687 name: "ModeFailOverToOriginalValue_invalid_uint_value", 1688 mode: ModeFailOverToOriginalValue, 1689 expectedErr: true, 1690 expectedResult: true, 1691 structModifier: func(p *parentStruct) { 1692 p.ParentField1 = childStruct{} 1693 }, 1694 inputMapModifier: func(m map[string]interface{}) { 1695 m["parent_field1"].(map[string]interface{})["child_field8"] = map[string]interface{}{"foo": "boo"} 1696 }, 1697 expectedMapModifier: func(m map[string]interface{}) { 1698 m["parent_field1"] = toMap(m["parent_field1"]) 1699 m["parent_field1"].(map[string]interface{})["child_field8"] = map[string]interface{}{"foo": "boo"} 1700 }, 1701 }, 1702 { 1703 name: "ModeFailOverToOriginalValue_invalid_uint8_value", 1704 mode: ModeFailOverToOriginalValue, 1705 expectedErr: true, 1706 expectedResult: true, 1707 structModifier: func(p *parentStruct) { 1708 p.ParentField1 = childStruct{} 1709 }, 1710 inputMapModifier: func(m map[string]interface{}) { 1711 m["parent_field1"].(map[string]interface{})["child_field9"] = map[string]interface{}{"foo": "boo"} 1712 }, 1713 expectedMapModifier: func(m map[string]interface{}) { 1714 m["parent_field1"] = toMap(m["parent_field1"]) 1715 m["parent_field1"].(map[string]interface{})["child_field9"] = map[string]interface{}{"foo": "boo"} 1716 }, 1717 }, 1718 { 1719 name: "ModeFailOverToOriginalValue_invalid_uint16_value", 1720 mode: ModeFailOverToOriginalValue, 1721 expectedErr: true, 1722 expectedResult: true, 1723 structModifier: func(p *parentStruct) { 1724 p.ParentField1 = childStruct{} 1725 }, 1726 inputMapModifier: func(m map[string]interface{}) { 1727 m["parent_field1"].(map[string]interface{})["child_field10"] = map[string]interface{}{"foo": "boo"} 1728 }, 1729 expectedMapModifier: func(m map[string]interface{}) { 1730 m["parent_field1"] = toMap(m["parent_field1"]) 1731 m["parent_field1"].(map[string]interface{})["child_field10"] = map[string]interface{}{"foo": "boo"} 1732 }, 1733 }, 1734 { 1735 name: "ModeFailOverToOriginalValue_invalid_uint32_value", 1736 mode: ModeFailOverToOriginalValue, 1737 expectedErr: true, 1738 expectedResult: true, 1739 structModifier: func(p *parentStruct) { 1740 p.ParentField1 = childStruct{} 1741 }, 1742 inputMapModifier: func(m map[string]interface{}) { 1743 m["parent_field1"].(map[string]interface{})["child_field11"] = map[string]interface{}{"foo": "boo"} 1744 }, 1745 expectedMapModifier: func(m map[string]interface{}) { 1746 m["parent_field1"] = toMap(m["parent_field1"]) 1747 m["parent_field1"].(map[string]interface{})["child_field11"] = map[string]interface{}{"foo": "boo"} 1748 }, 1749 }, 1750 { 1751 name: "ModeFailOverToOriginalValue_invalid_uint64_value", 1752 mode: ModeFailOverToOriginalValue, 1753 expectedErr: true, 1754 expectedResult: true, 1755 structModifier: func(p *parentStruct) { 1756 p.ParentField1 = childStruct{} 1757 }, 1758 inputMapModifier: func(m map[string]interface{}) { 1759 m["parent_field1"].(map[string]interface{})["child_field12"] = map[string]interface{}{"foo": "boo"} 1760 }, 1761 expectedMapModifier: func(m map[string]interface{}) { 1762 m["parent_field1"] = toMap(m["parent_field1"]) 1763 m["parent_field1"].(map[string]interface{})["child_field12"] = map[string]interface{}{"foo": "boo"} 1764 }, 1765 }, 1766 { 1767 name: "ModeFailOverToOriginalValue_invalid_float32_value", 1768 mode: ModeFailOverToOriginalValue, 1769 expectedErr: true, 1770 expectedResult: true, 1771 structModifier: func(p *parentStruct) { 1772 p.ParentField1 = childStruct{} 1773 }, 1774 inputMapModifier: func(m map[string]interface{}) { 1775 m["parent_field1"].(map[string]interface{})["child_field13"] = map[string]interface{}{"foo": "boo"} 1776 }, 1777 expectedMapModifier: func(m map[string]interface{}) { 1778 m["parent_field1"] = toMap(m["parent_field1"]) 1779 m["parent_field1"].(map[string]interface{})["child_field13"] = map[string]interface{}{"foo": "boo"} 1780 }, 1781 }, 1782 { 1783 name: "ModeFailOverToOriginalValue_invalid_float64_value", 1784 mode: ModeFailOverToOriginalValue, 1785 expectedErr: true, 1786 expectedResult: true, 1787 structModifier: func(p *parentStruct) { 1788 p.ParentField1 = childStruct{} 1789 }, 1790 inputMapModifier: func(m map[string]interface{}) { 1791 m["parent_field1"].(map[string]interface{})["child_field14"] = map[string]interface{}{"foo": "boo"} 1792 }, 1793 expectedMapModifier: func(m map[string]interface{}) { 1794 m["parent_field1"] = toMap(m["parent_field1"]) 1795 m["parent_field1"].(map[string]interface{})["child_field14"] = map[string]interface{}{"foo": "boo"} 1796 }, 1797 }, 1798 { 1799 name: "ModeFailOverToOriginalValue_invalid_string_ptr_value", 1800 mode: ModeFailOverToOriginalValue, 1801 expectedErr: true, 1802 expectedResult: true, 1803 structModifier: func(p *parentStruct) { 1804 p.ParentField1 = childStruct{} 1805 }, 1806 inputMapModifier: func(m map[string]interface{}) { 1807 m["parent_field1"].(map[string]interface{})["child_field15"] = map[string]interface{}{"foo": "boo"} 1808 }, 1809 expectedMapModifier: func(m map[string]interface{}) { 1810 m["parent_field1"] = toMap(m["parent_field1"]) 1811 m["parent_field1"].(map[string]interface{})["child_field15"] = map[string]interface{}{"foo": "boo"} 1812 }, 1813 }, 1814 { 1815 name: "ModeFailOverToOriginalValue_invalid_bool_ptr_value", 1816 mode: ModeFailOverToOriginalValue, 1817 expectedErr: true, 1818 expectedResult: true, 1819 structModifier: func(p *parentStruct) { 1820 p.ParentField1 = childStruct{} 1821 }, 1822 inputMapModifier: func(m map[string]interface{}) { 1823 m["parent_field1"].(map[string]interface{})["child_field16"] = map[string]interface{}{"foo": "boo"} 1824 }, 1825 expectedMapModifier: func(m map[string]interface{}) { 1826 m["parent_field1"] = toMap(m["parent_field1"]) 1827 m["parent_field1"].(map[string]interface{})["child_field16"] = map[string]interface{}{"foo": "boo"} 1828 }, 1829 }, 1830 { 1831 name: "ModeFailOverToOriginalValue_invalid_int_ptr_value", 1832 mode: ModeFailOverToOriginalValue, 1833 expectedErr: true, 1834 expectedResult: true, 1835 structModifier: func(p *parentStruct) { 1836 p.ParentField1 = childStruct{} 1837 }, 1838 inputMapModifier: func(m map[string]interface{}) { 1839 m["parent_field1"].(map[string]interface{})["child_field17"] = map[string]interface{}{"foo": "boo"} 1840 }, 1841 expectedMapModifier: func(m map[string]interface{}) { 1842 m["parent_field1"] = toMap(m["parent_field1"]) 1843 m["parent_field1"].(map[string]interface{})["child_field17"] = map[string]interface{}{"foo": "boo"} 1844 }, 1845 }, 1846 { 1847 name: "ModeFailOverToOriginalValue_invalid_int8_ptr_value", 1848 mode: ModeFailOverToOriginalValue, 1849 expectedErr: true, 1850 expectedResult: true, 1851 structModifier: func(p *parentStruct) { 1852 p.ParentField1 = childStruct{} 1853 }, 1854 inputMapModifier: func(m map[string]interface{}) { 1855 m["parent_field1"].(map[string]interface{})["child_field18"] = map[string]interface{}{"foo": "boo"} 1856 }, 1857 expectedMapModifier: func(m map[string]interface{}) { 1858 m["parent_field1"] = toMap(m["parent_field1"]) 1859 m["parent_field1"].(map[string]interface{})["child_field18"] = map[string]interface{}{"foo": "boo"} 1860 }, 1861 }, 1862 { 1863 name: "ModeFailOverToOriginalValue_invalid_int16_ptr_value", 1864 mode: ModeFailOverToOriginalValue, 1865 expectedErr: true, 1866 expectedResult: true, 1867 structModifier: func(p *parentStruct) { 1868 p.ParentField1 = childStruct{} 1869 }, 1870 inputMapModifier: func(m map[string]interface{}) { 1871 m["parent_field1"].(map[string]interface{})["child_field19"] = map[string]interface{}{"foo": "boo"} 1872 }, 1873 expectedMapModifier: func(m map[string]interface{}) { 1874 m["parent_field1"] = toMap(m["parent_field1"]) 1875 m["parent_field1"].(map[string]interface{})["child_field19"] = map[string]interface{}{"foo": "boo"} 1876 }, 1877 }, 1878 { 1879 name: "ModeFailOverToOriginalValue_invalid_int32_ptr_value", 1880 mode: ModeFailOverToOriginalValue, 1881 expectedErr: true, 1882 expectedResult: true, 1883 structModifier: func(p *parentStruct) { 1884 p.ParentField1 = childStruct{} 1885 }, 1886 inputMapModifier: func(m map[string]interface{}) { 1887 m["parent_field1"].(map[string]interface{})["child_field20"] = map[string]interface{}{"foo": "boo"} 1888 }, 1889 expectedMapModifier: func(m map[string]interface{}) { 1890 m["parent_field1"] = toMap(m["parent_field1"]) 1891 m["parent_field1"].(map[string]interface{})["child_field20"] = map[string]interface{}{"foo": "boo"} 1892 }, 1893 }, 1894 { 1895 name: "ModeFailOverToOriginalValue_invalid_int64_ptr_value", 1896 mode: ModeFailOverToOriginalValue, 1897 expectedErr: true, 1898 expectedResult: true, 1899 structModifier: func(p *parentStruct) { 1900 p.ParentField1 = childStruct{} 1901 }, 1902 inputMapModifier: func(m map[string]interface{}) { 1903 m["parent_field1"].(map[string]interface{})["child_field21"] = map[string]interface{}{"foo": "boo"} 1904 }, 1905 expectedMapModifier: func(m map[string]interface{}) { 1906 m["parent_field1"] = toMap(m["parent_field1"]) 1907 m["parent_field1"].(map[string]interface{})["child_field21"] = map[string]interface{}{"foo": "boo"} 1908 }, 1909 }, 1910 { 1911 name: "ModeFailOverToOriginalValue_invalid_uint_ptr_value", 1912 mode: ModeFailOverToOriginalValue, 1913 expectedErr: true, 1914 expectedResult: true, 1915 structModifier: func(p *parentStruct) { 1916 p.ParentField1 = childStruct{} 1917 }, 1918 inputMapModifier: func(m map[string]interface{}) { 1919 m["parent_field1"].(map[string]interface{})["child_field22"] = map[string]interface{}{"foo": "boo"} 1920 }, 1921 expectedMapModifier: func(m map[string]interface{}) { 1922 m["parent_field1"] = toMap(m["parent_field1"]) 1923 m["parent_field1"].(map[string]interface{})["child_field22"] = map[string]interface{}{"foo": "boo"} 1924 }, 1925 }, 1926 { 1927 name: "ModeFailOverToOriginalValue_invalid_uint8_ptr_value", 1928 mode: ModeFailOverToOriginalValue, 1929 expectedErr: true, 1930 expectedResult: true, 1931 structModifier: func(p *parentStruct) { 1932 p.ParentField1 = childStruct{} 1933 }, 1934 inputMapModifier: func(m map[string]interface{}) { 1935 m["parent_field1"].(map[string]interface{})["child_field23"] = map[string]interface{}{"foo": "boo"} 1936 }, 1937 expectedMapModifier: func(m map[string]interface{}) { 1938 m["parent_field1"] = toMap(m["parent_field1"]) 1939 m["parent_field1"].(map[string]interface{})["child_field23"] = map[string]interface{}{"foo": "boo"} 1940 }, 1941 }, 1942 { 1943 name: "ModeFailOverToOriginalValue_invalid_uint16_ptr_value", 1944 mode: ModeFailOverToOriginalValue, 1945 expectedErr: true, 1946 expectedResult: true, 1947 structModifier: func(p *parentStruct) { 1948 p.ParentField1 = childStruct{} 1949 }, 1950 inputMapModifier: func(m map[string]interface{}) { 1951 m["parent_field1"].(map[string]interface{})["child_field24"] = map[string]interface{}{"foo": "boo"} 1952 }, 1953 expectedMapModifier: func(m map[string]interface{}) { 1954 m["parent_field1"] = toMap(m["parent_field1"]) 1955 m["parent_field1"].(map[string]interface{})["child_field24"] = map[string]interface{}{"foo": "boo"} 1956 }, 1957 }, 1958 { 1959 name: "ModeFailOverToOriginalValue_invalid_uint32_ptr_value", 1960 mode: ModeFailOverToOriginalValue, 1961 expectedErr: true, 1962 expectedResult: true, 1963 structModifier: func(p *parentStruct) { 1964 p.ParentField1 = childStruct{} 1965 }, 1966 inputMapModifier: func(m map[string]interface{}) { 1967 m["parent_field1"].(map[string]interface{})["child_field25"] = map[string]interface{}{"foo": "boo"} 1968 }, 1969 expectedMapModifier: func(m map[string]interface{}) { 1970 m["parent_field1"] = toMap(m["parent_field1"]) 1971 m["parent_field1"].(map[string]interface{})["child_field25"] = map[string]interface{}{"foo": "boo"} 1972 }, 1973 }, 1974 { 1975 name: "ModeFailOverToOriginalValue_invalid_uint64_ptr_value", 1976 mode: ModeFailOverToOriginalValue, 1977 expectedErr: true, 1978 expectedResult: true, 1979 structModifier: func(p *parentStruct) { 1980 p.ParentField1 = childStruct{} 1981 }, 1982 inputMapModifier: func(m map[string]interface{}) { 1983 m["parent_field1"].(map[string]interface{})["child_field26"] = map[string]interface{}{"foo": "boo"} 1984 }, 1985 expectedMapModifier: func(m map[string]interface{}) { 1986 m["parent_field1"] = toMap(m["parent_field1"]) 1987 m["parent_field1"].(map[string]interface{})["child_field26"] = map[string]interface{}{"foo": "boo"} 1988 }, 1989 }, 1990 { 1991 name: "ModeFailOverToOriginalValue_invalid_float32_ptr_value", 1992 mode: ModeFailOverToOriginalValue, 1993 expectedErr: true, 1994 expectedResult: true, 1995 structModifier: func(p *parentStruct) { 1996 p.ParentField1 = childStruct{} 1997 }, 1998 inputMapModifier: func(m map[string]interface{}) { 1999 m["parent_field1"].(map[string]interface{})["child_field27"] = map[string]interface{}{"foo": "boo"} 2000 }, 2001 expectedMapModifier: func(m map[string]interface{}) { 2002 m["parent_field1"] = toMap(m["parent_field1"]) 2003 m["parent_field1"].(map[string]interface{})["child_field27"] = map[string]interface{}{"foo": "boo"} 2004 }, 2005 }, 2006 { 2007 name: "ModeFailOverToOriginalValue_invalid_float64_ptr_value", 2008 mode: ModeFailOverToOriginalValue, 2009 expectedErr: true, 2010 expectedResult: true, 2011 structModifier: func(p *parentStruct) { 2012 p.ParentField1 = childStruct{} 2013 }, 2014 inputMapModifier: func(m map[string]interface{}) { 2015 m["parent_field1"].(map[string]interface{})["child_field28"] = map[string]interface{}{"foo": "boo"} 2016 }, 2017 expectedMapModifier: func(m map[string]interface{}) { 2018 m["parent_field1"] = toMap(m["parent_field1"]) 2019 m["parent_field1"].(map[string]interface{})["child_field28"] = map[string]interface{}{"foo": "boo"} 2020 }, 2021 }, 2022 { 2023 name: "ModeFailOverToOriginalValue_invalid_string_slice_value", 2024 mode: ModeFailOverToOriginalValue, 2025 expectedErr: true, 2026 expectedResult: true, 2027 structModifier: func(p *parentStruct) { 2028 p.ParentField1 = childStruct{} 2029 }, 2030 inputMapModifier: func(m map[string]interface{}) { 2031 m["parent_field1"].(map[string]interface{})["child_field30"] = map[string]interface{}{"foo": "boo"} 2032 }, 2033 expectedMapModifier: func(m map[string]interface{}) { 2034 m["parent_field1"] = toMap(m["parent_field1"]) 2035 m["parent_field1"].(map[string]interface{})["child_field30"] = map[string]interface{}{"foo": "boo"} 2036 }, 2037 }, 2038 { 2039 name: "ModeFailOverToOriginalValue_invalid_string_array_value", 2040 mode: ModeFailOverToOriginalValue, 2041 expectedErr: true, 2042 expectedResult: true, 2043 structModifier: func(p *parentStruct) { 2044 p.ParentField1 = childStruct{} 2045 }, 2046 inputMapModifier: func(m map[string]interface{}) { 2047 m["parent_field1"].(map[string]interface{})["child_field31"] = map[string]interface{}{"foo": "boo"} 2048 }, 2049 expectedMapModifier: func(m map[string]interface{}) { 2050 m["parent_field1"] = toMap(m["parent_field1"]) 2051 m["parent_field1"].(map[string]interface{})["child_field31"] = map[string]interface{}{"foo": "boo"} 2052 }, 2053 }, 2054 { 2055 name: "ModeFailOverToOriginalValue_invalid_slice_element", 2056 mode: ModeFailOverToOriginalValue, 2057 expectedErr: true, 2058 expectedResult: true, 2059 structModifier: func(p *parentStruct) { 2060 p.ParentField3 = nil 2061 }, 2062 inputMapModifier: func(m map[string]interface{}) { 2063 m["parent_field3"] = []interface{}{nil, "foo", nil, nil} 2064 }, 2065 expectedMapModifier: func(m map[string]interface{}) { 2066 m["parent_field3"] = []interface{}{childStruct{}, "foo", nil, nil} 2067 }, 2068 }, 2069 { 2070 name: "ModeFailOverToOriginalValue_invalid_array_element", 2071 mode: ModeFailOverToOriginalValue, 2072 expectedErr: true, 2073 expectedResult: true, 2074 structModifier: func(p *parentStruct) { 2075 p.ParentField4 = [4]childStruct{} 2076 }, 2077 inputMapModifier: func(m map[string]interface{}) { 2078 m["parent_field4"] = []interface{}{nil, "foo", nil, nil} 2079 }, 2080 expectedMapModifier: func(m map[string]interface{}) { 2081 m["parent_field4"] = []interface{}{childStruct{}, "foo", nil, nil} 2082 }, 2083 }, 2084 { 2085 name: "ModeFailOverToOriginalValue_invalid_map_entry", 2086 mode: ModeFailOverToOriginalValue, 2087 expectedErr: true, 2088 expectedResult: true, 2089 structModifier: func(p *parentStruct) { 2090 p.ParentField7 = nil 2091 }, 2092 inputMapModifier: func(m map[string]interface{}) { 2093 m["parent_field7"] = map[string]interface{}{"foo": "a", "goo": 12, "boo": "c"} 2094 }, 2095 expectedMapModifier: func(m map[string]interface{}) { 2096 m["parent_field7"] = map[string]interface{}{"foo": "a", "goo": float64(12), "boo": "c"} 2097 }, 2098 }, 2099 { 2100 name: "nested_unknown_fields", 2101 mode: ModeFailOnFirstError, 2102 expectedErr: false, 2103 expectedResult: true, 2104 structModifier: func(p *parentStruct) { 2105 p.ParentField1 = childStruct{ 2106 ChildField1: "a", 2107 } 2108 }, 2109 inputMapModifier: func(m map[string]interface{}) { 2110 m["parent_field1"] = map[string]interface{}{"child_field1": "a", "foo": "f", "boo": "b"} 2111 }, 2112 expectedMapModifier: nil, 2113 }, 2114 } 2115 for _, tt := range tests { 2116 t.Run(tt.name, func(t *testing.T) { 2117 expectedStruct := buildParentStruct() 2118 if tt.structModifier != nil { 2119 tt.structModifier(expectedStruct) 2120 } 2121 input := toMap(expectedStruct) 2122 for k, v := range extraData { 2123 input[k] = v 2124 } 2125 if tt.inputMapModifier != nil { 2126 tt.inputMapModifier(input) 2127 } 2128 data, err := json.Marshal(input) 2129 if err != nil { 2130 t.Errorf("could not marshal parent: %v", err) 2131 return 2132 } 2133 actualStruct := &parentStruct{} 2134 actualMap, err := Unmarshal(data, actualStruct, WithMode(tt.mode)) 2135 if (err != nil) != tt.expectedErr { 2136 t.Errorf("Unmarshal() error = %v, expectedErr %v", err, tt.expectedErr) 2137 } 2138 if tt.expectedResult { 2139 expectedStruct.ParentField10.CustomField = "UnmarshalJSON called" 2140 expectedStruct.ParentField11.CustomField = "UnmarshalJSON called" 2141 if diff := deep.Equal(actualStruct, expectedStruct); diff != nil { 2142 t.Errorf("Unmarshal() struct mismatch (actual, expected):\n%s", strings.Join(diff, "\n")) 2143 } 2144 expectedMap := make(map[string]interface{}) 2145 for k, v := range extraData { 2146 expectedMap[k] = v 2147 } 2148 structValue := reflectStructValue(actualStruct) 2149 for name, refInfo := range mapStructFields(actualStruct) { 2150 field := refInfo.field(structValue) 2151 expectedMap[name] = field.Interface() 2152 } 2153 if tt.expectedMapModifier != nil { 2154 tt.expectedMapModifier(expectedMap) 2155 } 2156 if tt.mode == ModeFailOverToOriginalValue { 2157 normalizeMapTypes(actualMap) 2158 } 2159 if diff := deep.Equal(actualMap, expectedMap); diff != nil { 2160 t.Errorf("Unmarshal() map mismatch (actual, expected):\n%s", strings.Join(diff, "\n")) 2161 } 2162 } else { 2163 if reflect.DeepEqual(actualStruct, expectedStruct) { 2164 t.Error("Unmarshal() expected parsing to break before finished") 2165 } 2166 if actualMap != nil { 2167 t.Errorf("Unmarshal() expected actual map to not exist") 2168 } 2169 } 2170 }) 2171 } 2172 } 2173 2174 func TestUnmarshalSpecialInput(t *testing.T) { 2175 tests := []struct { 2176 name string 2177 data []byte 2178 v interface{} 2179 mode Mode 2180 result bool 2181 errValidator func(error) bool 2182 }{ 2183 { 2184 name: "invalid_input", 2185 data: []byte(`12`), 2186 v: &parentStruct{}, 2187 mode: ModeFailOnFirstError, 2188 result: false, 2189 errValidator: func(err error) bool { 2190 return err == ErrInvalidInput 2191 }, 2192 }, 2193 { 2194 name: "invalid_value", 2195 data: []byte(`{"field":""}`), 2196 v: "", 2197 mode: ModeFailOnFirstError, 2198 result: false, 2199 errValidator: func(err error) bool { 2200 return err == ErrInvalidValue 2201 }, 2202 }, 2203 { 2204 name: "null_input", 2205 data: []byte(`null`), 2206 v: &parentStruct{}, 2207 mode: ModeFailOnFirstError, 2208 result: true, 2209 errValidator: func(err error) bool { 2210 return err == nil 2211 }, 2212 }, 2213 { 2214 name: "ModeFailOnFirstError_custom_unmarshal_failing", 2215 data: []byte(`{"field":""}`), 2216 v: &failingCustomUnmarshalerParent{}, 2217 mode: ModeFailOnFirstError, 2218 result: false, 2219 errValidator: func(err error) bool { 2220 e, ok := err.(*jlexer.LexerError) 2221 if !ok { 2222 return false 2223 } 2224 return e.Reason == "failing" 2225 }, 2226 }, 2227 { 2228 name: "ModeAllowMultipleErrors_custom_unmarshal_failing", 2229 data: []byte(`{"field":""}`), 2230 v: &failingCustomUnmarshalerParent{}, 2231 mode: ModeAllowMultipleErrors, 2232 result: true, 2233 errValidator: func(err error) bool { 2234 e, ok := err.(*MultipleLexerError) 2235 if !ok { 2236 return false 2237 } 2238 if len(e.Errors) != 1 { 2239 return false 2240 } 2241 return e.Errors[0].Reason == "failing" 2242 }, 2243 }, 2244 { 2245 name: "ModeFailOverToOriginalValue_custom_unmarshal_failing", 2246 data: []byte(`{"field":""}`), 2247 v: &failingCustomUnmarshalerParent{}, 2248 mode: ModeFailOverToOriginalValue, 2249 result: true, 2250 errValidator: func(err error) bool { 2251 e, ok := err.(*MultipleLexerError) 2252 if !ok { 2253 return false 2254 } 2255 if len(e.Errors) != 1 { 2256 return false 2257 } 2258 return e.Errors[0].Reason == "failing" 2259 }, 2260 }, 2261 } 2262 for _, tt := range tests { 2263 t.Run(tt.name, func(t *testing.T) { 2264 got, err := Unmarshal(tt.data, tt.v, WithMode(tt.mode)) 2265 if !tt.errValidator(err) { 2266 t.Errorf("Unmarshal() unexpected error = %v", err) 2267 return 2268 } 2269 if tt.result { 2270 if got == nil { 2271 t.Error("Unmarshal() expected result exists") 2272 return 2273 } 2274 } else { 2275 if got != nil { 2276 t.Error("Unmarshal() expected result not exists") 2277 return 2278 } 2279 } 2280 }) 2281 } 2282 } 2283 2284 type embeddingParent struct { 2285 embeddingChild 2286 } 2287 2288 type embeddingChild struct { 2289 Field string `json:"field"` 2290 } 2291 2292 func TestEmbedding(t *testing.T) { 2293 t.Run("test_embedded_values", func(t *testing.T) { 2294 p := embeddingParent{} 2295 result, err := Unmarshal([]byte(`{"field":"value"}`), &p) 2296 if err != nil { 2297 t.Errorf("unexpected error %v", err) 2298 } 2299 if p.Field != "value" { 2300 t.Errorf("missing embedded value in struct %+v", p) 2301 } 2302 if len(result) != 1 || result["field"] != "value" { 2303 t.Errorf("missing embedded value in map %+v", result) 2304 } 2305 }) 2306 } 2307 2308 type handleJSONDataParent struct { 2309 Known string `json:"known"` 2310 Nested1 handleJSONDataChild `json:"nested1"` 2311 Nested2 handleJSONDataChild `json:"nested2"` 2312 } 2313 2314 type handleJSONDataChild struct { 2315 Known string `json:"known"` 2316 2317 Data map[string]interface{} `json:"-"` 2318 } 2319 2320 func (c *handleJSONDataChild) HandleJSONData(data map[string]interface{}) error { 2321 if _, exists := data["fail"]; exists { 2322 return errors.New("HandleJSONData failure") 2323 } 2324 c.Data = data 2325 return nil 2326 } 2327 2328 type handleJSONDataDeprecatedParent struct { 2329 Known string `json:"known"` 2330 Nested handleJSONDataDeprecatedChild `json:"nested"` 2331 } 2332 2333 type handleJSONDataDeprecatedChild struct { 2334 Known string `json:"known"` 2335 2336 Data map[string]interface{} `json:"-"` 2337 } 2338 2339 func (c *handleJSONDataDeprecatedChild) HandleJSONData(data map[string]interface{}) { 2340 c.Data = data 2341 } 2342 2343 func TestJSONDataHandler(t *testing.T) { 2344 t.Run("test_JSONDataHandler", func(t *testing.T) { 2345 data := []byte(`{ 2346 "known": "foo", 2347 "unknown":"boo", 2348 "nested1": {"known": "goo","unknown": "doo"}, 2349 "nested2": {"known": "goo","unknown": "doo"} 2350 }`) 2351 p := &handleJSONDataParent{} 2352 result, err := Unmarshal(data, p) 2353 if err != nil { 2354 t.Errorf("unexpected error %v", err) 2355 } 2356 _, ok := result["nested1"].(handleJSONDataChild) 2357 if !ok { 2358 t.Error("invalid map value") 2359 } 2360 if p.Nested1.Data == nil { 2361 t.Error("Nested1 HandleJSONData not called") 2362 } 2363 if len(p.Nested1.Data) != 2 || p.Nested1.Data["known"] != "goo" || p.Nested1.Data["unknown"] != "doo" { 2364 t.Error("Nested1 invalid JSON data") 2365 } 2366 _, ok = result["nested2"].(handleJSONDataChild) 2367 if !ok { 2368 t.Error("invalid map value") 2369 } 2370 if p.Nested2.Data == nil { 2371 t.Error("Nested2 HandleJSONData not called") 2372 } 2373 if len(p.Nested2.Data) != 2 || p.Nested2.Data["known"] != "goo" || p.Nested2.Data["unknown"] != "doo" { 2374 t.Error("Nested2 invalid JSON data") 2375 } 2376 }) 2377 t.Run("test_JSONDataHandler_single_error", func(t *testing.T) { 2378 data := []byte(`{ 2379 "known": "foo", 2380 "unknown":"boo", 2381 "nested1": {"known": "goo","unknown": "doo", "fail": true}, 2382 "nested2": {"known": "goo","unknown": "doo", "fail": true} 2383 }`) 2384 p := &handleJSONDataParent{} 2385 _, err := Unmarshal(data, p) 2386 if err == nil { 2387 t.Errorf("expected JSONDataHandler error %v", err) 2388 } 2389 e, ok := err.(*jlexer.LexerError) 2390 if !ok || e.Reason != "HandleJSONData failure" { 2391 t.Errorf("unexpected JSONDataHandler error type %v", err) 2392 } 2393 }) 2394 t.Run("test_JSONDataHandler_multiple_error", func(t *testing.T) { 2395 data := []byte(`{ 2396 "known": "foo", 2397 "unknown":"boo", 2398 "nested1": {"known": "goo","unknown": "doo", "fail": true}, 2399 "nested2": {"known": "goo","unknown": "doo", "fail": true} 2400 }`) 2401 p := &handleJSONDataParent{} 2402 _, err := Unmarshal(data, p, WithMode(ModeAllowMultipleErrors)) 2403 if err == nil { 2404 t.Errorf("expected JSONDataHandler error %v", err) 2405 } 2406 e, ok := err.(*MultipleLexerError) 2407 if !ok { 2408 t.Errorf("unexpected JSONDataHandler error type %v", err) 2409 } 2410 for _, lexerError := range e.Errors { 2411 if lexerError.Reason != "HandleJSONData failure" { 2412 t.Errorf("unexpected JSONDataHandler error type %v", err) 2413 } 2414 } 2415 }) 2416 t.Run("test_JSONDataHandler_deprecated", func(t *testing.T) { 2417 data := []byte(`{"known": "foo","unknown": "boo","nested": {"known": "goo","unknown": "doo"}}`) 2418 p := &handleJSONDataDeprecatedParent{} 2419 result, err := Unmarshal(data, p) 2420 if err != nil { 2421 t.Errorf("unexpected error %v", err) 2422 } 2423 _, ok := result["nested"].(handleJSONDataDeprecatedChild) 2424 if !ok { 2425 t.Error("invalid map value") 2426 } 2427 if p.Nested.Data == nil { 2428 t.Error("HandleJSONData not called") 2429 } 2430 if len(p.Nested.Data) != 2 || p.Nested.Data["known"] != "goo" || p.Nested.Data["unknown"] != "doo" { 2431 t.Error("invalid JSON data") 2432 } 2433 }) 2434 } 2435 2436 type Person struct { 2437 FirstName string `json:"firstName"` 2438 LastName string `json:"lastName"` 2439 } 2440 2441 func TestExcludeKnownFieldsFromMap(t *testing.T) { 2442 t.Run("test_exclude_known_fields_from_map_with_empty_map", func(t *testing.T) { 2443 p := Person{} 2444 result, err := Unmarshal([]byte(`{"firstName": "string_firstName", "lastName": "string_lastName"}`), &p, WithExcludeKnownFieldsFromMap(true)) 2445 if err != nil { 2446 t.Errorf("unexpected error %v", err) 2447 } 2448 if len(result) != 0 { 2449 t.Errorf("failure in excluding untyped fields") 2450 } 2451 }) 2452 2453 t.Run("test_exclude_known_fields_from_map", func(t *testing.T) { 2454 p := Person{} 2455 result, err := Unmarshal([]byte(`{"firstName": "string_firstName", "lastName": "string_lastName", "unknown":"string_unknown"}`), &p, WithExcludeKnownFieldsFromMap(true)) 2456 if err != nil { 2457 t.Errorf("unexpected error %v", err) 2458 } 2459 if len(result) != 1 { 2460 t.Errorf("failure in excluding untyped fields") 2461 } 2462 2463 _, exists := result["unknown"] 2464 if !exists { 2465 t.Errorf("unknown field is missing in the result") 2466 } 2467 }) 2468 } 2469 2470 func TestNestedSkipPopulate(t *testing.T) { 2471 t.Run("TestNestedSkipPopulate", func(t *testing.T) { 2472 p := &nestedSkipPopulateParent{} 2473 result, err := Unmarshal([]byte(`{"child":{"foo":"value"}}`), p, WithSkipPopulateStruct(true)) 2474 if err != nil { 2475 t.Errorf("unexpected error %v", err) 2476 } 2477 value, exists := result["child"] 2478 if !exists { 2479 t.Error("missing child element in result map") 2480 } 2481 child, ok := value.(nestedSkipPopulateChild) 2482 if !ok { 2483 t.Errorf("invalid child type %T in result map", child) 2484 } 2485 if child.Foo != "value" { 2486 t.Errorf("invalid value '%s' in child", child.Foo) 2487 } 2488 }) 2489 t.Run("TestNestedSkipPopulate_with_ModeFailOverToOriginalValue", func(t *testing.T) { 2490 p := &nestedSkipPopulateParent{} 2491 result, err := Unmarshal( 2492 []byte(`{"child":{"abc":"123","foo":12}}`), 2493 p, 2494 WithMode(ModeFailOverToOriginalValue), 2495 WithSkipPopulateStruct(true), 2496 ) 2497 if err == nil { 2498 t.Error("expected error") 2499 } 2500 value, exists := result["child"] 2501 if !exists { 2502 t.Error("missing child element in result map") 2503 } 2504 child, ok := value.(map[string]interface{}) 2505 if !ok { 2506 t.Errorf("invalid child type %T in result map", child) 2507 } 2508 if child["foo"] != float64(12) { 2509 t.Errorf("invalid value '%v' in child", child["foo"]) 2510 } 2511 }) 2512 t.Run("TestNestedSkipPopulate_all_fields_exist_in_root_struct", func(t *testing.T) { 2513 s := &failOverStruct{} 2514 result, err := Unmarshal( 2515 []byte(`{"a":"a_val","b":12,"c":"c_val"}}`), 2516 s, 2517 WithMode(ModeFailOverToOriginalValue), 2518 WithSkipPopulateStruct(true), 2519 ) 2520 if err == nil { 2521 t.Error("expected error") 2522 } 2523 if result["a"] != "a_val" { 2524 t.Errorf("invalid value '%v' in a", result["a"]) 2525 } 2526 if result["b"] != float64(12) { 2527 t.Errorf("invalid value '%v' in a", result["b"]) 2528 } 2529 if result["c"] != "c_val" { 2530 t.Errorf("invalid value '%v' in a", result["c"]) 2531 } 2532 }) 2533 t.Run("TestNestedSkipPopulate_all_fields_exist_in_nested_struct", func(t *testing.T) { 2534 s := &failOverParent{} 2535 result, err := Unmarshal( 2536 []byte(`{"child":{"a":"a_val","b":12,"c":"c_val"}}}`), 2537 s, 2538 WithMode(ModeFailOverToOriginalValue), 2539 WithSkipPopulateStruct(true), 2540 ) 2541 if err == nil { 2542 t.Error("expected error") 2543 } 2544 val, ok := result["child"] 2545 if !ok { 2546 t.Error("missing child in result value") 2547 } 2548 child, ok := val.(map[string]interface{}) 2549 if !ok { 2550 t.Error("invalid child type in result value") 2551 } 2552 if child["a"] != "a_val" { 2553 t.Errorf("invalid value '%v' in a", child["a"]) 2554 } 2555 if child["b"] != float64(12) { 2556 t.Errorf("invalid value '%v' in a", child["b"]) 2557 } 2558 if child["c"] != "c_val" { 2559 t.Errorf("invalid value '%v' in a", child["c"]) 2560 } 2561 }) 2562 } 2563 2564 type nestedSkipPopulateParent struct { 2565 Child nestedSkipPopulateChild `json:"child"` 2566 } 2567 2568 type nestedSkipPopulateChild struct { 2569 Foo string `json:"foo"` 2570 } 2571 2572 func (c *nestedSkipPopulateChild) HandleJSONData(map[string]interface{}) error { 2573 return nil 2574 } 2575 2576 var extraData = map[string]interface{}{ 2577 "extra1": "foo", 2578 "extra2": float64(12), 2579 "extra3": true, 2580 "extra4": []interface{}{"1", false}, 2581 } 2582 2583 type failOverParent struct { 2584 Child failOverStruct `json:"child"` 2585 } 2586 2587 type failOverStruct struct { 2588 A string `json:"a"` 2589 B string `json:"b"` 2590 C string `json:"c"` 2591 } 2592 2593 func (f *failOverStruct) HandleJSONData(map[string]interface{}) error { 2594 return nil 2595 } 2596 2597 func buildParentStruct() *parentStruct { 2598 return &parentStruct{ 2599 ParentField1: *buildChildStruct(), 2600 ParentField2: buildChildStruct(), 2601 ParentField3: []childStruct{*buildChildStruct()}, 2602 ParentField4: [4]childStruct{*buildChildStruct()}, 2603 ParentField5: []*childStruct{buildChildStruct(), nil}, 2604 ParentField6: [4]*childStruct{buildChildStruct()}, 2605 ParentField7: map[string]string{"f6-key-1": "f6-value-1", "f6-key-2": "f6-value-2"}, 2606 ParentField8: map[string]childStruct{"f7-key-1": *buildChildStruct()}, 2607 ParentField9: map[string]*childStruct{"f8-key-1": buildChildStruct()}, 2608 ParentField10: customUnmarshaler{CustomField: "ignore this"}, 2609 ParentField11: &customUnmarshaler{CustomField: "ignore this too"}, 2610 } 2611 } 2612 2613 func buildChildStruct() *childStruct { 2614 f15 := "field15" 2615 f16 := true 2616 f17 := 17 2617 f18 := int8(18) 2618 f19 := int16(19) 2619 f20 := int32(20) 2620 f21 := int64(21) 2621 f22 := uint(22) 2622 f23 := uint8(23) 2623 f24 := uint16(24) 2624 f25 := uint32(25) 2625 f26 := uint64(26) 2626 f27 := float32(27.7) 2627 f28 := 28.8 2628 return &childStruct{ 2629 ChildField1: "field1", 2630 ChildField2: true, 2631 ChildField3: 3, 2632 ChildField4: 4, 2633 ChildField5: 5, 2634 ChildField6: 6, 2635 ChildField7: 7, 2636 ChildField8: 8, 2637 ChildField9: 9, 2638 ChildField10: 10, 2639 ChildField11: 11, 2640 ChildField12: 12, 2641 ChildField13: 13.3, 2642 ChildField14: 14.4, 2643 ChildField15: &f15, 2644 ChildField16: &f16, 2645 ChildField17: &f17, 2646 ChildField18: &f18, 2647 ChildField19: &f19, 2648 ChildField20: &f20, 2649 ChildField21: &f21, 2650 ChildField22: &f22, 2651 ChildField23: &f23, 2652 ChildField24: &f24, 2653 ChildField25: &f25, 2654 ChildField26: &f26, 2655 ChildField27: &f27, 2656 ChildField28: &f28, 2657 ChildField29: "interface", 2658 ChildField30: []string{"f30-1", "f30-2"}, 2659 ChildField31: [4]string{"f31-1", "f31-2", "f31-3", "f31-4"}, 2660 } 2661 } 2662 2663 func toMap(value interface{}) map[string]interface{} { 2664 data, err := json.Marshal(value) 2665 if err != nil { 2666 panic(fmt.Errorf("could not marshal value to map %v", err)) 2667 } 2668 result := make(map[string]interface{}) 2669 err = json.Unmarshal(data, &result) 2670 if err != nil { 2671 panic(fmt.Errorf("could not unmarshal value to map %v", err)) 2672 } 2673 return result 2674 } 2675 2676 type parentStruct struct { 2677 ParentField1 childStruct `json:"parent_field1"` 2678 ParentField2 *childStruct `json:"parent_field2"` 2679 ParentField3 []childStruct `json:"parent_field3"` 2680 ParentField4 [4]childStruct `json:"parent_field4"` 2681 ParentField5 []*childStruct `json:"parent_field5"` 2682 ParentField6 [4]*childStruct `json:"parent_field6"` 2683 ParentField7 map[string]string `json:"parent_field7"` 2684 ParentField8 map[string]childStruct `json:"parent_field8"` 2685 ParentField9 map[string]*childStruct `json:"parent_field9"` 2686 ParentField10 customUnmarshaler `json:"parent_field10"` 2687 ParentField11 *customUnmarshaler `json:"parent_field11"` 2688 } 2689 2690 type childStruct struct { 2691 ChildField1 string `json:"child_field1,omitempty"` 2692 ChildField2 bool `json:"child_field2"` 2693 ChildField3 int `json:"child_field3"` 2694 ChildField4 int8 `json:"child_field4"` 2695 ChildField5 int16 `json:"child_field5"` 2696 ChildField6 int32 `json:"child_field6"` 2697 ChildField7 int64 `json:"child_field7"` 2698 ChildField8 uint `json:"child_field8"` 2699 ChildField9 uint8 `json:"child_field9"` 2700 ChildField10 uint16 `json:"child_field10"` 2701 ChildField11 uint32 `json:"child_field11"` 2702 ChildField12 uint64 `json:"child_field12"` 2703 ChildField13 float32 `json:"child_field13"` 2704 ChildField14 float64 `json:"child_field14"` 2705 ChildField15 *string `json:"child_field15"` 2706 ChildField16 *bool `json:"child_field16"` 2707 ChildField17 *int `json:"child_field17"` 2708 ChildField18 *int8 `json:"child_field18"` 2709 ChildField19 *int16 `json:"child_field19"` 2710 ChildField20 *int32 `json:"child_field20"` 2711 ChildField21 *int64 `json:"child_field21"` 2712 ChildField22 *uint `json:"child_field22"` 2713 ChildField23 *uint8 `json:"child_field23"` 2714 ChildField24 *uint16 `json:"child_field24"` 2715 ChildField25 *uint32 `json:"child_field25"` 2716 ChildField26 *uint64 `json:"child_field26"` 2717 ChildField27 *float32 `json:"child_field27"` 2718 ChildField28 *float64 `json:"child_field28"` 2719 ChildField29 interface{} `json:"child_field29"` 2720 ChildField30 []string `json:"child_field30"` 2721 ChildField31 [4]string `json:"child_field31"` 2722 } 2723 2724 type customUnmarshaler struct { 2725 CustomField string 2726 } 2727 2728 func (c *customUnmarshaler) UnmarshalJSON([]byte) error { 2729 *c = customUnmarshaler{CustomField: "UnmarshalJSON called"} 2730 return nil 2731 } 2732 2733 func (c *customUnmarshaler) UnmarshalJSONFromMap(interface{}) error { 2734 *c = customUnmarshaler{CustomField: "UnmarshalJSON called"} 2735 return nil 2736 } 2737 2738 type failingCustomUnmarshalerParent struct { 2739 Field *failingCustomUnmarshaler `json:"field"` 2740 } 2741 2742 type failingCustomUnmarshaler struct{} 2743 2744 func (c *failingCustomUnmarshaler) UnmarshalJSON([]byte) error { 2745 return errors.New("failing") 2746 } 2747 2748 func (c *failingCustomUnmarshaler) UnmarshalJSONFromMap(interface{}) error { 2749 return errors.New("failing") 2750 } 2751 2752 func normalizeMapTypes(m map[string]interface{}) { 2753 for k, v := range m { 2754 switch actual := v.(type) { 2755 case uint: 2756 m[k] = float64(actual) 2757 case uint8: 2758 m[k] = float64(actual) 2759 case uint16: 2760 m[k] = float64(actual) 2761 case uint32: 2762 m[k] = float64(actual) 2763 case uint64: 2764 m[k] = float64(actual) 2765 case int: 2766 m[k] = float64(actual) 2767 case int8: 2768 m[k] = float64(actual) 2769 case int16: 2770 m[k] = float64(actual) 2771 case int32: 2772 m[k] = float64(actual) 2773 case int64: 2774 m[k] = float64(actual) 2775 case float32: 2776 m[k] = float64(actual) 2777 case []string: 2778 data := make([]interface{}, len(actual)) 2779 for i, item := range actual { 2780 data[i] = item 2781 } 2782 m[k] = data 2783 case [4]string: 2784 data := make([]interface{}, len(actual)) 2785 for i, item := range actual { 2786 data[i] = item 2787 } 2788 m[k] = data 2789 case map[string]interface{}: 2790 normalizeMapTypes(actual) 2791 } 2792 } 2793 }