diff --git a/be1-go/internal/handler/message/hmessage/message.go b/be1-go/internal/handler/message/hmessage/message.go index f5a971c1bb..9fc33d98fa 100644 --- a/be1-go/internal/handler/message/hmessage/message.go +++ b/be1-go/internal/handler/message/hmessage/message.go @@ -3,7 +3,6 @@ package hmessage import ( "github.com/rs/zerolog" "popstellar/internal/errors" - "popstellar/internal/handler/channel" "popstellar/internal/handler/message/mmessage" ) @@ -16,27 +15,19 @@ type Repository interface { GetChannelType(channel string) (string, error) } -type DataHandler interface { +type ChannelHandler interface { Handle(channelPath string, msg mmessage.Message) error } -type DataHandlers struct { - Root DataHandler - Lao DataHandler - Election DataHandler - Chirp DataHandler - Reaction DataHandler - Coin DataHandler - Federation DataHandler -} +type ChannelHandlers map[string]ChannelHandler type Handler struct { db Repository - handlers DataHandlers + handlers ChannelHandlers log zerolog.Logger } -func New(db Repository, handlers DataHandlers, log zerolog.Logger) *Handler { +func New(db Repository, handlers ChannelHandlers, log zerolog.Logger) *Handler { return &Handler{ db: db, handlers: handlers, @@ -66,23 +57,10 @@ func (h *Handler) Handle(channelPath string, msg mmessage.Message, fromRumor boo return err } - switch channelType { - case channel.RootObject: - err = h.handlers.Root.Handle(channelPath, msg) - case channel.LAOObject: - err = h.handlers.Lao.Handle(channelPath, msg) - case channel.ElectionObject: - err = h.handlers.Election.Handle(channelPath, msg) - case channel.ChirpObject: - err = h.handlers.Chirp.Handle(channelPath, msg) - case channel.ReactionObject: - err = h.handlers.Reaction.Handle(channelPath, msg) - case channel.CoinObject: - err = h.handlers.Coin.Handle(channelPath, msg) - case channel.FederationObject: - err = h.handlers.Federation.Handle(channelPath, msg) - default: - err = errors.NewInvalidResourceError("unknown channelPath type for %s", channelPath) + handler, ok := h.handlers[channelType] + if !ok { + return errors.NewInvalidResourceError("unknown channelPath type for %s", channelPath) } - return err + + return handler.Handle(channelPath, msg) } diff --git a/be1-go/internal/handler/message/hmessage/message_test.go b/be1-go/internal/handler/message/hmessage/message_test.go index c9c10cf646..d96a87c633 100644 --- a/be1-go/internal/handler/message/hmessage/message_test.go +++ b/be1-go/internal/handler/message/hmessage/message_test.go @@ -14,21 +14,18 @@ import ( "time" ) +func Test_New(t *testing.T) { + +} + func Test_handleChannel(t *testing.T) { db := mocks.NewRepository(t) - dataHandler := mocks.NewDataHandler(t) - - subHandlers := DataHandlers{ - Root: dataHandler, - Lao: dataHandler, - Election: dataHandler, - Chirp: dataHandler, - Reaction: dataHandler, - Coin: dataHandler, - Federation: dataHandler, - } + channelHandler := mocks.NewChannelHandler(t) + + channelHandlers := make(ChannelHandlers) + channelHandlers[channel.Root] = channelHandler - msgHandler := New(db, subHandlers, zerolog.New(io.Discard)) + msgHandler := New(db, channelHandlers, zerolog.New(io.Discard)) _, publicBuf, private, _ := generator.GenerateKeyPair(t) sender := base64.URLEncoding.EncodeToString(publicBuf) @@ -189,12 +186,12 @@ func Test_handleChannel(t *testing.T) { // Test 12: success to handled message for channel root - channelPath = "rootMsg" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) + channelPath = "/root" + msg = generator.NewLaoCreateMsg(t, sender, "laoID", "laoName", time.Now().Unix(), sender, private) db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.RootObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) + db.On("GetChannelType", channelPath).Return(channel.Root, nil).Once() + channelHandler.On("Handle", channelPath, msg).Return(nil) args = append(args, input{ name: "Test 12", @@ -203,102 +200,6 @@ func Test_handleChannel(t *testing.T) { isError: false, }) - // Test 13: success to handled message for channel lao - - channelPath = "laoMsg" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) - - db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.LAOObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) - - args = append(args, input{ - name: "Test 13", - channelPath: channelPath, - message: msg, - isError: false, - }) - - // Test 14: success to handled message for channel election - - channelPath = "electionMsg" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) - - db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.ElectionObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) - - args = append(args, input{ - name: "Test 14", - channelPath: channelPath, - message: msg, - isError: false, - }) - - // Test 15: success to handled message for channel chirp - - channelPath = "chirpMsg" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) - - db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.ChirpObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) - - args = append(args, input{ - name: "Test 15", - channelPath: channelPath, - message: msg, - isError: false, - }) - - // Test 16: success to handled message for channel reaction - - channelPath = "reaction" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) - - db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.ReactionObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) - - args = append(args, input{ - name: "Test 16", - channelPath: channelPath, - message: msg, - isError: false, - }) - - // Test 17: success to handled message for channel coin - - channelPath = "coinMsg" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) - - db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.CoinObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) - - args = append(args, input{ - name: "Test 17", - channelPath: channelPath, - message: msg, - isError: false, - }) - - // Test 18: success to handled message for channel coin - - channelPath = "coinMsg" - msg = generator.NewChirpAddMsg(t, sender, private, time.Now().Unix()) - - db.On("HasMessage", msg.MessageID).Return(false, nil) - db.On("GetChannelType", channelPath).Return(channel.FederationObject, nil) - dataHandler.On("Handle", channelPath, msg).Return(nil) - - args = append(args, input{ - name: "Test 18", - channelPath: channelPath, - message: msg, - isError: false, - }) - for _, arg := range args { t.Run(arg.name, func(t *testing.T) { err := msgHandler.Handle(arg.channelPath, arg.message, false) diff --git a/be1-go/internal/handler/message/hmessage/mocks/data_handler.go b/be1-go/internal/handler/message/hmessage/mocks/channel_handler.go similarity index 50% rename from be1-go/internal/handler/message/hmessage/mocks/data_handler.go rename to be1-go/internal/handler/message/hmessage/mocks/channel_handler.go index 19409b6dfc..d937706f34 100644 --- a/be1-go/internal/handler/message/hmessage/mocks/data_handler.go +++ b/be1-go/internal/handler/message/hmessage/mocks/channel_handler.go @@ -3,18 +3,18 @@ package mocks import ( - message "popstellar/internal/handler/message/mmessage" + mmessage "popstellar/internal/handler/message/mmessage" mock "github.com/stretchr/testify/mock" ) -// DataHandler is an autogenerated mock type for the DataHandler type -type DataHandler struct { +// ChannelHandler is an autogenerated mock type for the ChannelHandler type +type ChannelHandler struct { mock.Mock } // Handle provides a mock function with given fields: channelPath, msg -func (_m *DataHandler) Handle(channelPath string, msg message.Message) error { +func (_m *ChannelHandler) Handle(channelPath string, msg mmessage.Message) error { ret := _m.Called(channelPath, msg) if len(ret) == 0 { @@ -22,7 +22,7 @@ func (_m *DataHandler) Handle(channelPath string, msg message.Message) error { } var r0 error - if rf, ok := ret.Get(0).(func(string, message.Message) error); ok { + if rf, ok := ret.Get(0).(func(string, mmessage.Message) error); ok { r0 = rf(channelPath, msg) } else { r0 = ret.Error(0) @@ -31,13 +31,13 @@ func (_m *DataHandler) Handle(channelPath string, msg message.Message) error { return r0 } -// NewDataHandler creates a new instance of DataHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// NewChannelHandler creates a new instance of ChannelHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. // The first argument is typically a *testing.T value. -func NewDataHandler(t interface { +func NewChannelHandler(t interface { mock.TestingT Cleanup(func()) -}) *DataHandler { - mock := &DataHandler{} +}) *ChannelHandler { + mock := &ChannelHandler{} mock.Mock.Test(t) t.Cleanup(func() { mock.AssertExpectations(t) }) diff --git a/be1-go/internal/handler/method/publish/hpublish/mocks/hub.go b/be1-go/internal/handler/method/publish/hpublish/mocks/hub.go new file mode 100644 index 0000000000..29ff9f4945 --- /dev/null +++ b/be1-go/internal/handler/method/publish/hpublish/mocks/hub.go @@ -0,0 +1,42 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Hub is an autogenerated mock type for the Hub type +type Hub struct { + mock.Mock +} + +// NotifyResetRumorSender provides a mock function with given fields: +func (_m *Hub) NotifyResetRumorSender() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for NotifyResetRumorSender") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewHub creates a new instance of Hub. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewHub(t interface { + mock.TestingT + Cleanup(func()) +}) *Hub { + mock := &Hub{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/publish/hpublish/mocks/message_handler.go b/be1-go/internal/handler/method/publish/hpublish/mocks/message_handler.go new file mode 100644 index 0000000000..67a6540bc7 --- /dev/null +++ b/be1-go/internal/handler/method/publish/hpublish/mocks/message_handler.go @@ -0,0 +1,46 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import ( + mmessage "popstellar/internal/handler/message/mmessage" + + mock "github.com/stretchr/testify/mock" +) + +// MessageHandler is an autogenerated mock type for the MessageHandler type +type MessageHandler struct { + mock.Mock +} + +// Handle provides a mock function with given fields: channelPath, msg, fromRumor +func (_m *MessageHandler) Handle(channelPath string, msg mmessage.Message, fromRumor bool) error { + ret := _m.Called(channelPath, msg, fromRumor) + + if len(ret) == 0 { + panic("no return value specified for Handle") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, mmessage.Message, bool) error); ok { + r0 = rf(channelPath, msg, fromRumor) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// NewMessageHandler creates a new instance of MessageHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMessageHandler(t interface { + mock.TestingT + Cleanup(func()) +}) *MessageHandler { + mock := &MessageHandler{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/publish/hpublish/mocks/repository.go b/be1-go/internal/handler/method/publish/hpublish/mocks/repository.go new file mode 100644 index 0000000000..995d444c6f --- /dev/null +++ b/be1-go/internal/handler/method/publish/hpublish/mocks/repository.go @@ -0,0 +1,52 @@ +// Code generated by mockery v2.42.1. DO NOT EDIT. + +package mocks + +import mock "github.com/stretchr/testify/mock" + +// Repository is an autogenerated mock type for the Repository type +type Repository struct { + mock.Mock +} + +// AddMessageToMyRumor provides a mock function with given fields: messageID +func (_m *Repository) AddMessageToMyRumor(messageID string) (int, error) { + ret := _m.Called(messageID) + + if len(ret) == 0 { + panic("no return value specified for AddMessageToMyRumor") + } + + var r0 int + var r1 error + if rf, ok := ret.Get(0).(func(string) (int, error)); ok { + return rf(messageID) + } + if rf, ok := ret.Get(0).(func(string) int); ok { + r0 = rf(messageID) + } else { + r0 = ret.Get(0).(int) + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(messageID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewRepository creates a new instance of Repository. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewRepository(t interface { + mock.TestingT + Cleanup(func()) +}) *Repository { + mock := &Repository{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/be1-go/internal/handler/method/publish/hpublish/publish_test.go b/be1-go/internal/handler/method/publish/hpublish/publish_test.go new file mode 100644 index 0000000000..e19be04c9e --- /dev/null +++ b/be1-go/internal/handler/method/publish/hpublish/publish_test.go @@ -0,0 +1,57 @@ +package hpublish + +import ( + "github.com/stretchr/testify/require" + "popstellar/internal/handler/method/publish/hpublish/mocks" + "popstellar/internal/logger" + mocks2 "popstellar/internal/network/socket/mocks" + "popstellar/internal/test/generator" + "testing" +) + +func Test_Handle(t *testing.T) { + log := logger.Logger.With().Str("test", "Handle").Logger() + + hub := mocks.NewHub(t) + messageHandler := mocks.NewMessageHandler(t) + db := mocks.NewRepository(t) + + publishHandler := New(hub, db, messageHandler, log) + + socket := mocks2.NewFakeSocket("0") + + queryID := 0 + channelPath := "/root" + msg := generator.NewNothingMsg(t, "sender", nil) + publishBuf := generator.NewPublishQuery(t, queryID, channelPath, msg) + + // succeed handling the publish + notify new rumor + + messageHandler.On("Handle", channelPath, msg, false).Return(nil).Once() + db.On("AddMessageToMyRumor", msg.MessageID).Return(thresholdMessagesByRumor, nil).Once() + hub.On("NotifyResetRumorSender").Return(nil).Once() + + id, err := publishHandler.Handle(socket, publishBuf) + require.Nil(t, id) + require.NoError(t, err) + + // succeed handling the publish but no notify rumor + + messageHandler.On("Handle", channelPath, msg, false).Return(nil).Once() + db.On("AddMessageToMyRumor", msg.MessageID).Return(thresholdMessagesByRumor-1, nil).Once() + + id, err = publishHandler.Handle(socket, publishBuf) + require.Nil(t, id) + require.NoError(t, err) + + // succeed handling the publish but no rumor because federation channel + + channelPath = "/root/laoID/federation" + publishBuf = generator.NewPublishQuery(t, queryID, channelPath, msg) + + messageHandler.On("Handle", channelPath, msg, false).Return(nil).Once() + + id, err = publishHandler.Handle(socket, publishBuf) + require.Nil(t, id) + require.NoError(t, err) +} diff --git a/be1-go/internal/handler/query/hquery/query.go b/be1-go/internal/handler/query/hquery/query.go index 1f87692b6f..c489e50934 100644 --- a/be1-go/internal/handler/query/hquery/query.go +++ b/be1-go/internal/handler/query/hquery/query.go @@ -12,16 +12,8 @@ type MethodHandler interface { Handle(socket socket.Socket, msg []byte) (*int, error) } -type MethodHandlers struct { - Catchup MethodHandler - GetMessagesbyid MethodHandler - Greetserver MethodHandler - Heartbeat MethodHandler - Publish MethodHandler - Subscribe MethodHandler - Unsubscribe MethodHandler - Rumor MethodHandler -} +// MethodHandlers is map with a handler per method (method : handler) +type MethodHandlers map[string]MethodHandler type Handler struct { handlers MethodHandlers @@ -43,29 +35,13 @@ func (h *Handler) Handle(socket socket.Socket, msg []byte) error { return errors.NewJsonUnmarshalError(err.Error()) } - var id *int = nil - - switch queryBase.Method { - case mquery.MethodCatchUp: - id, err = h.handlers.Catchup.Handle(socket, msg) - case mquery.MethodGetMessagesById: - id, err = h.handlers.GetMessagesbyid.Handle(socket, msg) - case mquery.MethodGreetServer: - _, err = h.handlers.Greetserver.Handle(socket, msg) - case mquery.MethodHeartbeat: - _, err = h.handlers.Heartbeat.Handle(socket, msg) - case mquery.MethodPublish: - id, err = h.handlers.Publish.Handle(socket, msg) - case mquery.MethodSubscribe: - id, err = h.handlers.Subscribe.Handle(socket, msg) - case mquery.MethodUnsubscribe: - id, err = h.handlers.Unsubscribe.Handle(socket, msg) - case mquery.MethodRumor: - id, err = h.handlers.Rumor.Handle(socket, msg) - default: - err = errors.NewInvalidActionError("unexpected method: '%s'", queryBase.Method) + handler, ok := h.handlers[queryBase.Method] + if !ok { + return errors.NewInvalidActionError("unexpected method: '%s'", queryBase.Method) } + id, err := handler.Handle(socket, msg) + if err != nil && id != nil { socket.SendPopError(id, err) } diff --git a/be1-go/internal/handler/query/hquery/query_test.go b/be1-go/internal/handler/query/hquery/query_test.go index 8bccd725db..357f87377b 100644 --- a/be1-go/internal/handler/query/hquery/query_test.go +++ b/be1-go/internal/handler/query/hquery/query_test.go @@ -4,59 +4,60 @@ import ( "github.com/rs/zerolog" "github.com/stretchr/testify/require" "io" + "popstellar/internal/errors" "popstellar/internal/handler/query/hquery/mocks" + "popstellar/internal/handler/query/mquery" mocks2 "popstellar/internal/network/socket/mocks" "popstellar/internal/test/generator" "testing" ) func Test_handleQuery(t *testing.T) { - type input struct { - name string - message []byte - isError bool - contains string - } - methodHandler := mocks.NewMethodHandler(t) - methodHandlers := MethodHandlers{ - Catchup: methodHandler, - GetMessagesbyid: methodHandler, - Greetserver: methodHandler, - Heartbeat: methodHandler, - Publish: methodHandler, - Subscribe: methodHandler, - Unsubscribe: methodHandler, - Rumor: methodHandler, - } - - handler := New(methodHandlers, zerolog.New(io.Discard)) - - args := make([]input, 0) - - // Test 1: failed to handled popquery because unknown method - - msg := generator.NewNothingQuery(t, 999) - - args = append(args, input{ - name: "Test 1", - message: msg, - isError: true, - contains: "unexpected method", - }) - - // run all tests - - for _, arg := range args { - t.Run(arg.name, func(t *testing.T) { - fakeSocket := mocks2.FakeSocket{Id: "fakesocket"} - err := handler.Handle(&fakeSocket, arg.message) - if arg.isError { - require.Error(t, err, arg.contains) - } else { - require.NoError(t, err) - } - }) - } + methodHandlers := make(MethodHandlers) + methodHandlers[mquery.MethodSubscribe] = methodHandler + + queryHandler := New(methodHandlers, zerolog.New(io.Discard)) + + // succeed to handled known query method without any error + + queryID := 0 + + fakeSocket := mocks2.NewFakeSocket("0") + msg := generator.NewSubscribeQuery(t, queryID, "/root") + + methodHandler.On("Handle", fakeSocket, msg).Return(&queryID, nil).Once() + + err := queryHandler.Handle(fakeSocket, msg) + require.NoError(t, err) + + // failed to handled known query method + send error to socket + + queryID = 0 + contains := "Nop" + + fakeSocket = mocks2.NewFakeSocket("0") + msg = generator.NewSubscribeQuery(t, queryID, "/root") + + methodHandler.On("Handle", fakeSocket, msg).Return(&queryID, errors.NewInvalidMessageFieldError(contains)).Once() + + err = queryHandler.Handle(fakeSocket, msg) + require.Error(t, err) + require.Contains(t, err.Error(), contains) + require.Error(t, fakeSocket.Err) + require.Contains(t, fakeSocket.Err.Error(), contains) + + // failed to handled query because unknown method + + queryID = 0 + contains = "unexpected method" + + fakeSocket = mocks2.NewFakeSocket("0") + msg = generator.NewNothingQuery(t, queryID) + + err = queryHandler.Handle(fakeSocket, msg) + require.Error(t, err) + require.Contains(t, err.Error(), contains) + } diff --git a/be1-go/internal/hub/hub.go b/be1-go/internal/hub/hub.go index de378158f8..f03e3ae31c 100644 --- a/be1-go/internal/hub/hub.go +++ b/be1-go/internal/hub/hub.go @@ -9,6 +9,7 @@ import ( "popstellar/internal/database/sqlite" poperrors "popstellar/internal/errors" "popstellar/internal/handler/answer/hanswer" + "popstellar/internal/handler/channel" "popstellar/internal/handler/channel/chirp/hchirp" "popstellar/internal/handler/channel/coin/hcoin" "popstellar/internal/handler/channel/election/helection" @@ -156,19 +157,18 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st return nil, err } - // Create the message data handlers - dataHandlers := hmessage.DataHandlers{ - Root: hroot.New(conf, &db, subs, peers, schemaValidator, log), - Lao: hlao.New(conf, subs, &db, schemaValidator, log), - Election: helection.New(conf, subs, &db, schemaValidator, log), - Chirp: hchirp.New(conf, subs, &db, schemaValidator, log), - Reaction: hreaction.New(subs, &db, schemaValidator, log), - Coin: hcoin.New(subs, &db, schemaValidator, log), - Federation: hfederation.New(hubParams, subs, &db, schemaValidator, log), - } + // Create the message channel handlers + channelHandlers := make(hmessage.ChannelHandlers) + channelHandlers[channel.RootObject] = hroot.New(conf, &db, subs, peers, schemaValidator, log) + channelHandlers[channel.LAOObject] = hlao.New(conf, subs, &db, schemaValidator, log) + channelHandlers[channel.ElectionObject] = helection.New(conf, subs, &db, schemaValidator, log) + channelHandlers[channel.ChirpObject] = hchirp.New(conf, subs, &db, schemaValidator, log) + channelHandlers[channel.ReactionObject] = hreaction.New(subs, &db, schemaValidator, log) + channelHandlers[channel.CoinObject] = hcoin.New(subs, &db, schemaValidator, log) + channelHandlers[channel.FederationObject] = hfederation.New(hubParams, subs, &db, schemaValidator, log) // Create the message handler - msgHandler := hmessage.New(&db, dataHandlers, log) + msgHandler := hmessage.New(&db, channelHandlers, log) // Create the greetserver handler greetserverHandler := hgreetserver.New(conf, peers, log) @@ -177,16 +177,17 @@ func New(dbPath string, ownerPubKey kyber.Point, clientAddress, serverAddress st rumorHandler := hrumor.New(queries, sockets, &db, msgHandler, log) // Create the query handler - qHandler := hquery.New(hquery.MethodHandlers{ - Catchup: hcatchup.New(&db, log), - GetMessagesbyid: hgetmessagesbyid.New(&db, log), - Greetserver: greetserverHandler, - Heartbeat: hheartbeat.New(queries, &db, log), - Publish: hpublish.New(hubParams, &db, msgHandler, log), - Subscribe: hsubscribe.New(subs, log), - Unsubscribe: hunsubscribe.New(subs, log), - Rumor: rumorHandler, - }, log) + methodHandlers := make(hquery.MethodHandlers) + methodHandlers[mquery.MethodCatchUp] = hcatchup.New(&db, log) + methodHandlers[mquery.MethodGetMessagesById] = hgetmessagesbyid.New(&db, log) + methodHandlers[mquery.MethodGreetServer] = greetserverHandler + methodHandlers[mquery.MethodHeartbeat] = hheartbeat.New(queries, &db, log) + methodHandlers[mquery.MethodPublish] = hpublish.New(hubParams, &db, msgHandler, log) + methodHandlers[mquery.MethodSubscribe] = hsubscribe.New(subs, log) + methodHandlers[mquery.MethodUnsubscribe] = hunsubscribe.New(subs, log) + methodHandlers[mquery.MethodRumor] = rumorHandler + + qHandler := hquery.New(methodHandlers, log) // Create the answer handler aHandler := hanswer.New(queries, hanswer.Handlers{ diff --git a/be1-go/internal/network/socket/mocks/socket.go b/be1-go/internal/network/socket/mocks/socket.go index 28fbb4ed58..e61873605b 100644 --- a/be1-go/internal/network/socket/mocks/socket.go +++ b/be1-go/internal/network/socket/mocks/socket.go @@ -43,6 +43,11 @@ func (f *FakeSocket) SendError(_ *int, err error) { f.Err = err } +// SendPopError implements socket.Socket +func (f *FakeSocket) SendPopError(_ *int, err error) { + f.Err = err +} + func (f *FakeSocket) ID() string { return f.Id }