github.com/koko1123/flow-go-1@v0.29.6/engine/common/splitter/network/network_test.go (about)

     1  package network_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/rs/zerolog"
     7  	"github.com/stretchr/testify/mock"
     8  	"github.com/stretchr/testify/suite"
     9  
    10  	splitternetwork "github.com/koko1123/flow-go-1/engine/common/splitter/network"
    11  	"github.com/koko1123/flow-go-1/network"
    12  	"github.com/koko1123/flow-go-1/network/channels"
    13  	"github.com/koko1123/flow-go-1/network/mocknetwork"
    14  	"github.com/koko1123/flow-go-1/utils/unittest"
    15  )
    16  
    17  func getEvent() interface{} {
    18  	return struct {
    19  		foo string
    20  	}{
    21  		foo: "bar",
    22  	}
    23  }
    24  
    25  type Suite struct {
    26  	suite.Suite
    27  
    28  	con     *mocknetwork.Conduit
    29  	net     *splitternetwork.Network
    30  	engines map[channels.Channel]network.MessageProcessor
    31  }
    32  
    33  func (suite *Suite) SetupTest() {
    34  	net := new(mocknetwork.Network)
    35  	suite.con = new(mocknetwork.Conduit)
    36  	suite.engines = make(map[channels.Channel]network.MessageProcessor)
    37  
    38  	net.On("Register", mock.AnythingOfType("channels.Channel"), mock.Anything).Run(func(args mock.Arguments) {
    39  		channel, _ := args.Get(0).(channels.Channel)
    40  		engine, ok := args.Get(1).(network.MessageProcessor)
    41  		suite.Assert().True(ok)
    42  		suite.engines[channel] = engine
    43  	}).Return(suite.con, nil)
    44  
    45  	splitterNet := splitternetwork.NewNetwork(net, zerolog.Logger{})
    46  
    47  	suite.net = splitterNet
    48  }
    49  
    50  func TestSplitterNetwork(t *testing.T) {
    51  	suite.Run(t, new(Suite))
    52  }
    53  
    54  // TestHappyPath tests a basic scenario with three channels and three engines
    55  func (suite *Suite) TestHappyPath() {
    56  	id := unittest.IdentifierFixture()
    57  	event := getEvent()
    58  
    59  	chan1 := channels.Channel("test-chan-1")
    60  	chan2 := channels.Channel("test-chan-2")
    61  	chan3 := channels.Channel("test-chan-3")
    62  
    63  	engine1 := new(mocknetwork.Engine)
    64  	engine2 := new(mocknetwork.Engine)
    65  	engine3 := new(mocknetwork.Engine)
    66  
    67  	con, err := suite.net.Register(chan1, engine1)
    68  	suite.Assert().Nil(err)
    69  	suite.Assert().Equal(suite.con, con)
    70  	con, err = suite.net.Register(chan1, engine2)
    71  	suite.Assert().Nil(err)
    72  	suite.Assert().Equal(suite.con, con)
    73  
    74  	con, err = suite.net.Register(chan2, engine2)
    75  	suite.Assert().Nil(err)
    76  	suite.Assert().Equal(suite.con, con)
    77  	con, err = suite.net.Register(chan2, engine3)
    78  	suite.Assert().Nil(err)
    79  	suite.Assert().Equal(suite.con, con)
    80  
    81  	con, err = suite.net.Register(chan3, engine1)
    82  	suite.Assert().Nil(err)
    83  	suite.Assert().Equal(suite.con, con)
    84  	con, err = suite.net.Register(chan3, engine2)
    85  	suite.Assert().Nil(err)
    86  	suite.Assert().Equal(suite.con, con)
    87  	con, err = suite.net.Register(chan3, engine3)
    88  	suite.Assert().Nil(err)
    89  	suite.Assert().Equal(suite.con, con)
    90  
    91  	// Message sent on chan1 should be delivered to engine1 and engine2
    92  
    93  	engine1.On("Process", chan1, id, event).Return(nil).Once()
    94  	engine2.On("Process", chan1, id, event).Return(nil).Once()
    95  
    96  	splitter, ok := suite.engines[chan1]
    97  	suite.Assert().True(ok)
    98  
    99  	err = splitter.Process(chan1, id, event)
   100  	suite.Assert().Nil(err)
   101  
   102  	engine1.AssertNumberOfCalls(suite.T(), "Process", 1)
   103  	engine2.AssertNumberOfCalls(suite.T(), "Process", 1)
   104  	engine3.AssertNumberOfCalls(suite.T(), "Process", 0)
   105  
   106  	engine1.AssertExpectations(suite.T())
   107  	engine2.AssertExpectations(suite.T())
   108  	engine3.AssertExpectations(suite.T())
   109  
   110  	// Message sent on chan2 should be delivered to engine2 and engine3
   111  
   112  	engine2.On("Process", chan2, id, event).Return(nil).Once()
   113  	engine3.On("Process", chan2, id, event).Return(nil).Once()
   114  
   115  	splitter, ok = suite.engines[chan2]
   116  	suite.Assert().True(ok)
   117  
   118  	err = splitter.Process(chan2, id, event)
   119  	suite.Assert().Nil(err)
   120  
   121  	engine1.AssertNumberOfCalls(suite.T(), "Process", 1)
   122  	engine2.AssertNumberOfCalls(suite.T(), "Process", 2)
   123  	engine3.AssertNumberOfCalls(suite.T(), "Process", 1)
   124  
   125  	engine1.AssertExpectations(suite.T())
   126  	engine2.AssertExpectations(suite.T())
   127  	engine3.AssertExpectations(suite.T())
   128  
   129  	// Message sent on chan3 should be delivered to all engines
   130  
   131  	engine1.On("Process", chan3, id, event).Return(nil).Once()
   132  	engine2.On("Process", chan3, id, event).Return(nil).Once()
   133  	engine3.On("Process", chan3, id, event).Return(nil).Once()
   134  
   135  	splitter, ok = suite.engines[chan3]
   136  	suite.Assert().True(ok)
   137  
   138  	err = splitter.Process(chan3, id, event)
   139  	suite.Assert().Nil(err)
   140  
   141  	engine1.AssertNumberOfCalls(suite.T(), "Process", 2)
   142  	engine2.AssertNumberOfCalls(suite.T(), "Process", 3)
   143  	engine3.AssertNumberOfCalls(suite.T(), "Process", 2)
   144  
   145  	engine1.AssertExpectations(suite.T())
   146  	engine2.AssertExpectations(suite.T())
   147  	engine3.AssertExpectations(suite.T())
   148  }