github.com/vmware/transport-go@v1.3.4/bus/channel_test.go (about)

     1  // Copyright 2019-2020 VMware, Inc.
     2  // SPDX-License-Identifier: BSD-2-Clause
     3  
     4  package bus
     5  
     6  import (
     7  	"github.com/go-stomp/stomp/v3/frame"
     8  	"github.com/google/uuid"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/mock"
    11  	"github.com/vmware/transport-go/bridge"
    12  	"github.com/vmware/transport-go/model"
    13  	"testing"
    14  )
    15  
    16  var testChannelName string = "testing"
    17  
    18  func TestChannel_CheckChannelCreation(t *testing.T) {
    19  
    20  	channel := NewChannel(testChannelName)
    21  	assert.Empty(t, channel.eventHandlers)
    22  
    23  }
    24  
    25  func TestChannel_SubscribeHandler(t *testing.T) {
    26  	id := uuid.New()
    27  	channel := NewChannel(testChannelName)
    28  	handler := func(*model.Message) {}
    29  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handler, runOnce: false, uuid: &id})
    30  
    31  	assert.Equal(t, 1, len(channel.eventHandlers))
    32  
    33  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handler, runOnce: false, uuid: &id})
    34  
    35  	assert.Equal(t, 2, len(channel.eventHandlers))
    36  }
    37  
    38  func TestChannel_HandlerCheck(t *testing.T) {
    39  	channel := NewChannel(testChannelName)
    40  	id := uuid.New()
    41  	assert.False(t, channel.ContainsHandlers())
    42  
    43  	handler := func(*model.Message) {}
    44  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handler, runOnce: false, uuid: &id})
    45  
    46  	assert.True(t, channel.ContainsHandlers())
    47  }
    48  
    49  func TestChannel_SendMessage(t *testing.T) {
    50  	id := uuid.New()
    51  	channel := NewChannel(testChannelName)
    52  	handler := func(message *model.Message) {
    53  		assert.Equal(t, message.Payload.(string), "pickled eggs")
    54  		assert.Equal(t, message.Channel, testChannelName)
    55  	}
    56  
    57  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handler, runOnce: false, uuid: &id})
    58  
    59  	var message = &model.Message{
    60  		Id:        &id,
    61  		Payload:   "pickled eggs",
    62  		Channel:   testChannelName,
    63  		Direction: model.RequestDir}
    64  
    65  	channel.Send(message)
    66  	channel.wg.Wait()
    67  }
    68  
    69  func TestChannel_SendMessageRunOnceHasRun(t *testing.T) {
    70  	id := uuid.New()
    71  	channel := NewChannel(testChannelName)
    72  	count := 0
    73  	handler := func(message *model.Message) {
    74  		assert.Equal(t, message.Payload.(string), "pickled eggs")
    75  		assert.Equal(t, message.Channel, testChannelName)
    76  		count++
    77  	}
    78  
    79  	h := &channelEventHandler{callBackFunction: handler, runOnce: true, uuid: &id}
    80  	channel.subscribeHandler(h)
    81  
    82  	var message = &model.Message{
    83  		Id:        &id,
    84  		Payload:   "pickled eggs",
    85  		Channel:   testChannelName,
    86  		Direction: model.RequestDir}
    87  
    88  	channel.Send(message)
    89  	channel.wg.Wait()
    90  	h.runCount = 1
    91  	channel.Send(message)
    92  	assert.Len(t, channel.eventHandlers, 0)
    93  	assert.Equal(t, 1, count)
    94  }
    95  
    96  func TestChannel_SendMultipleMessages(t *testing.T) {
    97  	id := uuid.New()
    98  	channel := NewChannel(testChannelName)
    99  	var counter int32 = 0
   100  	handler := func(message *model.Message) {
   101  		assert.Equal(t, message.Payload.(string), "chewy louie")
   102  		assert.Equal(t, message.Channel, testChannelName)
   103  		inc(&counter)
   104  	}
   105  
   106  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handler, runOnce: false, uuid: &id})
   107  	var message = &model.Message{
   108  		Id:        &id,
   109  		Payload:   "chewy louie",
   110  		Channel:   testChannelName,
   111  		Direction: model.RequestDir}
   112  
   113  	channel.Send(message)
   114  	channel.Send(message)
   115  	channel.Send(message)
   116  	channel.wg.Wait()
   117  	assert.Equal(t, int32(3), counter)
   118  }
   119  
   120  func TestChannel_MultiHandlerSingleMessage(t *testing.T) {
   121  	id := uuid.New()
   122  	channel := NewChannel(testChannelName)
   123  	var counterA, counterB, counterC int32 = 0, 0, 0
   124  
   125  	handlerA := func(message *model.Message) {
   126  		inc(&counterA)
   127  	}
   128  	handlerB := func(message *model.Message) {
   129  		inc(&counterB)
   130  	}
   131  	handlerC := func(message *model.Message) {
   132  		inc(&counterC)
   133  	}
   134  
   135  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handlerA, runOnce: false, uuid: &id})
   136  
   137  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handlerB, runOnce: false, uuid: &id})
   138  
   139  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handlerC, runOnce: false, uuid: &id})
   140  
   141  	var message = &model.Message{
   142  		Id:        &id,
   143  		Payload:   "late night munchies",
   144  		Channel:   testChannelName,
   145  		Direction: model.RequestDir}
   146  
   147  	channel.Send(message)
   148  	channel.Send(message)
   149  	channel.Send(message)
   150  	channel.wg.Wait()
   151  	value := counterA + counterB + counterC
   152  
   153  	assert.Equal(t, int32(9), value)
   154  }
   155  
   156  func TestChannel_Privacy(t *testing.T) {
   157  	channel := NewChannel(testChannelName)
   158  	assert.False(t, channel.private)
   159  	channel.SetPrivate(true)
   160  	assert.True(t, channel.IsPrivate())
   161  }
   162  
   163  func TestChannel_ChannelGalactic(t *testing.T) {
   164  	channel := NewChannel(testChannelName)
   165  	assert.False(t, channel.galactic)
   166  	channel.SetGalactic("somewhere")
   167  	assert.True(t, channel.IsGalactic())
   168  }
   169  
   170  func TestChannel_RemoveEventHandler(t *testing.T) {
   171  	channel := NewChannel(testChannelName)
   172  	handlerA := func(message *model.Message) {}
   173  	handlerB := func(message *model.Message) {}
   174  
   175  	idA := uuid.New()
   176  	idB := uuid.New()
   177  
   178  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handlerA, runOnce: false, uuid: &idA})
   179  
   180  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handlerB, runOnce: false, uuid: &idB})
   181  
   182  	assert.Len(t, channel.eventHandlers, 2)
   183  
   184  	// remove the first handler (A)
   185  	channel.removeEventHandler(0)
   186  	assert.Len(t, channel.eventHandlers, 1)
   187  	assert.Equal(t, idB.String(), channel.eventHandlers[0].uuid.String())
   188  
   189  	// remove the second handler B)
   190  	channel.removeEventHandler(0)
   191  	assert.True(t, len(channel.eventHandlers) == 0)
   192  
   193  }
   194  
   195  func TestChannel_RemoveEventHandlerNoHandlers(t *testing.T) {
   196  	channel := NewChannel(testChannelName)
   197  
   198  	channel.removeEventHandler(0)
   199  	assert.Len(t, channel.eventHandlers, 0)
   200  }
   201  
   202  func TestChannel_RemoveEventHandlerOOBIndex(t *testing.T) {
   203  	channel := NewChannel(testChannelName)
   204  	id := uuid.New()
   205  	handler := func(*model.Message) {}
   206  	channel.subscribeHandler(&channelEventHandler{callBackFunction: handler, runOnce: false, uuid: &id})
   207  
   208  	channel.removeEventHandler(999)
   209  	assert.Len(t, channel.eventHandlers, 1)
   210  }
   211  
   212  func TestChannel_AddRemoveBrokerSubscription(t *testing.T) {
   213  	channel := NewChannel(testChannelName)
   214  	id := uuid.New()
   215  	sub := &MockBridgeSubscription{Id: &id}
   216  	c := &MockBridgeConnection{Id: &id}
   217  	channel.addBrokerSubscription(c, sub)
   218  	assert.Len(t, channel.brokerSubs, 1)
   219  	channel.removeBrokerSubscription(sub)
   220  	assert.Len(t, channel.brokerSubs, 0)
   221  }
   222  
   223  func TestChannel_CheckIfBrokerSubscribed(t *testing.T) {
   224  
   225  	cId := uuid.New()
   226  	sId := uuid.New()
   227  	sId2 := uuid.New()
   228  
   229  	c := &MockBridgeConnection{
   230  		Id: &cId,
   231  	}
   232  	s := &MockBridgeSubscription{Id: &sId}
   233  	s2 := &MockBridgeSubscription{Id: &sId2}
   234  
   235  	cm := NewBusChannelManager(GetBus())
   236  	ch := cm.CreateChannel("testing-broker-subs")
   237  	ch.addBrokerSubscription(c, s)
   238  	assert.True(t, ch.isBrokerSubscribed(s))
   239  	assert.False(t, ch.isBrokerSubscribed(s2))
   240  
   241  	ch.removeBrokerSubscription(s)
   242  	assert.False(t, ch.isBrokerSubscribed(s))
   243  }
   244  
   245  type MockBridgeConnection struct {
   246  	mock.Mock
   247  	Id *uuid.UUID
   248  }
   249  
   250  func (c *MockBridgeConnection) GetId() *uuid.UUID {
   251  	return c.Id
   252  }
   253  
   254  func (c *MockBridgeConnection) SubscribeReplyDestination(destination string) (bridge.Subscription, error) {
   255  	args := c.MethodCalled("Subscribe", destination)
   256  	return args.Get(0).(bridge.Subscription), args.Error(1)
   257  }
   258  
   259  func (c *MockBridgeConnection) Subscribe(destination string) (bridge.Subscription, error) {
   260  	args := c.MethodCalled("Subscribe", destination)
   261  	return args.Get(0).(bridge.Subscription), args.Error(1)
   262  }
   263  
   264  func (c *MockBridgeConnection) Disconnect() (err error) {
   265  	return nil
   266  }
   267  
   268  func (c *MockBridgeConnection) SendJSONMessage(destination string, payload []byte, opts ...func(frame *frame.Frame) error) error {
   269  	args := c.MethodCalled("SendJSONMessage", destination, payload)
   270  	return args.Error(0)
   271  }
   272  
   273  func (c *MockBridgeConnection) SendMessage(destination, contentType string, payload []byte, opts ...func(frame *frame.Frame) error) error {
   274  	args := c.MethodCalled("SendMessage", destination, contentType, payload)
   275  	return args.Error(0)
   276  }
   277  
   278  func (c *MockBridgeConnection) SendMessageWithReplyDestination(destination, reply, contentType string, payload []byte, opts ...func(frame *frame.Frame) error) error {
   279  	args := c.MethodCalled("SendMessage", destination, contentType, payload)
   280  	return args.Error(0)
   281  }
   282  
   283  type MockBridgeSubscription struct {
   284  	Id          *uuid.UUID
   285  	Destination string
   286  	Channel     chan *model.Message
   287  }
   288  
   289  func (m *MockBridgeSubscription) GetId() *uuid.UUID {
   290  	return m.Id
   291  }
   292  
   293  func (m *MockBridgeSubscription) GetDestination() string {
   294  	return m.Destination
   295  }
   296  
   297  func (m *MockBridgeSubscription) GetMsgChannel() chan *model.Message {
   298  	return m.Channel
   299  }
   300  
   301  func (m *MockBridgeSubscription) Unsubscribe() error {
   302  	return nil
   303  }