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  }