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