github.com/enbility/spine-go@v0.7.0/model/measurement_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 TestMeasurementListDataType_Update_Add(t *testing.T) {
    11  	sut := MeasurementListDataType{
    12  		MeasurementData: []MeasurementDataType{
    13  			{
    14  				MeasurementId: util.Ptr(MeasurementIdType(0)),
    15  				ValueType:     util.Ptr(MeasurementValueTypeTypeAverageValue),
    16  				Value:         NewScaledNumberType(1),
    17  			},
    18  			{
    19  				MeasurementId: util.Ptr(MeasurementIdType(1)),
    20  				ValueType:     util.Ptr(MeasurementValueTypeTypeAverageValue),
    21  				Value:         NewScaledNumberType(1),
    22  			},
    23  		},
    24  	}
    25  
    26  	newData := MeasurementListDataType{
    27  		MeasurementData: []MeasurementDataType{
    28  			{
    29  				MeasurementId: util.Ptr(MeasurementIdType(1)),
    30  				ValueType:     util.Ptr(MeasurementValueTypeTypeValue),
    31  				Value:         NewScaledNumberType(10),
    32  			},
    33  		},
    34  	}
    35  
    36  	// Act
    37  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
    38  	assert.True(t, success)
    39  
    40  	data := sut.MeasurementData
    41  	// check the non changing items
    42  	assert.Equal(t, 3, len(data))
    43  	item1 := data[0]
    44  	assert.Equal(t, 0, int(*item1.MeasurementId))
    45  	assert.Equal(t, MeasurementValueTypeTypeAverageValue, *item1.ValueType)
    46  	assert.Equal(t, 1.0, item1.Value.GetValue())
    47  	item2 := data[1]
    48  	assert.Equal(t, 1, int(*item2.MeasurementId))
    49  	assert.Equal(t, MeasurementValueTypeTypeAverageValue, *item2.ValueType)
    50  	assert.Equal(t, 1.0, item2.Value.GetValue())
    51  }
    52  
    53  func TestMeasurementListDataType_Update_Replace(t *testing.T) {
    54  	sut := MeasurementListDataType{
    55  		MeasurementData: []MeasurementDataType{
    56  			{
    57  				MeasurementId: util.Ptr(MeasurementIdType(0)),
    58  				ValueType:     util.Ptr(MeasurementValueTypeTypeAverageValue),
    59  				Value:         NewScaledNumberType(1),
    60  			},
    61  			{
    62  				MeasurementId: util.Ptr(MeasurementIdType(1)),
    63  				ValueType:     util.Ptr(MeasurementValueTypeTypeValue),
    64  				Value:         NewScaledNumberType(1),
    65  			},
    66  		},
    67  	}
    68  
    69  	newData := MeasurementListDataType{
    70  		MeasurementData: []MeasurementDataType{
    71  			{
    72  				MeasurementId: util.Ptr(MeasurementIdType(1)),
    73  				ValueType:     util.Ptr(MeasurementValueTypeTypeValue),
    74  				Value:         NewScaledNumberType(10),
    75  			},
    76  		},
    77  	}
    78  
    79  	// Act
    80  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
    81  	assert.True(t, success)
    82  
    83  	data := sut.MeasurementData
    84  	// check the non changing items
    85  	assert.Equal(t, 2, len(data))
    86  	item1 := data[0]
    87  	assert.Equal(t, 0, int(*item1.MeasurementId))
    88  	assert.Equal(t, MeasurementValueTypeTypeAverageValue, *item1.ValueType)
    89  	assert.Equal(t, 1.0, item1.Value.GetValue())
    90  	// check properties of updated item
    91  	item2 := data[1]
    92  	assert.Equal(t, 1, int(*item2.MeasurementId))
    93  	assert.Equal(t, MeasurementValueTypeTypeValue, *item2.ValueType)
    94  	assert.Equal(t, 10.0, item2.Value.GetValue())
    95  }
    96  
    97  func TestMeasurementSeriesListDataType_Update(t *testing.T) {
    98  	sut := MeasurementSeriesListDataType{
    99  		MeasurementSeriesData: []MeasurementSeriesDataType{
   100  			{
   101  				MeasurementId: util.Ptr(MeasurementIdType(0)),
   102  				ValueType:     util.Ptr(MeasurementValueTypeTypeMinValue),
   103  				Value:         NewScaledNumberType(1),
   104  			},
   105  			{
   106  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   107  				ValueType:     util.Ptr(MeasurementValueTypeTypeMaxValue),
   108  				Value:         NewScaledNumberType(10),
   109  			},
   110  		},
   111  	}
   112  
   113  	newData := MeasurementSeriesListDataType{
   114  		MeasurementSeriesData: []MeasurementSeriesDataType{
   115  			{
   116  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   117  				ValueType:     util.Ptr(MeasurementValueTypeTypeMaxValue),
   118  				Value:         NewScaledNumberType(100),
   119  			},
   120  		},
   121  	}
   122  
   123  	// Act
   124  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   125  	assert.True(t, success)
   126  
   127  	data := sut.MeasurementSeriesData
   128  	// check the non changing items
   129  	assert.Equal(t, 2, len(data))
   130  	item1 := data[0]
   131  	assert.Equal(t, 0, int(*item1.MeasurementId))
   132  	assert.Equal(t, 1.0, item1.Value.GetValue())
   133  	// check properties of updated item
   134  	item2 := data[1]
   135  	assert.Equal(t, 1, int(*item2.MeasurementId))
   136  	assert.Equal(t, 100.0, item2.Value.GetValue())
   137  }
   138  
   139  func TestMeasurementConstraintsListDataType_Update(t *testing.T) {
   140  	sut := MeasurementConstraintsListDataType{
   141  		MeasurementConstraintsData: []MeasurementConstraintsDataType{
   142  			{
   143  				MeasurementId: util.Ptr(MeasurementIdType(0)),
   144  				ValueStepSize: NewScaledNumberType(1),
   145  			},
   146  			{
   147  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   148  				ValueStepSize: NewScaledNumberType(1),
   149  			},
   150  		},
   151  	}
   152  
   153  	newData := MeasurementConstraintsListDataType{
   154  		MeasurementConstraintsData: []MeasurementConstraintsDataType{
   155  			{
   156  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   157  				ValueStepSize: NewScaledNumberType(10),
   158  			},
   159  		},
   160  	}
   161  
   162  	// Act
   163  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   164  	assert.True(t, success)
   165  
   166  	data := sut.MeasurementConstraintsData
   167  	// check the non changing items
   168  	assert.Equal(t, 2, len(data))
   169  	item1 := data[0]
   170  	assert.Equal(t, 0, int(*item1.MeasurementId))
   171  	assert.Equal(t, 1.0, item1.ValueStepSize.GetValue())
   172  	// check properties of updated item
   173  	item2 := data[1]
   174  	assert.Equal(t, 1, int(*item2.MeasurementId))
   175  	assert.Equal(t, 10.0, item2.ValueStepSize.GetValue())
   176  }
   177  
   178  func TestMeasurementDescriptionListDataType_Update(t *testing.T) {
   179  	sut := MeasurementDescriptionListDataType{
   180  		MeasurementDescriptionData: []MeasurementDescriptionDataType{
   181  			{
   182  				MeasurementId: util.Ptr(MeasurementIdType(0)),
   183  				ScopeType:     util.Ptr(ScopeTypeTypeACCurrent),
   184  			},
   185  			{
   186  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   187  				ScopeType:     util.Ptr(ScopeTypeTypeACCurrent),
   188  			},
   189  		},
   190  	}
   191  
   192  	newData := MeasurementDescriptionListDataType{
   193  		MeasurementDescriptionData: []MeasurementDescriptionDataType{
   194  			{
   195  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   196  				ScopeType:     util.Ptr(ScopeTypeTypeACPower),
   197  			},
   198  		},
   199  	}
   200  
   201  	// Act
   202  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   203  	assert.True(t, success)
   204  
   205  	data := sut.MeasurementDescriptionData
   206  	// check the non changing items
   207  	assert.Equal(t, 2, len(data))
   208  	item1 := data[0]
   209  	assert.Equal(t, 0, int(*item1.MeasurementId))
   210  	assert.Equal(t, ScopeTypeTypeACCurrent, *item1.ScopeType)
   211  	// check properties of updated item
   212  	item2 := data[1]
   213  	assert.Equal(t, 1, int(*item2.MeasurementId))
   214  	assert.Equal(t, ScopeTypeTypeACPower, *item2.ScopeType)
   215  }
   216  
   217  func TestMeasurementThresholdRelationListDataType_Update(t *testing.T) {
   218  	sut := MeasurementThresholdRelationListDataType{
   219  		MeasurementThresholdRelationData: []MeasurementThresholdRelationDataType{
   220  			{
   221  				MeasurementId: util.Ptr(MeasurementIdType(0)),
   222  				ThresholdId:   []ThresholdIdType{ThresholdIdType(0)},
   223  			},
   224  			{
   225  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   226  				ThresholdId:   []ThresholdIdType{ThresholdIdType(0)},
   227  			},
   228  		},
   229  	}
   230  
   231  	newData := MeasurementThresholdRelationListDataType{
   232  		MeasurementThresholdRelationData: []MeasurementThresholdRelationDataType{
   233  			{
   234  				MeasurementId: util.Ptr(MeasurementIdType(1)),
   235  				ThresholdId:   []ThresholdIdType{ThresholdIdType(1)},
   236  			},
   237  		},
   238  	}
   239  
   240  	// Act
   241  	_, success := sut.UpdateList(false, true, &newData, NewFilterTypePartial(), nil)
   242  	assert.True(t, success)
   243  
   244  	data := sut.MeasurementThresholdRelationData
   245  	// check the non changing items
   246  	assert.Equal(t, 2, len(data))
   247  	item1 := data[0]
   248  	assert.Equal(t, 0, int(*item1.MeasurementId))
   249  	assert.Equal(t, 0, int(item1.ThresholdId[0]))
   250  	// check properties of updated item
   251  	item2 := data[1]
   252  	assert.Equal(t, 1, int(*item2.MeasurementId))
   253  	assert.Equal(t, 1, int(item2.ThresholdId[0]))
   254  }