github.com/enbility/spine-go@v0.7.0/model/powersequences_additions_test.go (about) 1 package model 2 3 import ( 4 "testing" 5 "time" 6 7 "github.com/enbility/spine-go/util" 8 "github.com/stretchr/testify/assert" 9 ) 10 11 func TestPowerTimeSlotScheduleListDataType_Update(t *testing.T) { 12 sut := PowerTimeSlotScheduleListDataType{ 13 PowerTimeSlotScheduleData: []PowerTimeSlotScheduleDataType{ 14 { 15 SequenceId: util.Ptr(PowerSequenceIdType(0)), 16 SlotActivated: util.Ptr(false), 17 }, 18 { 19 SequenceId: util.Ptr(PowerSequenceIdType(1)), 20 SlotActivated: util.Ptr(false), 21 }, 22 }, 23 } 24 25 newData := PowerTimeSlotScheduleListDataType{ 26 PowerTimeSlotScheduleData: []PowerTimeSlotScheduleDataType{ 27 { 28 SequenceId: util.Ptr(PowerSequenceIdType(1)), 29 SlotActivated: util.Ptr(true), 30 }, 31 }, 32 } 33 34 // Act 35 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 36 assert.True(t, success) 37 38 data := sut.PowerTimeSlotScheduleData 39 // check the non changing items 40 assert.Equal(t, 2, len(data)) 41 item1 := data[0] 42 assert.Equal(t, 0, int(*item1.SequenceId)) 43 assert.Equal(t, false, *item1.SlotActivated) 44 // check properties of updated item 45 item2 := data[1] 46 assert.Equal(t, 1, int(*item2.SequenceId)) 47 assert.Equal(t, true, *item2.SlotActivated) 48 } 49 50 func TestPowerTimeSlotValueListDataType_Update(t *testing.T) { 51 sut := PowerTimeSlotValueListDataType{ 52 PowerTimeSlotValueData: []PowerTimeSlotValueDataType{ 53 { 54 SequenceId: util.Ptr(PowerSequenceIdType(0)), 55 Value: NewScaledNumberType(1), 56 }, 57 { 58 SequenceId: util.Ptr(PowerSequenceIdType(1)), 59 Value: NewScaledNumberType(1), 60 }, 61 }, 62 } 63 64 newData := PowerTimeSlotValueListDataType{ 65 PowerTimeSlotValueData: []PowerTimeSlotValueDataType{ 66 { 67 SequenceId: util.Ptr(PowerSequenceIdType(1)), 68 Value: NewScaledNumberType(10), 69 }, 70 }, 71 } 72 73 // Act 74 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 75 assert.True(t, success) 76 77 data := sut.PowerTimeSlotValueData 78 // check the non changing items 79 assert.Equal(t, 2, len(data)) 80 item1 := data[0] 81 assert.Equal(t, 0, int(*item1.SequenceId)) 82 assert.Equal(t, 1.0, item1.Value.GetValue()) 83 // check properties of updated item 84 item2 := data[1] 85 assert.Equal(t, 1, int(*item2.SequenceId)) 86 assert.Equal(t, 10.0, item2.Value.GetValue()) 87 } 88 89 func TestPowerTimeSlotScheduleConstraintsListDataType_Update(t *testing.T) { 90 sut := PowerTimeSlotScheduleConstraintsListDataType{ 91 PowerTimeSlotScheduleConstraintsData: []PowerTimeSlotScheduleConstraintsDataType{ 92 { 93 SequenceId: util.Ptr(PowerSequenceIdType(0)), 94 MinDuration: NewDurationType(1 * time.Second), 95 }, 96 { 97 SequenceId: util.Ptr(PowerSequenceIdType(1)), 98 MinDuration: NewDurationType(1 * time.Second), 99 }, 100 }, 101 } 102 103 newData := PowerTimeSlotScheduleConstraintsListDataType{ 104 PowerTimeSlotScheduleConstraintsData: []PowerTimeSlotScheduleConstraintsDataType{ 105 { 106 SequenceId: util.Ptr(PowerSequenceIdType(1)), 107 MinDuration: NewDurationType(10 * time.Second), 108 }, 109 }, 110 } 111 112 // Act 113 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 114 assert.True(t, success) 115 116 data := sut.PowerTimeSlotScheduleConstraintsData 117 // check the non changing items 118 assert.Equal(t, 2, len(data)) 119 item1 := data[0] 120 assert.Equal(t, 0, int(*item1.SequenceId)) 121 duration, _ := item1.MinDuration.GetTimeDuration() 122 assert.Equal(t, time.Duration(1*time.Second), duration) 123 // check properties of updated item 124 item2 := data[1] 125 assert.Equal(t, 1, int(*item2.SequenceId)) 126 duration, _ = item2.MinDuration.GetTimeDuration() 127 assert.Equal(t, time.Duration(10*time.Second), duration) 128 } 129 130 func TestPowerSequenceAlternativesRelationListDataType_Update(t *testing.T) { 131 sut := PowerSequenceAlternativesRelationListDataType{ 132 PowerSequenceAlternativesRelationData: []PowerSequenceAlternativesRelationDataType{ 133 { 134 AlternativesId: util.Ptr(AlternativesIdType(0)), 135 SequenceId: []PowerSequenceIdType{0}, 136 }, 137 { 138 AlternativesId: util.Ptr(AlternativesIdType(1)), 139 SequenceId: []PowerSequenceIdType{0}, 140 }, 141 }, 142 } 143 144 newData := PowerSequenceAlternativesRelationListDataType{ 145 PowerSequenceAlternativesRelationData: []PowerSequenceAlternativesRelationDataType{ 146 { 147 AlternativesId: util.Ptr(AlternativesIdType(1)), 148 SequenceId: []PowerSequenceIdType{1}, 149 }, 150 }, 151 } 152 153 // Act 154 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 155 assert.True(t, success) 156 157 data := sut.PowerSequenceAlternativesRelationData 158 // check the non changing items 159 assert.Equal(t, 2, len(data)) 160 item1 := data[0] 161 assert.Equal(t, 0, int(*item1.AlternativesId)) 162 assert.Equal(t, 0, int(item1.SequenceId[0])) 163 // check properties of updated item 164 item2 := data[1] 165 assert.Equal(t, 1, int(*item2.AlternativesId)) 166 assert.Equal(t, 1, int(item2.SequenceId[0])) 167 } 168 169 func TestPowerSequenceDescriptionListDataType_Update(t *testing.T) { 170 sut := PowerSequenceDescriptionListDataType{ 171 PowerSequenceDescriptionData: []PowerSequenceDescriptionDataType{ 172 { 173 SequenceId: util.Ptr(PowerSequenceIdType(0)), 174 PositiveEnergyDirection: util.Ptr(EnergyDirectionTypeConsume), 175 }, 176 { 177 SequenceId: util.Ptr(PowerSequenceIdType(1)), 178 PositiveEnergyDirection: util.Ptr(EnergyDirectionTypeConsume), 179 }, 180 }, 181 } 182 183 newData := PowerSequenceDescriptionListDataType{ 184 PowerSequenceDescriptionData: []PowerSequenceDescriptionDataType{ 185 { 186 SequenceId: util.Ptr(PowerSequenceIdType(1)), 187 PositiveEnergyDirection: util.Ptr(EnergyDirectionTypeProduce), 188 }, 189 }, 190 } 191 192 // Act 193 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 194 assert.True(t, success) 195 196 data := sut.PowerSequenceDescriptionData 197 // check the non changing items 198 assert.Equal(t, 2, len(data)) 199 item1 := data[0] 200 assert.Equal(t, 0, int(*item1.SequenceId)) 201 assert.Equal(t, EnergyDirectionTypeConsume, *item1.PositiveEnergyDirection) 202 // check properties of updated item 203 item2 := data[1] 204 assert.Equal(t, 1, int(*item2.SequenceId)) 205 assert.Equal(t, EnergyDirectionTypeProduce, *item2.PositiveEnergyDirection) 206 } 207 208 func TestPowerSequenceStateListDataType_Update(t *testing.T) { 209 sut := PowerSequenceStateListDataType{ 210 PowerSequenceStateData: []PowerSequenceStateDataType{ 211 { 212 SequenceId: util.Ptr(PowerSequenceIdType(0)), 213 State: util.Ptr(PowerSequenceStateTypeRunning), 214 }, 215 { 216 SequenceId: util.Ptr(PowerSequenceIdType(1)), 217 State: util.Ptr(PowerSequenceStateTypeRunning), 218 }, 219 }, 220 } 221 222 newData := PowerSequenceStateListDataType{ 223 PowerSequenceStateData: []PowerSequenceStateDataType{ 224 { 225 SequenceId: util.Ptr(PowerSequenceIdType(1)), 226 State: util.Ptr(PowerSequenceStateTypeCompleted), 227 }, 228 }, 229 } 230 231 // Act 232 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 233 assert.True(t, success) 234 235 data := sut.PowerSequenceStateData 236 // check the non changing items 237 assert.Equal(t, 2, len(data)) 238 item1 := data[0] 239 assert.Equal(t, 0, int(*item1.SequenceId)) 240 assert.Equal(t, PowerSequenceStateTypeRunning, *item1.State) 241 // check properties of updated item 242 item2 := data[1] 243 assert.Equal(t, 1, int(*item2.SequenceId)) 244 assert.Equal(t, PowerSequenceStateTypeCompleted, *item2.State) 245 } 246 247 func TestPowerSequenceScheduleListDataType_Update(t *testing.T) { 248 sut := PowerSequenceScheduleListDataType{ 249 PowerSequenceScheduleData: []PowerSequenceScheduleDataType{ 250 { 251 SequenceId: util.Ptr(PowerSequenceIdType(0)), 252 EndTime: NewAbsoluteOrRelativeTimeType("PT2H"), 253 }, 254 { 255 SequenceId: util.Ptr(PowerSequenceIdType(1)), 256 EndTime: NewAbsoluteOrRelativeTimeType("PT2H"), 257 }, 258 }, 259 } 260 261 newData := PowerSequenceScheduleListDataType{ 262 PowerSequenceScheduleData: []PowerSequenceScheduleDataType{ 263 { 264 SequenceId: util.Ptr(PowerSequenceIdType(1)), 265 EndTime: NewAbsoluteOrRelativeTimeType("PT4H"), 266 }, 267 }, 268 } 269 270 // Act 271 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 272 assert.True(t, success) 273 274 data := sut.PowerSequenceScheduleData 275 // check the non changing items 276 assert.Equal(t, 2, len(data)) 277 item1 := data[0] 278 assert.Equal(t, 0, int(*item1.SequenceId)) 279 assert.Equal(t, "PT2H", string(*item1.EndTime)) 280 // check properties of updated item 281 item2 := data[1] 282 assert.Equal(t, 1, int(*item2.SequenceId)) 283 assert.Equal(t, "PT4H", string(*item2.EndTime)) 284 } 285 286 func TestPowerSequenceScheduleConstraintsListDataType_Update(t *testing.T) { 287 sut := PowerSequenceScheduleConstraintsListDataType{ 288 PowerSequenceScheduleConstraintsData: []PowerSequenceScheduleConstraintsDataType{ 289 { 290 SequenceId: util.Ptr(PowerSequenceIdType(0)), 291 EarliestEndTime: NewAbsoluteOrRelativeTimeType("PT2H"), 292 }, 293 { 294 SequenceId: util.Ptr(PowerSequenceIdType(1)), 295 EarliestEndTime: NewAbsoluteOrRelativeTimeType("PT2H"), 296 }, 297 }, 298 } 299 300 newData := PowerSequenceScheduleConstraintsListDataType{ 301 PowerSequenceScheduleConstraintsData: []PowerSequenceScheduleConstraintsDataType{ 302 { 303 SequenceId: util.Ptr(PowerSequenceIdType(1)), 304 EarliestEndTime: NewAbsoluteOrRelativeTimeType("PT4H"), 305 }, 306 }, 307 } 308 309 // Act 310 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 311 assert.True(t, success) 312 313 data := sut.PowerSequenceScheduleConstraintsData 314 // check the non changing items 315 assert.Equal(t, 2, len(data)) 316 item1 := data[0] 317 assert.Equal(t, 0, int(*item1.SequenceId)) 318 assert.Equal(t, "PT2H", string(*item1.EarliestEndTime)) 319 // check properties of updated item 320 item2 := data[1] 321 assert.Equal(t, 1, int(*item2.SequenceId)) 322 assert.Equal(t, "PT4H", string(*item2.EarliestEndTime)) 323 } 324 325 func TestPowerSequencePriceListDataType_Update(t *testing.T) { 326 sut := PowerSequencePriceListDataType{ 327 PowerSequencePriceData: []PowerSequencePriceDataType{ 328 { 329 SequenceId: util.Ptr(PowerSequenceIdType(0)), 330 Price: NewScaledNumberType(1), 331 }, 332 { 333 SequenceId: util.Ptr(PowerSequenceIdType(1)), 334 Price: NewScaledNumberType(1), 335 }, 336 }, 337 } 338 339 newData := PowerSequencePriceListDataType{ 340 PowerSequencePriceData: []PowerSequencePriceDataType{ 341 { 342 SequenceId: util.Ptr(PowerSequenceIdType(1)), 343 Price: NewScaledNumberType(10), 344 }, 345 }, 346 } 347 348 // Act 349 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 350 assert.True(t, success) 351 352 data := sut.PowerSequencePriceData 353 // check the non changing items 354 assert.Equal(t, 2, len(data)) 355 item1 := data[0] 356 assert.Equal(t, 0, int(*item1.SequenceId)) 357 assert.Equal(t, 1.0, item1.Price.GetValue()) 358 // check properties of updated item 359 item2 := data[1] 360 assert.Equal(t, 1, int(*item2.SequenceId)) 361 assert.Equal(t, 10.0, item2.Price.GetValue()) 362 } 363 364 func TestPowerSequenceSchedulePreferenceListDataType_Update(t *testing.T) { 365 sut := PowerSequenceSchedulePreferenceListDataType{ 366 PowerSequenceSchedulePreferenceData: []PowerSequenceSchedulePreferenceDataType{ 367 { 368 SequenceId: util.Ptr(PowerSequenceIdType(0)), 369 Cheapest: util.Ptr(false), 370 }, 371 { 372 SequenceId: util.Ptr(PowerSequenceIdType(1)), 373 Cheapest: util.Ptr(false), 374 }, 375 }, 376 } 377 378 newData := PowerSequenceSchedulePreferenceListDataType{ 379 PowerSequenceSchedulePreferenceData: []PowerSequenceSchedulePreferenceDataType{ 380 { 381 SequenceId: util.Ptr(PowerSequenceIdType(1)), 382 Cheapest: util.Ptr(true), 383 }, 384 }, 385 } 386 387 // Act 388 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 389 assert.True(t, success) 390 391 data := sut.PowerSequenceSchedulePreferenceData 392 // check the non changing items 393 assert.Equal(t, 2, len(data)) 394 item1 := data[0] 395 assert.Equal(t, 0, int(*item1.SequenceId)) 396 assert.Equal(t, false, *item1.Cheapest) 397 // check properties of updated item 398 item2 := data[1] 399 assert.Equal(t, 1, int(*item2.SequenceId)) 400 assert.Equal(t, true, *item2.Cheapest) 401 }