github.com/enbility/spine-go@v0.7.0/model/update_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  type TestUpdateData struct {
    11  	Id           *uint `eebus:"key"`
    12  	IsChangeable *bool `eebus:"writecheck"`
    13  	DataItem     *int
    14  }
    15  
    16  type TestUpdater struct {
    17  	// updateSelectorHashKey *string
    18  	// deleteSelectorHashKey *string
    19  }
    20  
    21  func TestUpdateList_NewItem(t *testing.T) {
    22  	existingData := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(1))}}
    23  	newData := []TestUpdateData{{Id: util.Ptr(uint(2)), DataItem: util.Ptr(int(2))}}
    24  
    25  	expectedResult := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(1))}, {Id: util.Ptr(uint(2)), DataItem: util.Ptr(int(2))}}
    26  
    27  	// Act
    28  	result, boolV := UpdateList(false, existingData, newData, nil, nil)
    29  
    30  	assert.True(t, boolV)
    31  	assert.Equal(t, expectedResult, result)
    32  
    33  	expectedResult = []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(1))}}
    34  
    35  	// Act
    36  	result, boolV = UpdateList(true, existingData, newData, nil, nil)
    37  
    38  	assert.False(t, boolV)
    39  	assert.Equal(t, expectedResult, result)
    40  }
    41  
    42  func TestUpdateList_ChangedItem(t *testing.T) {
    43  	existingData := []TestUpdateData{{Id: util.Ptr(uint(1)), IsChangeable: util.Ptr(false), DataItem: util.Ptr(int(1))}}
    44  	newData := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(2))}}
    45  
    46  	expectedResult := []TestUpdateData{{Id: util.Ptr(uint(1)), IsChangeable: util.Ptr(false), DataItem: util.Ptr(int(2))}}
    47  
    48  	// Act
    49  	result, boolV := UpdateList(false, existingData, newData, nil, nil)
    50  
    51  	assert.True(t, boolV)
    52  	assert.Equal(t, expectedResult, result)
    53  
    54  	expectedResult = []TestUpdateData{{Id: util.Ptr(uint(1)), IsChangeable: util.Ptr(false), DataItem: util.Ptr(int(1))}}
    55  
    56  	// Act
    57  	result, boolV = UpdateList(true, existingData, newData, nil, nil)
    58  
    59  	assert.False(t, boolV)
    60  	assert.Equal(t, expectedResult, result)
    61  }
    62  
    63  func TestUpdateList_NewAndChangedItem(t *testing.T) {
    64  	existingData := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(1))}}
    65  	newData := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(2))}, {Id: util.Ptr(uint(3)), DataItem: util.Ptr(int(3))}}
    66  
    67  	expectedResult := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(2))}, {Id: util.Ptr(uint(3)), DataItem: util.Ptr(int(3))}}
    68  
    69  	// Act
    70  	result, boolV := UpdateList(false, existingData, newData, nil, nil)
    71  
    72  	assert.True(t, boolV)
    73  	assert.Equal(t, expectedResult, result)
    74  
    75  	expectedResult = []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(1))}}
    76  
    77  	// Act
    78  	result, boolV = UpdateList(true, existingData, newData, nil, nil)
    79  
    80  	assert.False(t, boolV)
    81  	assert.Equal(t, expectedResult, result)
    82  }
    83  
    84  func TestUpdateList_ItemWithNoIdentifier(t *testing.T) {
    85  	existingData := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(1))}, {Id: util.Ptr(uint(2)), DataItem: util.Ptr(int(2))}}
    86  	newData := []TestUpdateData{{DataItem: util.Ptr(int(3))}}
    87  
    88  	expectedResult := []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(3))}, {Id: util.Ptr(uint(2)), DataItem: util.Ptr(int(3))}}
    89  
    90  	// Act
    91  	result, boolV := UpdateList(false, existingData, newData, nil, nil)
    92  
    93  	assert.True(t, boolV)
    94  	assert.Equal(t, expectedResult, result)
    95  
    96  	expectedResult = []TestUpdateData{{Id: util.Ptr(uint(1)), DataItem: util.Ptr(int(3))}, {Id: util.Ptr(uint(2)), DataItem: util.Ptr(int(3))}}
    97  
    98  	// Act
    99  	result, boolV = UpdateList(true, existingData, newData, nil, nil)
   100  
   101  	assert.False(t, boolV)
   102  	assert.Equal(t, expectedResult, result)
   103  }
   104  
   105  func TestUpdateList_FilterDelete(t *testing.T) {
   106  	existingData := []LoadControlLimitDataType{
   107  		{
   108  			LimitId: util.Ptr(LoadControlLimitIdType(0)),
   109  			Value:   NewScaledNumberType(0),
   110  		},
   111  		{
   112  			LimitId: util.Ptr(LoadControlLimitIdType(1)),
   113  			Value:   NewScaledNumberType(0),
   114  		},
   115  	}
   116  	newData := []LoadControlLimitDataType{
   117  		{
   118  			LimitId: util.Ptr(LoadControlLimitIdType(1)),
   119  			Value:   NewScaledNumberType(10),
   120  		},
   121  	}
   122  
   123  	expectedResult := []LoadControlLimitDataType{
   124  		{
   125  			LimitId: util.Ptr(LoadControlLimitIdType(1)),
   126  			Value:   NewScaledNumberType(10),
   127  		},
   128  	}
   129  
   130  	filterDelete := &FilterType{CmdControl: &CmdControlType{Delete: &ElementTagType{}}}
   131  	filterDelete.CmdControl.Delete = new(ElementTagType)
   132  	filterDelete.LoadControlLimitListDataSelectors = &LoadControlLimitListDataSelectorsType{
   133  		LimitId: util.Ptr(LoadControlLimitIdType(0)),
   134  	}
   135  
   136  	filterPartial := NewFilterTypePartial()
   137  	filterPartial.LoadControlLimitListDataSelectors = &LoadControlLimitListDataSelectorsType{
   138  		LimitId: util.Ptr(LoadControlLimitIdType(1)),
   139  	}
   140  
   141  	// Act
   142  	result, boolV := UpdateList(false, existingData, newData, filterPartial, filterDelete)
   143  
   144  	assert.True(t, boolV)
   145  	assert.Equal(t, expectedResult, result)
   146  
   147  	newData = []LoadControlLimitDataType{
   148  		{
   149  			Value: NewScaledNumberType(10),
   150  		},
   151  	}
   152  
   153  	expectedResult = []LoadControlLimitDataType{
   154  		{
   155  			LimitId: util.Ptr(LoadControlLimitIdType(0)),
   156  			Value:   NewScaledNumberType(0),
   157  		},
   158  		{
   159  			LimitId: util.Ptr(LoadControlLimitIdType(1)),
   160  			Value:   NewScaledNumberType(0),
   161  		},
   162  	}
   163  
   164  	// Act
   165  	result, boolV = UpdateList(true, existingData, newData, filterPartial, filterDelete)
   166  
   167  	assert.False(t, boolV)
   168  	assert.Equal(t, expectedResult, result)
   169  }
   170  
   171  func TestRemoveFieldFromType(t *testing.T) {
   172  	items := &LoadControlLimitListDataType{
   173  		LoadControlLimitData: []LoadControlLimitDataType{
   174  			{
   175  				LimitId: util.Ptr(LoadControlLimitIdType(1)),
   176  				Value:   NewScaledNumberType(16.0),
   177  			},
   178  		},
   179  	}
   180  
   181  	elements := &LoadControlLimitDataElementsType{
   182  		Value: &ScaledNumberElementsType{},
   183  	}
   184  
   185  	RemoveElementFromItem(&items.LoadControlLimitData[0], elements)
   186  
   187  	var nilValue *ScaledNumberType
   188  
   189  	assert.Equal(t, nilValue, items.LoadControlLimitData[0].Value)
   190  }
   191  
   192  // TODO: Fix, as these tests won't work right now as TestUpdater doesn't use FilterProvider and its data structure
   193  /*
   194  func TestUpdateList_UpdateSelector(t *testing.T) {
   195  	existingData := []TestUpdateData{{Id: util.Ptr(1), DataItem: 1}, {Id: util.Ptr(2), DataItem: 2}}
   196  	newData := []TestUpdateData{{DataItem: 3}}
   197  
   198  	dataProvider := &TestUpdater{
   199  		updateSelectorHashKey: util.Ptr("1"),
   200  	}
   201  	expectedResult := []TestUpdateData{{Id: util.Ptr(1), DataItem: 3}, {Id: util.Ptr(2), DataItem: 2}}
   202  
   203  	// Act
   204  	result := UpdateList[TestUpdateData](existingData, newData, dataProvider)
   205  
   206  	assert.Equal(t, expectedResult, result)
   207  }
   208  
   209  func TestUpdateList_DeleteSelector(t *testing.T) {
   210  	existingData := []TestUpdateData{{Id: util.Ptr(1), DataItem: 1}, {Id: util.Ptr(2), DataItem: 2}}
   211  	newData := []TestUpdateData{{Id: util.Ptr(0), DataItem: 0}}
   212  
   213  	dataProvider := &TestUpdater{
   214  		deleteSelectorHashKey: util.Ptr("1"),
   215  	}
   216  	expectedResult := []TestUpdateData{{Id: util.Ptr(2), DataItem: 2}}
   217  
   218  	// Act
   219  	result := UpdateList[TestUpdateData](existingData, newData, dataProvider)
   220  
   221  	assert.Equal(t, expectedResult, result)
   222  }
   223  */