github.com/enbility/spine-go@v0.7.0/model/timeseries_additions_test.go (about)

     1  package model
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/enbility/spine-go/util"
     7  	"github.com/stretchr/testify/assert"
     8  )
     9  
    10  func TestTimeSeriesListDataType_Update(t *testing.T) {
    11  	sut := TimeSeriesListDataType{
    12  		TimeSeriesData: []TimeSeriesDataType{
    13  			{
    14  				TimeSeriesId: util.Ptr(TimeSeriesIdType(0)),
    15  				TimeSeriesSlot: []TimeSeriesSlotType{
    16  					{
    17  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(0)),
    18  					},
    19  				},
    20  			},
    21  			{
    22  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
    23  				TimeSeriesSlot: []TimeSeriesSlotType{
    24  					{
    25  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(0)),
    26  					},
    27  				},
    28  			},
    29  		},
    30  	}
    31  
    32  	newData := TimeSeriesListDataType{
    33  		TimeSeriesData: []TimeSeriesDataType{
    34  			{
    35  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
    36  				TimeSeriesSlot: []TimeSeriesSlotType{
    37  					{
    38  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(1)),
    39  					},
    40  				},
    41  			},
    42  		},
    43  	}
    44  
    45  	// Act
    46  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
    47  	assert.True(t, success)
    48  
    49  	data := sut.TimeSeriesData
    50  	// check the non changing items
    51  	assert.Equal(t, 2, len(data))
    52  	item1 := data[0]
    53  	assert.Equal(t, 0, int(*item1.TimeSeriesId))
    54  	assert.Equal(t, 0, int(*item1.TimeSeriesSlot[0].TimeSeriesSlotId))
    55  	// check properties of updated item
    56  	item2 := data[1]
    57  	assert.Equal(t, 1, int(*item2.TimeSeriesId))
    58  	assert.Equal(t, 1, int(*item2.TimeSeriesSlot[0].TimeSeriesSlotId))
    59  }
    60  
    61  func TestTimeSeriesListDataType_Update_02(t *testing.T) {
    62  	sut := TimeSeriesListDataType{
    63  		TimeSeriesData: []TimeSeriesDataType{
    64  			{
    65  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
    66  				TimePeriod: &TimePeriodType{
    67  					StartTime: util.Ptr(AbsoluteOrRelativeTimeType("PT0S")),
    68  					EndTime:   util.Ptr(AbsoluteOrRelativeTimeType("P6D")),
    69  				},
    70  				TimeSeriesSlot: []TimeSeriesSlotType{
    71  					{
    72  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(0)),
    73  						TimePeriod: &TimePeriodType{
    74  							StartTime: util.Ptr(AbsoluteOrRelativeTimeType("PT0S")),
    75  							EndTime:   util.Ptr(AbsoluteOrRelativeTimeType("P6D")),
    76  						},
    77  						MaxValue: NewScaledNumberType(10000),
    78  					},
    79  				},
    80  			},
    81  			{
    82  				TimeSeriesId: util.Ptr(TimeSeriesIdType(2)),
    83  				TimePeriod: &TimePeriodType{
    84  					StartTime: util.Ptr(AbsoluteOrRelativeTimeType("PT0S")),
    85  				},
    86  				TimeSeriesSlot: []TimeSeriesSlotType{
    87  					{
    88  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(0)),
    89  						Duration:         util.Ptr(DurationType("P1DT6H46M33S")),
    90  						MaxValue:         NewScaledNumberType(0),
    91  					},
    92  					{
    93  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(1)),
    94  						Duration:         util.Ptr(DurationType("PT7H37M53S")),
    95  						MaxValue:         NewScaledNumberType(4410),
    96  					},
    97  					{
    98  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(2)),
    99  						Duration:         util.Ptr(DurationType("PT38M")),
   100  						MaxValue:         NewScaledNumberType(0),
   101  					},
   102  					{
   103  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(3)),
   104  						Duration:         util.Ptr(DurationType("PT32M")),
   105  						MaxValue:         NewScaledNumberType(4410),
   106  					},
   107  					{
   108  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(4)),
   109  						Duration:         util.Ptr(DurationType("P1D")),
   110  						MaxValue:         NewScaledNumberType(0),
   111  					},
   112  				},
   113  			},
   114  			{
   115  				TimeSeriesId: util.Ptr(TimeSeriesIdType(3)),
   116  				TimePeriod: &TimePeriodType{
   117  					StartTime: util.Ptr(AbsoluteOrRelativeTimeType("PT0S")),
   118  				},
   119  				TimeSeriesSlot: []TimeSeriesSlotType{
   120  					{
   121  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(1)),
   122  						Duration:         util.Ptr(DurationType("P1DT15H24M57S")),
   123  						Value:            NewScaledNumberType(44229),
   124  						MaxValue:         NewScaledNumberType(49629),
   125  					},
   126  				},
   127  			},
   128  		},
   129  	}
   130  
   131  	newData := TimeSeriesListDataType{
   132  		TimeSeriesData: []TimeSeriesDataType{
   133  			{
   134  				TimeSeriesId: util.Ptr(TimeSeriesIdType(3)),
   135  				TimePeriod: &TimePeriodType{
   136  					StartTime: util.Ptr(AbsoluteOrRelativeTimeType("PT0S")),
   137  				},
   138  				TimeSeriesSlot: []TimeSeriesSlotType{
   139  					{
   140  						TimeSeriesSlotId: util.Ptr(TimeSeriesSlotIdType(1)),
   141  						Duration:         util.Ptr(DurationType("P1DT15H16M50S")),
   142  						Value:            NewScaledNumberType(11539),
   143  						MaxValue:         NewScaledNumberType(49629),
   144  					},
   145  				},
   146  			},
   147  		},
   148  	}
   149  
   150  	// Act
   151  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   152  	assert.True(t, success)
   153  
   154  	data := sut.TimeSeriesData
   155  	// check the non changing items
   156  	assert.Equal(t, 3, len(data))
   157  	item1 := data[0]
   158  	assert.Equal(t, 1, int(*item1.TimeSeriesId))
   159  	assert.Equal(t, 0, int(*item1.TimeSeriesSlot[0].TimeSeriesSlotId))
   160  	// check properties of updated item
   161  	item2 := data[2]
   162  	assert.Equal(t, 3, int(*item2.TimeSeriesId))
   163  	assert.Equal(t, 1, int(*item2.TimeSeriesSlot[0].TimeSeriesSlotId))
   164  	assert.Equal(t, 11539, int(item2.TimeSeriesSlot[0].Value.GetValue()))
   165  }
   166  
   167  func TestTimeSeriesDescriptionListDataType_Update(t *testing.T) {
   168  	sut := TimeSeriesDescriptionListDataType{
   169  		TimeSeriesDescriptionData: []TimeSeriesDescriptionDataType{
   170  			{
   171  				TimeSeriesId: util.Ptr(TimeSeriesIdType(0)),
   172  				Description:  util.Ptr(DescriptionType("old")),
   173  			},
   174  			{
   175  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
   176  				Description:  util.Ptr(DescriptionType("old")),
   177  			},
   178  		},
   179  	}
   180  
   181  	newData := TimeSeriesDescriptionListDataType{
   182  		TimeSeriesDescriptionData: []TimeSeriesDescriptionDataType{
   183  			{
   184  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
   185  				Description:  util.Ptr(DescriptionType("new")),
   186  			},
   187  		},
   188  	}
   189  
   190  	// Act
   191  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   192  	assert.True(t, success)
   193  
   194  	data := sut.TimeSeriesDescriptionData
   195  	// check the non changing items
   196  	assert.Equal(t, 2, len(data))
   197  	item1 := data[0]
   198  	assert.Equal(t, 0, int(*item1.TimeSeriesId))
   199  	assert.Equal(t, "old", string(*item1.Description))
   200  	// check properties of updated item
   201  	item2 := data[1]
   202  	assert.Equal(t, 1, int(*item2.TimeSeriesId))
   203  	assert.Equal(t, "new", string(*item2.Description))
   204  }
   205  
   206  func TestTimeSeriesConstraintsListDataType_Update(t *testing.T) {
   207  	sut := TimeSeriesConstraintsListDataType{
   208  		TimeSeriesConstraintsData: []TimeSeriesConstraintsDataType{
   209  			{
   210  				TimeSeriesId: util.Ptr(TimeSeriesIdType(0)),
   211  				SlotValueMin: NewScaledNumberType(1),
   212  			},
   213  			{
   214  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
   215  				SlotValueMin: NewScaledNumberType(1),
   216  			},
   217  		},
   218  	}
   219  
   220  	newData := TimeSeriesConstraintsListDataType{
   221  		TimeSeriesConstraintsData: []TimeSeriesConstraintsDataType{
   222  			{
   223  				TimeSeriesId: util.Ptr(TimeSeriesIdType(1)),
   224  				SlotValueMin: NewScaledNumberType(10),
   225  			},
   226  		},
   227  	}
   228  
   229  	// Act
   230  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   231  	assert.True(t, success)
   232  
   233  	data := sut.TimeSeriesConstraintsData
   234  	// check the non changing items
   235  	assert.Equal(t, 2, len(data))
   236  	item1 := data[0]
   237  	assert.Equal(t, 0, int(*item1.TimeSeriesId))
   238  	assert.Equal(t, 1.0, item1.SlotValueMin.GetValue())
   239  	// check properties of updated item
   240  	item2 := data[1]
   241  	assert.Equal(t, 1, int(*item2.TimeSeriesId))
   242  	assert.Equal(t, 10.0, item2.SlotValueMin.GetValue())
   243  }