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  }