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

     1  package spine
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/enbility/spine-go/model"
     8  	"github.com/enbility/spine-go/util"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func Test_SendSpineMessage(t *testing.T) {
    13  	sut := &Sender{}
    14  
    15  	datagram := model.DatagramType{}
    16  	err := sut.sendSpineMessage(datagram)
    17  	assert.NotNil(t, err)
    18  
    19  	temp := &WriteMessageHandler{}
    20  	sut.writeHandler = temp
    21  	err = sut.sendSpineMessage(datagram)
    22  	assert.Nil(t, err)
    23  }
    24  
    25  func Test_Cache(t *testing.T) {
    26  	temp := &WriteMessageHandler{}
    27  	sut := NewSender(temp)
    28  
    29  	cmdClassifier := model.CmdClassifierTypeRead
    30  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
    31  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
    32  	cmd := []model.CmdType{
    33  		{
    34  			ResultData: &model.ResultDataType{ErrorNumber: util.Ptr(model.ErrorNumberType(model.ErrorNumberTypeNoError))},
    35  		},
    36  	}
    37  
    38  	msgCounter, err := sut.Request(cmdClassifier, senderAddress, destinationAddress, false, cmd)
    39  	assert.NoError(t, err)
    40  	assert.NotNil(t, msgCounter)
    41  
    42  	msgCounter2, err := sut.Request(cmdClassifier, senderAddress, destinationAddress, false, cmd)
    43  	assert.NoError(t, err)
    44  	assert.NotNil(t, msgCounter2)
    45  	assert.Equal(t, *msgCounter, *msgCounter2)
    46  
    47  	sut.ProcessResponseForMsgCounterReference(msgCounter)
    48  
    49  	msgCounter3, err := sut.Request(cmdClassifier, senderAddress, destinationAddress, false, cmd)
    50  	assert.NoError(t, err)
    51  	assert.NotNil(t, msgCounter3)
    52  	assert.NotEqual(t, *msgCounter, *msgCounter3)
    53  
    54  	for i := 0; i < 50; i++ {
    55  		expMsgCounter4 := model.MsgCounterType(i + 3)
    56  		destinationAddress = featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
    57  		cmd = []model.CmdType{
    58  			{
    59  				ResultData: &model.ResultDataType{ErrorNumber: util.Ptr(model.ErrorNumberType(i + 1))},
    60  			},
    61  		}
    62  
    63  		msgCounter4, err := sut.Request(cmdClassifier, senderAddress, destinationAddress, false, cmd)
    64  		assert.Nil(t, err)
    65  		assert.NotNil(t, expMsgCounter4)
    66  		assert.NotEqual(t, *msgCounter, *msgCounter4)
    67  		assert.NotEqual(t, *msgCounter3, *msgCounter4)
    68  	}
    69  }
    70  
    71  func TestSender_Reply_MsgCounter(t *testing.T) {
    72  	temp := &WriteMessageHandler{}
    73  	sut := NewSender(temp)
    74  
    75  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
    76  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
    77  	requestHeader := &model.HeaderType{
    78  		AddressSource:      senderAddress,
    79  		AddressDestination: destinationAddress,
    80  		MsgCounter:         util.Ptr(model.MsgCounterType(10)),
    81  	}
    82  	cmd := model.CmdType{
    83  		ResultData: &model.ResultDataType{ErrorNumber: util.Ptr(model.ErrorNumberType(model.ErrorNumberTypeNoError))},
    84  	}
    85  
    86  	err := sut.Reply(requestHeader, senderAddress, cmd)
    87  	assert.NoError(t, err)
    88  
    89  	// Act
    90  	err = sut.Reply(requestHeader, senderAddress, cmd)
    91  	assert.NoError(t, err)
    92  	expectedMsgCounter := 2 //because Notify was called twice
    93  
    94  	sentBytes := temp.LastMessage()
    95  	var sentDatagram model.Datagram
    96  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
    97  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
    98  }
    99  
   100  func TestSender_Notify_MsgCounter(t *testing.T) {
   101  	temp := &WriteMessageHandler{}
   102  	sut := NewSender(temp)
   103  
   104  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
   105  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
   106  	cmd := model.CmdType{
   107  		ResultData: &model.ResultDataType{ErrorNumber: util.Ptr(model.ErrorNumberType(model.ErrorNumberTypeNoError))},
   108  	}
   109  
   110  	_, err := sut.Notify(senderAddress, destinationAddress, cmd)
   111  	assert.NoError(t, err)
   112  
   113  	// Act
   114  	_, err = sut.Notify(senderAddress, destinationAddress, cmd)
   115  	assert.NoError(t, err)
   116  	expectedMsgCounter := 2 //because Notify was called twice
   117  
   118  	sentBytes := temp.LastMessage()
   119  	var sentDatagram model.Datagram
   120  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   121  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   122  
   123  	_, err = sut.DatagramForMsgCounter(model.MsgCounterType(2))
   124  	assert.NoError(t, err)
   125  
   126  	_, err = sut.DatagramForMsgCounter(model.MsgCounterType(3))
   127  	assert.Error(t, err)
   128  }
   129  
   130  func TestSender_Write_MsgCounter(t *testing.T) {
   131  	temp := &WriteMessageHandler{}
   132  	sut := NewSender(temp)
   133  
   134  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
   135  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
   136  	cmd := model.CmdType{
   137  		ResultData: &model.ResultDataType{ErrorNumber: util.Ptr(model.ErrorNumberType(model.ErrorNumberTypeNoError))},
   138  	}
   139  
   140  	_, err := sut.Write(senderAddress, destinationAddress, cmd)
   141  	assert.NoError(t, err)
   142  
   143  	// Act
   144  	_, err = sut.Write(senderAddress, destinationAddress, cmd)
   145  	assert.NoError(t, err)
   146  	expectedMsgCounter := 2 //because Write was called twice
   147  
   148  	sentBytes := temp.LastMessage()
   149  	var sentDatagram model.Datagram
   150  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   151  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   152  }
   153  
   154  func TestSender_Subscribe_MsgCounter(t *testing.T) {
   155  	temp := &WriteMessageHandler{}
   156  	sut := NewSender(temp)
   157  
   158  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
   159  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
   160  
   161  	_, err := sut.Subscribe(senderAddress, destinationAddress, model.FeatureTypeTypeLoadControl)
   162  	assert.NoError(t, err)
   163  
   164  	// Act
   165  	_, err = sut.Subscribe(senderAddress, destinationAddress, model.FeatureTypeTypeLoadControl)
   166  	assert.NoError(t, err)
   167  	expectedMsgCounter := 1 //because Subscribe was called twice and it was cached
   168  
   169  	sentBytes := temp.LastMessage()
   170  	var sentDatagram model.Datagram
   171  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   172  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   173  
   174  	msgCounter := model.MsgCounterType(expectedMsgCounter)
   175  	sut.ProcessResponseForMsgCounterReference(&msgCounter)
   176  
   177  	_, err = sut.Subscribe(senderAddress, destinationAddress, model.FeatureTypeTypeLoadControl)
   178  	assert.NoError(t, err)
   179  	expectedMsgCounter = 2 //because Subscribe was called again
   180  
   181  	sentBytes = temp.LastMessage()
   182  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   183  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   184  }
   185  
   186  func TestSender_Unsubscribe_MsgCounter(t *testing.T) {
   187  	temp := &WriteMessageHandler{}
   188  	sut := NewSender(temp)
   189  
   190  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
   191  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
   192  
   193  	_, err := sut.Unsubscribe(senderAddress, destinationAddress)
   194  	assert.NoError(t, err)
   195  
   196  	// Act
   197  	_, err = sut.Unsubscribe(senderAddress, destinationAddress)
   198  	assert.NoError(t, err)
   199  	expectedMsgCounter := 1 //because Unsubscribe was called twice and it was cached
   200  
   201  	sentBytes := temp.LastMessage()
   202  	var sentDatagram model.Datagram
   203  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   204  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   205  
   206  	msgCounter := model.MsgCounterType(expectedMsgCounter)
   207  	sut.ProcessResponseForMsgCounterReference(&msgCounter)
   208  
   209  	_, err = sut.Unsubscribe(senderAddress, destinationAddress)
   210  	assert.NoError(t, err)
   211  	expectedMsgCounter = 2 //because Unsubscribe was called again
   212  
   213  	sentBytes = temp.LastMessage()
   214  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   215  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   216  }
   217  
   218  func TestSender_Bind_MsgCounter(t *testing.T) {
   219  	temp := &WriteMessageHandler{}
   220  	sut := NewSender(temp)
   221  
   222  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
   223  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
   224  
   225  	_, err := sut.Bind(senderAddress, destinationAddress, model.FeatureTypeTypeLoadControl)
   226  	assert.NoError(t, err)
   227  
   228  	// Act
   229  	_, err = sut.Bind(senderAddress, destinationAddress, model.FeatureTypeTypeLoadControl)
   230  	assert.NoError(t, err)
   231  	expectedMsgCounter := 1 //because Bind was called twice and it was cached
   232  
   233  	sentBytes := temp.LastMessage()
   234  	var sentDatagram model.Datagram
   235  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   236  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   237  
   238  	msgCounter := model.MsgCounterType(expectedMsgCounter)
   239  	sut.ProcessResponseForMsgCounterReference(&msgCounter)
   240  
   241  	_, err = sut.Bind(senderAddress, destinationAddress, model.FeatureTypeTypeLoadControl)
   242  	assert.NoError(t, err)
   243  	expectedMsgCounter = 2 //because Bind was called again
   244  
   245  	sentBytes = temp.LastMessage()
   246  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   247  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   248  }
   249  
   250  func TestSender_Unbind_MsgCounter(t *testing.T) {
   251  	temp := &WriteMessageHandler{}
   252  	sut := NewSender(temp)
   253  
   254  	senderAddress := featureAddressType(1, NewEntityAddressType("Sender", []uint{1}))
   255  	destinationAddress := featureAddressType(2, NewEntityAddressType("destination", []uint{1}))
   256  
   257  	_, err := sut.Unbind(senderAddress, destinationAddress)
   258  	assert.NoError(t, err)
   259  
   260  	// Act
   261  	_, err = sut.Unbind(senderAddress, destinationAddress)
   262  	assert.NoError(t, err)
   263  	expectedMsgCounter := 1 //because Unbind was called twice and it was cached
   264  
   265  	sentBytes := temp.LastMessage()
   266  	var sentDatagram model.Datagram
   267  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   268  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   269  
   270  	msgCounter := model.MsgCounterType(expectedMsgCounter)
   271  	sut.ProcessResponseForMsgCounterReference(&msgCounter)
   272  
   273  	_, err = sut.Unbind(senderAddress, destinationAddress)
   274  	assert.NoError(t, err)
   275  	expectedMsgCounter = 2 //because Unbind was called again
   276  
   277  	sentBytes = temp.LastMessage()
   278  	assert.NoError(t, json.Unmarshal(sentBytes, &sentDatagram))
   279  	assert.Equal(t, expectedMsgCounter, int(*sentDatagram.Datagram.Header.MsgCounter))
   280  }