github.com/enbility/spine-go@v0.7.0/model/operatingconstraints_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 TestOperatingConstraintsInterruptListDataType_Update(t *testing.T) { 12 sut := OperatingConstraintsInterruptListDataType{ 13 OperatingConstraintsInterruptData: []OperatingConstraintsInterruptDataType{ 14 { 15 SequenceId: util.Ptr(PowerSequenceIdType(0)), 16 IsPausable: util.Ptr(false), 17 }, 18 { 19 SequenceId: util.Ptr(PowerSequenceIdType(1)), 20 IsPausable: util.Ptr(false), 21 }, 22 }, 23 } 24 25 newData := OperatingConstraintsInterruptListDataType{ 26 OperatingConstraintsInterruptData: []OperatingConstraintsInterruptDataType{ 27 { 28 SequenceId: util.Ptr(PowerSequenceIdType(1)), 29 IsPausable: 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.OperatingConstraintsInterruptData 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.IsPausable) 44 // check properties of updated item 45 item2 := data[1] 46 assert.Equal(t, 1, int(*item2.SequenceId)) 47 assert.Equal(t, true, *item2.IsPausable) 48 } 49 50 func TestOperatingConstraintsDurationListDataType_Update(t *testing.T) { 51 sut := OperatingConstraintsDurationListDataType{ 52 OperatingConstraintsDurationData: []OperatingConstraintsDurationDataType{ 53 { 54 SequenceId: util.Ptr(PowerSequenceIdType(0)), 55 ActiveDurationMin: NewDurationType(1 * time.Second), 56 }, 57 { 58 SequenceId: util.Ptr(PowerSequenceIdType(1)), 59 ActiveDurationMin: NewDurationType(1 * time.Second), 60 }, 61 }, 62 } 63 64 newData := OperatingConstraintsDurationListDataType{ 65 OperatingConstraintsDurationData: []OperatingConstraintsDurationDataType{ 66 { 67 SequenceId: util.Ptr(PowerSequenceIdType(1)), 68 ActiveDurationMin: NewDurationType(10 * time.Second), 69 }, 70 }, 71 } 72 73 // Act 74 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 75 assert.True(t, success) 76 77 data := sut.OperatingConstraintsDurationData 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 duration, _ := item1.ActiveDurationMin.GetTimeDuration() 83 assert.Equal(t, time.Duration(1*time.Second), duration) 84 // check properties of updated item 85 item2 := data[1] 86 assert.Equal(t, 1, int(*item2.SequenceId)) 87 duration, _ = item2.ActiveDurationMin.GetTimeDuration() 88 assert.Equal(t, time.Duration(10*time.Second), duration) 89 } 90 91 func TestOperatingConstraintsPowerDescriptionListDataType_Update(t *testing.T) { 92 sut := OperatingConstraintsPowerDescriptionListDataType{ 93 OperatingConstraintsPowerDescriptionData: []OperatingConstraintsPowerDescriptionDataType{ 94 { 95 SequenceId: util.Ptr(PowerSequenceIdType(0)), 96 PositiveEnergyDirection: util.Ptr(EnergyDirectionTypeConsume), 97 }, 98 { 99 SequenceId: util.Ptr(PowerSequenceIdType(1)), 100 PositiveEnergyDirection: util.Ptr(EnergyDirectionTypeConsume), 101 }, 102 }, 103 } 104 105 newData := OperatingConstraintsPowerDescriptionListDataType{ 106 OperatingConstraintsPowerDescriptionData: []OperatingConstraintsPowerDescriptionDataType{ 107 { 108 SequenceId: util.Ptr(PowerSequenceIdType(1)), 109 PositiveEnergyDirection: util.Ptr(EnergyDirectionTypeProduce), 110 }, 111 }, 112 } 113 114 // Act 115 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 116 assert.True(t, success) 117 118 data := sut.OperatingConstraintsPowerDescriptionData 119 // check the non changing items 120 assert.Equal(t, 2, len(data)) 121 item1 := data[0] 122 assert.Equal(t, 0, int(*item1.SequenceId)) 123 assert.Equal(t, EnergyDirectionTypeConsume, *item1.PositiveEnergyDirection) 124 // check properties of updated item 125 item2 := data[1] 126 assert.Equal(t, 1, int(*item2.SequenceId)) 127 assert.Equal(t, EnergyDirectionTypeProduce, *item2.PositiveEnergyDirection) 128 } 129 130 func TestOperatingConstraintsPowerRangeListDataType_Update(t *testing.T) { 131 sut := OperatingConstraintsPowerRangeListDataType{ 132 OperatingConstraintsPowerRangeData: []OperatingConstraintsPowerRangeDataType{ 133 { 134 SequenceId: util.Ptr(PowerSequenceIdType(0)), 135 PowerMin: NewScaledNumberType(1), 136 }, 137 { 138 SequenceId: util.Ptr(PowerSequenceIdType(1)), 139 PowerMin: NewScaledNumberType(1), 140 }, 141 }, 142 } 143 144 newData := OperatingConstraintsPowerRangeListDataType{ 145 OperatingConstraintsPowerRangeData: []OperatingConstraintsPowerRangeDataType{ 146 { 147 SequenceId: util.Ptr(PowerSequenceIdType(1)), 148 PowerMin: NewScaledNumberType(10), 149 }, 150 }, 151 } 152 153 // Act 154 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 155 assert.True(t, success) 156 157 data := sut.OperatingConstraintsPowerRangeData 158 // check the non changing items 159 assert.Equal(t, 2, len(data)) 160 item1 := data[0] 161 assert.Equal(t, 0, int(*item1.SequenceId)) 162 assert.Equal(t, 1.0, item1.PowerMin.GetValue()) 163 // check properties of updated item 164 item2 := data[1] 165 assert.Equal(t, 1, int(*item2.SequenceId)) 166 assert.Equal(t, 10.0, item2.PowerMin.GetValue()) 167 } 168 169 func TestOperatingConstraintsPowerLevelListDataType_Update(t *testing.T) { 170 sut := OperatingConstraintsPowerLevelListDataType{ 171 OperatingConstraintsPowerLevelData: []OperatingConstraintsPowerLevelDataType{ 172 { 173 SequenceId: util.Ptr(PowerSequenceIdType(0)), 174 Power: NewScaledNumberType(1), 175 }, 176 { 177 SequenceId: util.Ptr(PowerSequenceIdType(1)), 178 Power: NewScaledNumberType(1), 179 }, 180 }, 181 } 182 183 newData := OperatingConstraintsPowerLevelListDataType{ 184 OperatingConstraintsPowerLevelData: []OperatingConstraintsPowerLevelDataType{ 185 { 186 SequenceId: util.Ptr(PowerSequenceIdType(1)), 187 Power: NewScaledNumberType(10), 188 }, 189 }, 190 } 191 192 // Act 193 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 194 assert.True(t, success) 195 196 data := sut.OperatingConstraintsPowerLevelData 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, 1.0, item1.Power.GetValue()) 202 // check properties of updated item 203 item2 := data[1] 204 assert.Equal(t, 1, int(*item2.SequenceId)) 205 assert.Equal(t, 10.0, item2.Power.GetValue()) 206 } 207 208 func TestOperatingConstraintsResumeImplicationListDataType_Update(t *testing.T) { 209 sut := OperatingConstraintsResumeImplicationListDataType{ 210 OperatingConstraintsResumeImplicationData: []OperatingConstraintsResumeImplicationDataType{ 211 { 212 SequenceId: util.Ptr(PowerSequenceIdType(0)), 213 ResumeEnergyEstimated: NewScaledNumberType(1), 214 }, 215 { 216 SequenceId: util.Ptr(PowerSequenceIdType(1)), 217 ResumeEnergyEstimated: NewScaledNumberType(1), 218 }, 219 }, 220 } 221 222 newData := OperatingConstraintsResumeImplicationListDataType{ 223 OperatingConstraintsResumeImplicationData: []OperatingConstraintsResumeImplicationDataType{ 224 { 225 SequenceId: util.Ptr(PowerSequenceIdType(1)), 226 ResumeEnergyEstimated: NewScaledNumberType(10), 227 }, 228 }, 229 } 230 231 // Act 232 _, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil) 233 assert.True(t, success) 234 235 data := sut.OperatingConstraintsResumeImplicationData 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, 1.0, item1.ResumeEnergyEstimated.GetValue()) 241 // check properties of updated item 242 item2 := data[1] 243 assert.Equal(t, 1, int(*item2.SequenceId)) 244 assert.Equal(t, 10.0, item2.ResumeEnergyEstimated.GetValue()) 245 }