github.com/enbility/spine-go@v0.7.0/model/electricalconnection_additions_test.go (about) 1 package model 2 3 import ( 4 "encoding/json" 5 "testing" 6 7 "github.com/enbility/spine-go/util" 8 "github.com/stretchr/testify/assert" 9 ) 10 11 func TestElectricalConnectionStateListDataType_Update(t *testing.T) { 12 sut := ElectricalConnectionStateListDataType{ 13 ElectricalConnectionStateData: []ElectricalConnectionStateDataType{ 14 { 15 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 16 CurrentEnergyMode: util.Ptr(EnergyModeTypeProduce), 17 }, 18 { 19 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 20 CurrentEnergyMode: util.Ptr(EnergyModeTypeProduce), 21 }, 22 }, 23 } 24 25 newData := ElectricalConnectionStateListDataType{ 26 ElectricalConnectionStateData: []ElectricalConnectionStateDataType{ 27 { 28 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 29 CurrentEnergyMode: util.Ptr(EnergyModeTypeConsume), 30 }, 31 }, 32 } 33 34 // Act 35 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 36 assert.True(t, success) 37 38 data := sut.ElectricalConnectionStateData 39 // check the non changing items 40 assert.Equal(t, 2, len(data)) 41 item1 := data[0] 42 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 43 assert.Equal(t, EnergyModeTypeProduce, *item1.CurrentEnergyMode) 44 // check properties of updated item 45 item2 := data[1] 46 assert.Equal(t, 1, int(*item2.ElectricalConnectionId)) 47 assert.Equal(t, EnergyModeTypeConsume, *item2.CurrentEnergyMode) 48 } 49 50 // verifies that a subset of existing items will be updated with identified new values 51 func TestElectricalConnectionPermittedValueSetListDataType_Update_Modify(t *testing.T) { 52 sut := ElectricalConnectionPermittedValueSetListDataType{ 53 ElectricalConnectionPermittedValueSetData: []ElectricalConnectionPermittedValueSetDataType{ 54 { 55 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 56 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 57 PermittedValueSet: []ScaledNumberSetType{ 58 { 59 Range: []ScaledNumberRangeType{ 60 { 61 Min: NewScaledNumberType(1), 62 }, 63 }, 64 }, 65 }, 66 }, 67 { 68 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 69 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(1)), 70 PermittedValueSet: []ScaledNumberSetType{ 71 { 72 Range: []ScaledNumberRangeType{ 73 { 74 Min: NewScaledNumberType(6), 75 Max: NewScaledNumberType(16), 76 }, 77 }, 78 }, 79 }, 80 }, 81 { 82 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 83 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(2)), 84 PermittedValueSet: []ScaledNumberSetType{ 85 { 86 Range: []ScaledNumberRangeType{ 87 { 88 Min: NewScaledNumberType(6), 89 Max: NewScaledNumberType(16), 90 }, 91 }, 92 }, 93 }, 94 }, 95 { 96 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 97 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(3)), 98 PermittedValueSet: []ScaledNumberSetType{ 99 { 100 Range: []ScaledNumberRangeType{ 101 { 102 Min: NewScaledNumberType(6), 103 Max: NewScaledNumberType(16), 104 }, 105 }, 106 }, 107 }, 108 }, 109 }, 110 } 111 112 newData := ElectricalConnectionPermittedValueSetListDataType{ 113 ElectricalConnectionPermittedValueSetData: []ElectricalConnectionPermittedValueSetDataType{ 114 { 115 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 116 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(1)), 117 PermittedValueSet: []ScaledNumberSetType{ 118 { 119 Range: []ScaledNumberRangeType{ 120 { 121 Min: NewScaledNumberType(2), 122 Max: NewScaledNumberType(16), 123 }, 124 }, 125 }, 126 }, 127 }, 128 { 129 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 130 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(2)), 131 PermittedValueSet: []ScaledNumberSetType{ 132 { 133 Range: []ScaledNumberRangeType{ 134 { 135 Min: NewScaledNumberType(2), 136 Max: NewScaledNumberType(16), 137 }, 138 }, 139 }, 140 }, 141 }, 142 { 143 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 144 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(3)), 145 PermittedValueSet: []ScaledNumberSetType{ 146 { 147 Range: []ScaledNumberRangeType{ 148 { 149 Min: NewScaledNumberType(2), 150 Max: NewScaledNumberType(16), 151 }, 152 }, 153 }, 154 }, 155 }, 156 }, 157 } 158 159 // Act 160 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 161 assert.True(t, success) 162 163 data := sut.ElectricalConnectionPermittedValueSetData 164 // check the non changing items 165 assert.Equal(t, 4, len(data)) 166 item1 := data[0] 167 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 168 assert.Equal(t, 0, int(*item1.ParameterId)) 169 assert.Equal(t, 1, len(item1.PermittedValueSet)) 170 // check properties of updated item 171 item2 := data[1] 172 assert.Equal(t, 0, int(*item2.ElectricalConnectionId)) 173 assert.Equal(t, 1, int(*item2.ParameterId)) 174 assert.Equal(t, 1, len(item2.PermittedValueSet)) 175 valueSet := item2.PermittedValueSet[0] 176 assert.Equal(t, 1, len(valueSet.Range)) 177 rangeSet := valueSet.Range[0] 178 assert.Equal(t, 2.0, rangeSet.Min.GetValue()) 179 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 180 } 181 182 // verifies that a subset of existing items will be updated with identified new values 183 func TestElectricalConnectionPermittedValueSetListDataType_Update_Modify_Selector(t *testing.T) { 184 existingDataJson := `{ 185 "electricalConnectionPermittedValueSetData":[ 186 { 187 "electricalConnectionId":0, 188 "parameterId":0, 189 "permittedValueSet":[ 190 { 191 "range":[ 192 { 193 "min":{"number":1,"scale":0} 194 } 195 ] 196 } 197 ] 198 }, 199 { 200 "electricalConnectionId":0, 201 "parameterId":1, 202 "permittedValueSet":[ 203 { 204 "range":[ 205 { 206 "min":{"number":6,"scale":0}, 207 "max":{"number":16,"scale":0} 208 } 209 ] 210 } 211 ] 212 }, 213 { 214 "electricalConnectionId":0, 215 "parameterId":2, 216 "permittedValueSet":[ 217 { 218 "range":[ 219 { 220 "min":{"number":6,"scale":0}, 221 "max":{"number":16,"scale":0} 222 } 223 ] 224 } 225 ] 226 }, 227 { 228 "electricalConnectionId":0, 229 "parameterId":3, 230 "permittedValueSet":[ 231 { 232 "range":[ 233 { 234 "min":{"number":6,"scale":0}, 235 "max":{"number":16,"scale":0} 236 } 237 ] 238 } 239 ] 240 } 241 ] 242 }` 243 244 var sut ElectricalConnectionPermittedValueSetListDataType 245 err := json.Unmarshal([]byte(existingDataJson), &sut) 246 if assert.Nil(t, err) == false { 247 return 248 } 249 250 newDataJson := `{ 251 "electricalConnectionPermittedValueSetData":[ 252 { 253 "permittedValueSet":[ 254 { 255 "range":[ 256 { 257 "min":{"number":2,"scale":0}, 258 "max":{"number":16,"scale":0} 259 } 260 ] 261 } 262 ] 263 } 264 ] 265 }` 266 267 var newData ElectricalConnectionPermittedValueSetListDataType 268 err = json.Unmarshal([]byte(newDataJson), &newData) 269 if assert.Nil(t, err) == false { 270 return 271 } 272 273 partial := &FilterType{ 274 CmdControl: &CmdControlType{ 275 Partial: &ElementTagType{}, 276 }, 277 ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{ 278 ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0), 279 ParameterId: util.Ptr[ElectricalConnectionParameterIdType](1), 280 }, 281 } 282 283 // Act 284 _, success := sut.UpdateList(false, false, &newData, partial, nil) 285 assert.True(t, success) 286 287 data := sut.ElectricalConnectionPermittedValueSetData 288 // check the non changing items 289 assert.Equal(t, 4, len(data)) 290 item1 := data[0] 291 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 292 assert.Equal(t, 0, int(*item1.ParameterId)) 293 assert.Equal(t, 1, len(item1.PermittedValueSet)) 294 item3 := data[2] 295 assert.Equal(t, 0, int(*item3.ElectricalConnectionId)) 296 assert.Equal(t, 2, int(*item3.ParameterId)) 297 assert.Equal(t, 1, len(item3.PermittedValueSet)) 298 valueSet := item3.PermittedValueSet[0] 299 assert.Equal(t, 1, len(valueSet.Range)) 300 rangeSet := valueSet.Range[0] 301 assert.Equal(t, 6.0, rangeSet.Min.GetValue()) 302 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 303 304 // check properties of updated item 305 item2 := sut.ElectricalConnectionPermittedValueSetData[1] 306 assert.Equal(t, 0, int(*item2.ElectricalConnectionId)) 307 assert.Equal(t, 1, int(*item2.ParameterId)) 308 assert.Equal(t, 1, len(item2.PermittedValueSet)) 309 valueSet = item2.PermittedValueSet[0] 310 assert.Equal(t, 1, len(valueSet.Range)) 311 rangeSet = valueSet.Range[0] 312 assert.Equal(t, 2.0, rangeSet.Min.GetValue()) 313 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 314 } 315 316 // verifies that a subset of existing items will be updated with identified new values 317 func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_Modify(t *testing.T) { 318 existingDataJson := `{ 319 "electricalConnectionPermittedValueSetData":[ 320 { 321 "electricalConnectionId":0, 322 "parameterId":0, 323 "permittedValueSet":[ 324 { 325 "range":[ 326 { 327 "min":{"number":1,"scale":0} 328 } 329 ] 330 } 331 ] 332 }, 333 { 334 "electricalConnectionId":0, 335 "parameterId":1, 336 "permittedValueSet":[ 337 { 338 "range":[ 339 { 340 "min":{"number":6,"scale":0}, 341 "max":{"number":16,"scale":0} 342 } 343 ] 344 } 345 ] 346 }, 347 { 348 "electricalConnectionId":0, 349 "parameterId":2, 350 "permittedValueSet":[ 351 { 352 "range":[ 353 { 354 "min":{"number":6,"scale":0}, 355 "max":{"number":16,"scale":0} 356 } 357 ] 358 } 359 ] 360 }, 361 { 362 "electricalConnectionId":0, 363 "parameterId":3, 364 "permittedValueSet":[ 365 { 366 "range":[ 367 { 368 "min":{"number":6,"scale":0}, 369 "max":{"number":16,"scale":0} 370 } 371 ] 372 } 373 ] 374 } 375 ] 376 }` 377 378 var sut ElectricalConnectionPermittedValueSetListDataType 379 err := json.Unmarshal([]byte(existingDataJson), &sut) 380 if assert.Nil(t, err) == false { 381 return 382 } 383 384 newDataJson := `{ 385 "electricalConnectionPermittedValueSetData":[ 386 { 387 "electricalConnectionId":0, 388 "parameterId":1, 389 "permittedValueSet":[ 390 { 391 "range":[ 392 { 393 "min":{"number":2,"scale":0}, 394 "max":{"number":16,"scale":0} 395 } 396 ] 397 } 398 ] 399 }, 400 { 401 "electricalConnectionId":0, 402 "parameterId":2, 403 "permittedValueSet":[ 404 { 405 "range":[ 406 { 407 "min":{"number":2,"scale":0}, 408 "max":{"number":16,"scale":0} 409 } 410 ] 411 } 412 ] 413 }, 414 { 415 "electricalConnectionId":0, 416 "parameterId":3, 417 "permittedValueSet":[ 418 { 419 "range":[ 420 { 421 "min":{"number":2,"scale":0}, 422 "max":{"number":16,"scale":0} 423 } 424 ] 425 } 426 ] 427 } 428 ] 429 }` 430 431 var newData ElectricalConnectionPermittedValueSetListDataType 432 err = json.Unmarshal([]byte(newDataJson), &newData) 433 if assert.Nil(t, err) == false { 434 return 435 } 436 437 deleteFilter := &FilterType{ 438 CmdControl: &CmdControlType{ 439 Delete: &ElementTagType{}, 440 }, 441 ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{ 442 ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0), 443 ParameterId: util.Ptr[ElectricalConnectionParameterIdType](0), 444 }, 445 } 446 447 // Act 448 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), deleteFilter) 449 assert.True(t, success) 450 451 data := sut.ElectricalConnectionPermittedValueSetData 452 // check the deleted item is gone 453 assert.Equal(t, 3, len(data)) 454 // check properties of updated item 455 item1 := data[0] 456 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 457 assert.Equal(t, 1, int(*item1.ParameterId)) 458 assert.Equal(t, 1, len(item1.PermittedValueSet)) 459 valueSet := item1.PermittedValueSet[0] 460 assert.Equal(t, 1, len(valueSet.Range)) 461 rangeSet := valueSet.Range[0] 462 assert.Equal(t, 2.0, rangeSet.Min.GetValue()) 463 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 464 } 465 466 // verifies that a subset of existing items will be updated with identified new values 467 func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete(t *testing.T) { 468 existingDataJson := `{ 469 "electricalConnectionPermittedValueSetData":[ 470 { 471 "electricalConnectionId":0, 472 "parameterId":0, 473 "permittedValueSet":[ 474 { 475 "range":[ 476 { 477 "min":{"number":1,"scale":0} 478 } 479 ] 480 } 481 ] 482 }, 483 { 484 "electricalConnectionId":0, 485 "parameterId":1, 486 "permittedValueSet":[ 487 { 488 "range":[ 489 { 490 "min":{"number":6,"scale":0}, 491 "max":{"number":16,"scale":0} 492 } 493 ] 494 } 495 ] 496 }, 497 { 498 "electricalConnectionId":0, 499 "parameterId":2, 500 "permittedValueSet":[ 501 { 502 "range":[ 503 { 504 "min":{"number":6,"scale":0}, 505 "max":{"number":16,"scale":0} 506 } 507 ] 508 } 509 ] 510 }, 511 { 512 "electricalConnectionId":0, 513 "parameterId":3, 514 "permittedValueSet":[ 515 { 516 "range":[ 517 { 518 "min":{"number":6,"scale":0}, 519 "max":{"number":16,"scale":0} 520 } 521 ] 522 } 523 ] 524 } 525 ] 526 }` 527 528 var sut ElectricalConnectionPermittedValueSetListDataType 529 err := json.Unmarshal([]byte(existingDataJson), &sut) 530 if assert.Nil(t, err) == false { 531 return 532 } 533 534 deleteFilter := &FilterType{ 535 CmdControl: &CmdControlType{ 536 Delete: &ElementTagType{}, 537 }, 538 ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{ 539 ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0), 540 ParameterId: util.Ptr[ElectricalConnectionParameterIdType](0), 541 }, 542 } 543 544 // Act 545 _, success := sut.UpdateList(false, true, nil, nil, deleteFilter) 546 assert.True(t, success) 547 548 data := sut.ElectricalConnectionPermittedValueSetData 549 // check the deleted item is added again 550 assert.Equal(t, 3, len(data)) 551 // check properties of remaining item 552 item1 := data[0] 553 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 554 assert.Equal(t, 1, int(*item1.ParameterId)) 555 assert.Equal(t, 1, len(item1.PermittedValueSet)) 556 valueSet := item1.PermittedValueSet[0] 557 assert.Equal(t, 1, len(valueSet.Range)) 558 rangeSet := valueSet.Range[0] 559 assert.Equal(t, 6.0, rangeSet.Min.GetValue()) 560 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 561 } 562 563 // verifies that a subset of existing items will be updated with identified new values 564 func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_Element(t *testing.T) { 565 existingDataJson := `{ 566 "electricalConnectionPermittedValueSetData":[ 567 { 568 "electricalConnectionId":0, 569 "parameterId":0, 570 "permittedValueSet":[ 571 { 572 "range":[ 573 { 574 "min":{"number":1,"scale":0} 575 } 576 ] 577 } 578 ] 579 }, 580 { 581 "electricalConnectionId":0, 582 "parameterId":1, 583 "permittedValueSet":[ 584 { 585 "range":[ 586 { 587 "min":{"number":6,"scale":0}, 588 "max":{"number":16,"scale":0} 589 } 590 ] 591 } 592 ] 593 }, 594 { 595 "electricalConnectionId":0, 596 "parameterId":2, 597 "permittedValueSet":[ 598 { 599 "range":[ 600 { 601 "min":{"number":6,"scale":0}, 602 "max":{"number":16,"scale":0} 603 } 604 ] 605 } 606 ] 607 }, 608 { 609 "electricalConnectionId":0, 610 "parameterId":3, 611 "permittedValueSet":[ 612 { 613 "range":[ 614 { 615 "min":{"number":6,"scale":0}, 616 "max":{"number":16,"scale":0} 617 } 618 ] 619 } 620 ] 621 } 622 ] 623 }` 624 625 var sut ElectricalConnectionPermittedValueSetListDataType 626 err := json.Unmarshal([]byte(existingDataJson), &sut) 627 if assert.Nil(t, err) == false { 628 return 629 } 630 631 deleteFilter := &FilterType{ 632 CmdControl: &CmdControlType{ 633 Delete: &ElementTagType{}, 634 }, 635 ElectricalConnectionPermittedValueSetDataElements: &ElectricalConnectionPermittedValueSetDataElementsType{ 636 PermittedValueSet: &ElementTagType{}, 637 }, 638 ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{ 639 ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0), 640 ParameterId: util.Ptr[ElectricalConnectionParameterIdType](0), 641 }, 642 } 643 644 // Act 645 _, success := sut.UpdateList(false, true, nil, nil, deleteFilter) 646 assert.True(t, success) 647 648 data := sut.ElectricalConnectionPermittedValueSetData 649 // check no items are deleted 650 assert.Equal(t, 4, len(data)) 651 // check permitted value is removed from item with ID 0 652 item1 := data[0] 653 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 654 assert.Equal(t, 0, int(*item1.ParameterId)) 655 var nilValue []ScaledNumberSetType 656 assert.Equal(t, nilValue, item1.PermittedValueSet) 657 658 // check properties of remaining item 659 item2 := data[1] 660 assert.Equal(t, 0, int(*item2.ElectricalConnectionId)) 661 assert.Equal(t, 1, int(*item2.ParameterId)) 662 assert.Equal(t, 1, len(item2.PermittedValueSet)) 663 valueSet := item2.PermittedValueSet[0] 664 assert.Equal(t, 1, len(valueSet.Range)) 665 rangeSet := valueSet.Range[0] 666 assert.Equal(t, 6.0, rangeSet.Min.GetValue()) 667 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 668 } 669 670 // verifies that a subset of existing items will be updated with identified new values 671 func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_OnlyElement(t *testing.T) { 672 existingDataJson := `{ 673 "electricalConnectionPermittedValueSetData":[ 674 { 675 "electricalConnectionId":0, 676 "parameterId":0, 677 "permittedValueSet":[ 678 { 679 "range":[ 680 { 681 "min":{"number":1,"scale":0} 682 } 683 ] 684 } 685 ] 686 }, 687 { 688 "electricalConnectionId":0, 689 "parameterId":1, 690 "permittedValueSet":[ 691 { 692 "range":[ 693 { 694 "min":{"number":6,"scale":0}, 695 "max":{"number":16,"scale":0} 696 } 697 ] 698 } 699 ] 700 }, 701 { 702 "electricalConnectionId":0, 703 "parameterId":2, 704 "permittedValueSet":[ 705 { 706 "range":[ 707 { 708 "min":{"number":6,"scale":0}, 709 "max":{"number":16,"scale":0} 710 } 711 ] 712 } 713 ] 714 }, 715 { 716 "electricalConnectionId":0, 717 "parameterId":3, 718 "permittedValueSet":[ 719 { 720 "range":[ 721 { 722 "min":{"number":6,"scale":0}, 723 "max":{"number":16,"scale":0} 724 } 725 ] 726 } 727 ] 728 } 729 ] 730 }` 731 732 var sut ElectricalConnectionPermittedValueSetListDataType 733 err := json.Unmarshal([]byte(existingDataJson), &sut) 734 if assert.Nil(t, err) == false { 735 return 736 } 737 738 deleteFilter := &FilterType{ 739 CmdControl: &CmdControlType{ 740 Delete: &ElementTagType{}, 741 }, 742 ElectricalConnectionPermittedValueSetDataElements: &ElectricalConnectionPermittedValueSetDataElementsType{ 743 PermittedValueSet: &ElementTagType{}, 744 }, 745 } 746 747 // Act 748 _, success := sut.UpdateList(false, true, nil, nil, deleteFilter) 749 assert.True(t, success) 750 751 data := sut.ElectricalConnectionPermittedValueSetData 752 // check no items are deleted 753 assert.Equal(t, 4, len(data)) 754 // check permitted value is removed from item with ID 0 755 item1 := data[0] 756 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 757 assert.Equal(t, 0, int(*item1.ParameterId)) 758 var nilValue []ScaledNumberSetType 759 assert.Equal(t, nilValue, item1.PermittedValueSet) 760 761 // check properties 762 item2 := data[1] 763 assert.Equal(t, 0, int(*item2.ElectricalConnectionId)) 764 assert.Equal(t, 1, int(*item2.ParameterId)) 765 assert.Equal(t, nilValue, item2.PermittedValueSet) 766 767 item3 := data[2] 768 assert.Equal(t, 0, int(*item3.ElectricalConnectionId)) 769 assert.Equal(t, 2, int(*item3.ParameterId)) 770 assert.Equal(t, nilValue, item3.PermittedValueSet) 771 772 item4 := data[3] 773 assert.Equal(t, 0, int(*item4.ElectricalConnectionId)) 774 assert.Equal(t, 3, int(*item4.ParameterId)) 775 assert.Equal(t, nilValue, item4.PermittedValueSet) 776 } 777 778 // verifies that a subset of existing items will be updated with identified new values 779 func TestElectricalConnectionPermittedValueSetListDataType_Update_Delete_Add(t *testing.T) { 780 existingDataJson := `{ 781 "electricalConnectionPermittedValueSetData":[ 782 { 783 "electricalConnectionId":0, 784 "parameterId":0, 785 "permittedValueSet":[ 786 { 787 "range":[ 788 { 789 "min":{"number":1,"scale":0} 790 } 791 ] 792 } 793 ] 794 }, 795 { 796 "electricalConnectionId":0, 797 "parameterId":1, 798 "permittedValueSet":[ 799 { 800 "range":[ 801 { 802 "min":{"number":6,"scale":0}, 803 "max":{"number":16,"scale":0} 804 } 805 ] 806 } 807 ] 808 }, 809 { 810 "electricalConnectionId":0, 811 "parameterId":2, 812 "permittedValueSet":[ 813 { 814 "range":[ 815 { 816 "min":{"number":6,"scale":0}, 817 "max":{"number":16,"scale":0} 818 } 819 ] 820 } 821 ] 822 }, 823 { 824 "electricalConnectionId":0, 825 "parameterId":3, 826 "permittedValueSet":[ 827 { 828 "range":[ 829 { 830 "min":{"number":6,"scale":0}, 831 "max":{"number":16,"scale":0} 832 } 833 ] 834 } 835 ] 836 } 837 ] 838 }` 839 840 var sut ElectricalConnectionPermittedValueSetListDataType 841 err := json.Unmarshal([]byte(existingDataJson), &sut) 842 if assert.Nil(t, err) == false { 843 return 844 } 845 846 newDataJson := `{ 847 "electricalConnectionPermittedValueSetData":[ 848 { 849 "electricalConnectionId":0, 850 "parameterId":0, 851 "permittedValueSet":[ 852 { 853 "range":[ 854 { 855 "min":{"number":1,"scale":0} 856 } 857 ] 858 } 859 ] 860 }, 861 { 862 "electricalConnectionId":0, 863 "parameterId":1, 864 "permittedValueSet":[ 865 { 866 "range":[ 867 { 868 "min":{"number":2,"scale":0}, 869 "max":{"number":16,"scale":0} 870 } 871 ] 872 } 873 ] 874 }, 875 { 876 "electricalConnectionId":0, 877 "parameterId":2, 878 "permittedValueSet":[ 879 { 880 "range":[ 881 { 882 "min":{"number":2,"scale":0}, 883 "max":{"number":16,"scale":0} 884 } 885 ] 886 } 887 ] 888 }, 889 { 890 "electricalConnectionId":0, 891 "parameterId":3, 892 "permittedValueSet":[ 893 { 894 "range":[ 895 { 896 "min":{"number":2,"scale":0}, 897 "max":{"number":16,"scale":0} 898 } 899 ] 900 } 901 ] 902 } 903 ] 904 }` 905 906 var newData ElectricalConnectionPermittedValueSetListDataType 907 err = json.Unmarshal([]byte(newDataJson), &newData) 908 if assert.Nil(t, err) == false { 909 return 910 } 911 912 deleteFilter := &FilterType{ 913 CmdControl: &CmdControlType{ 914 Delete: &ElementTagType{}, 915 }, 916 ElectricalConnectionPermittedValueSetListDataSelectors: &ElectricalConnectionPermittedValueSetListDataSelectorsType{ 917 ElectricalConnectionId: util.Ptr[ElectricalConnectionIdType](0), 918 ParameterId: util.Ptr[ElectricalConnectionParameterIdType](0), 919 }, 920 } 921 922 // Act 923 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), deleteFilter) 924 assert.True(t, success) 925 926 data := sut.ElectricalConnectionPermittedValueSetData 927 // check the deleted item is added again 928 assert.Equal(t, 4, len(data)) 929 item1 := data[0] 930 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 931 assert.Equal(t, 0, int(*item1.ParameterId)) 932 assert.Equal(t, 1, len(item1.PermittedValueSet)) 933 // check properties of updated item 934 item2 := data[1] 935 assert.Equal(t, 0, int(*item2.ElectricalConnectionId)) 936 assert.Equal(t, 1, int(*item2.ParameterId)) 937 assert.Equal(t, 1, len(item2.PermittedValueSet)) 938 valueSet := item2.PermittedValueSet[0] 939 assert.Equal(t, 1, len(valueSet.Range)) 940 rangeSet := valueSet.Range[0] 941 assert.Equal(t, 2.0, rangeSet.Min.GetValue()) 942 assert.Equal(t, 16.0, rangeSet.Max.GetValue()) 943 } 944 945 // verifies that an item in the payload which is not in the existing data will be added 946 func TestElectricalConnectionPermittedValueSetListDataType_Update_NewItem(t *testing.T) { 947 existingDataJson := `{ 948 "electricalConnectionPermittedValueSetData": [ 949 { 950 "electricalConnectionId": 1, 951 "parameterId": 1, 952 "permittedValueSet": [ 953 { 954 "range": [ 955 { 956 "min": { "number": 3, "scale": 0 }, 957 "max": { "number": 6, "scale": 0 } 958 } 959 ] 960 } 961 ] 962 } 963 ] 964 }` 965 966 var sut ElectricalConnectionPermittedValueSetListDataType 967 err := json.Unmarshal([]byte(existingDataJson), &sut) 968 if assert.Nil(t, err) == false { 969 return 970 } 971 972 newDataJson := `{ 973 "electricalConnectionPermittedValueSetData": [ 974 { 975 "electricalConnectionId": 1, 976 "parameterId": 2, 977 "permittedValueSet": [ 978 { 979 "range": [ 980 { 981 "min": { "number": 9, "scale": 0 }, 982 "max": { "number": 19, "scale": 0 } 983 } 984 ] 985 }, 986 { 987 "range": [ 988 { 989 "min": { "number": 30, "scale": 0 }, 990 "max": { "number": 36, "scale": 0 } 991 } 992 ] 993 } 994 ] 995 } 996 ] 997 }` 998 999 var newData ElectricalConnectionPermittedValueSetListDataType 1000 err = json.Unmarshal([]byte(newDataJson), &newData) 1001 if assert.Nil(t, err) == false { 1002 return 1003 } 1004 1005 // Act 1006 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 1007 assert.True(t, success) 1008 1009 data := sut.ElectricalConnectionPermittedValueSetData 1010 // new item should be added 1011 assert.Equal(t, 2, len(data)) 1012 item1 := data[0] 1013 assert.Equal(t, 1, int(*item1.ElectricalConnectionId)) 1014 assert.Equal(t, 1, int(*item1.ParameterId)) 1015 assert.Equal(t, 1, len(item1.PermittedValueSet)) 1016 // check properties of added item 1017 item2 := data[1] 1018 assert.Equal(t, 1, int(*item2.ElectricalConnectionId)) 1019 assert.Equal(t, 2, int(*item2.ParameterId)) 1020 assert.Equal(t, 2, len(item2.PermittedValueSet)) 1021 } 1022 1023 // verifies that an item in the payload which has no identifiers will be copied to all existing data 1024 // (see EEBus_SPINE_TS_ProtocolSpecification.pdf, Table 7: Considered cmdOptions combinations for classifier "notify") 1025 func TestElectricalConnectionPermittedValueSetListDataType_UpdateWithoutIdenifiers(t *testing.T) { 1026 existingDataJson := `{ 1027 "electricalConnectionPermittedValueSetData": [ 1028 { 1029 "electricalConnectionId": 1, 1030 "parameterId": 1, 1031 "permittedValueSet": [ 1032 { 1033 "range": [ 1034 { 1035 "min": { "number": 3, "scale": 0 }, 1036 "max": { "number": 6, "scale": 0 } 1037 } 1038 ] 1039 } 1040 ] 1041 }, 1042 { 1043 "electricalConnectionId": 1, 1044 "parameterId": 2, 1045 "permittedValueSet": [ 1046 { 1047 "range": [ 1048 { 1049 "min": { "number": 6, "scale": 0 }, 1050 "max": { "number": 12, "scale": 0 } 1051 } 1052 ] 1053 } 1054 ] 1055 } ] 1056 }` 1057 1058 var sut ElectricalConnectionPermittedValueSetListDataType 1059 err := json.Unmarshal([]byte(existingDataJson), &sut) 1060 if assert.Nil(t, err) == false { 1061 return 1062 } 1063 1064 // item with no identifiers 1065 newDataJson := `{ 1066 "electricalConnectionPermittedValueSetData": [ 1067 { 1068 "permittedValueSet": [ 1069 { 1070 "range": [ 1071 { 1072 "min": { "number": 30, "scale": 0 }, 1073 "max": { "number": 36, "scale": 0 } 1074 } 1075 ] 1076 } 1077 ] 1078 } 1079 ] 1080 }` 1081 1082 var newData ElectricalConnectionPermittedValueSetListDataType 1083 err = json.Unmarshal([]byte(newDataJson), &newData) 1084 if assert.Nil(t, err) == false { 1085 return 1086 } 1087 1088 // Act 1089 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 1090 assert.True(t, success) 1091 1092 data := sut.ElectricalConnectionPermittedValueSetData 1093 // the new item should not be added 1094 assert.Equal(t, 2, len(data)) 1095 item1 := data[0] 1096 assert.Equal(t, 1, int(*item1.ElectricalConnectionId)) 1097 assert.Equal(t, 1, int(*item1.ParameterId)) 1098 assert.Equal(t, 1, len(item1.PermittedValueSet)) 1099 valueSet := item1.PermittedValueSet[0] 1100 assert.Equal(t, 1, len(valueSet.Range)) 1101 // the values of the item in the payload should be copied to the first item 1102 assert.Equal(t, 30, int(*valueSet.Range[0].Min.Number)) 1103 assert.Equal(t, 0, int(*valueSet.Range[0].Min.Scale)) 1104 assert.Equal(t, 36, int(*valueSet.Range[0].Max.Number)) 1105 assert.Equal(t, 0, int(*valueSet.Range[0].Max.Scale)) 1106 1107 item2 := data[1] 1108 assert.Equal(t, 1, int(*item2.ElectricalConnectionId)) 1109 assert.Equal(t, 2, int(*item2.ParameterId)) 1110 assert.Equal(t, 1, len(item2.PermittedValueSet)) 1111 valueSet = item2.PermittedValueSet[0] 1112 assert.Equal(t, 1, len(valueSet.Range)) 1113 // the values of the item in the payload should be also copied to the second item 1114 assert.Equal(t, 30, int(*valueSet.Range[0].Min.Number)) 1115 assert.Equal(t, 0, int(*valueSet.Range[0].Min.Scale)) 1116 assert.Equal(t, 36, int(*valueSet.Range[0].Max.Number)) 1117 assert.Equal(t, 0, int(*valueSet.Range[0].Max.Scale)) 1118 } 1119 1120 func TestElectricalConnectionDescriptionListDataType_Update(t *testing.T) { 1121 sut := ElectricalConnectionDescriptionListDataType{ 1122 ElectricalConnectionDescriptionData: []ElectricalConnectionDescriptionDataType{ 1123 { 1124 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 1125 PowerSupplyType: util.Ptr(ElectricalConnectionVoltageTypeTypeAc), 1126 }, 1127 { 1128 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 1129 PowerSupplyType: util.Ptr(ElectricalConnectionVoltageTypeTypeAc), 1130 }, 1131 }, 1132 } 1133 1134 newData := ElectricalConnectionDescriptionListDataType{ 1135 ElectricalConnectionDescriptionData: []ElectricalConnectionDescriptionDataType{ 1136 { 1137 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 1138 PowerSupplyType: util.Ptr(ElectricalConnectionVoltageTypeTypeDc), 1139 }, 1140 }, 1141 } 1142 1143 // Act 1144 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 1145 assert.True(t, success) 1146 1147 data := sut.ElectricalConnectionDescriptionData 1148 // check the non changing items 1149 assert.Equal(t, 2, len(data)) 1150 item1 := data[0] 1151 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 1152 assert.Equal(t, ElectricalConnectionVoltageTypeTypeAc, *item1.PowerSupplyType) 1153 // check properties of updated item 1154 item2 := data[1] 1155 assert.Equal(t, 1, int(*item2.ElectricalConnectionId)) 1156 assert.Equal(t, ElectricalConnectionVoltageTypeTypeDc, *item2.PowerSupplyType) 1157 } 1158 1159 func TestElectricalConnectionCharacteristicListDataType_Update(t *testing.T) { 1160 sut := ElectricalConnectionCharacteristicListDataType{ 1161 ElectricalConnectionCharacteristicData: []ElectricalConnectionCharacteristicDataType{ 1162 { 1163 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 1164 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 1165 CharacteristicId: util.Ptr(ElectricalConnectionCharacteristicIdType(0)), 1166 CharacteristicType: util.Ptr(ElectricalConnectionCharacteristicTypeTypeApparentPowerConsumptionNominalMax), 1167 }, 1168 { 1169 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 1170 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 1171 CharacteristicId: util.Ptr(ElectricalConnectionCharacteristicIdType(1)), 1172 CharacteristicType: util.Ptr(ElectricalConnectionCharacteristicTypeTypePowerConsumptionMax), 1173 }, 1174 }, 1175 } 1176 1177 newData := ElectricalConnectionCharacteristicListDataType{ 1178 ElectricalConnectionCharacteristicData: []ElectricalConnectionCharacteristicDataType{ 1179 { 1180 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 1181 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 1182 CharacteristicId: util.Ptr(ElectricalConnectionCharacteristicIdType(1)), 1183 CharacteristicType: util.Ptr(ElectricalConnectionCharacteristicTypeTypeEnergyCapacityNominalMax), 1184 }, 1185 }, 1186 } 1187 1188 // Act 1189 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 1190 assert.True(t, success) 1191 1192 data := sut.ElectricalConnectionCharacteristicData 1193 // check the non changing items 1194 assert.Equal(t, 2, len(data)) 1195 item1 := data[0] 1196 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 1197 assert.Equal(t, ElectricalConnectionCharacteristicTypeTypeApparentPowerConsumptionNominalMax, *item1.CharacteristicType) 1198 // check properties of updated item 1199 item2 := data[1] 1200 assert.Equal(t, 1, int(*item2.ElectricalConnectionId)) 1201 assert.Equal(t, ElectricalConnectionCharacteristicTypeTypeEnergyCapacityNominalMax, *item2.CharacteristicType) 1202 } 1203 1204 func TestElectricalConnectionParameterDescriptionListDataType_Update(t *testing.T) { 1205 sut := ElectricalConnectionParameterDescriptionListDataType{ 1206 ElectricalConnectionParameterDescriptionData: []ElectricalConnectionParameterDescriptionDataType{ 1207 { 1208 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(0)), 1209 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 1210 VoltageType: util.Ptr(ElectricalConnectionVoltageTypeTypeAc), 1211 }, 1212 { 1213 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 1214 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 1215 MeasurementId: util.Ptr(MeasurementIdType(0)), 1216 VoltageType: util.Ptr(ElectricalConnectionVoltageTypeTypeAc), 1217 }, 1218 }, 1219 } 1220 1221 newData := ElectricalConnectionParameterDescriptionListDataType{ 1222 ElectricalConnectionParameterDescriptionData: []ElectricalConnectionParameterDescriptionDataType{ 1223 { 1224 ElectricalConnectionId: util.Ptr(ElectricalConnectionIdType(1)), 1225 ParameterId: util.Ptr(ElectricalConnectionParameterIdType(0)), 1226 VoltageType: util.Ptr(ElectricalConnectionVoltageTypeTypeDc), 1227 }, 1228 }, 1229 } 1230 1231 // Act 1232 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 1233 assert.True(t, success) 1234 1235 data := sut.ElectricalConnectionParameterDescriptionData 1236 // check the non changing items 1237 assert.Equal(t, 2, len(data)) 1238 item1 := data[0] 1239 assert.Equal(t, 0, int(*item1.ElectricalConnectionId)) 1240 assert.Equal(t, ElectricalConnectionVoltageTypeTypeAc, *item1.VoltageType) 1241 // check properties of updated item 1242 item2 := data[1] 1243 assert.Equal(t, 1, int(*item2.ElectricalConnectionId)) 1244 assert.Equal(t, ElectricalConnectionVoltageTypeTypeDc, *item2.VoltageType) 1245 }