[BE1] Increase usability of module with handlers

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)
 }

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)

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)
 	}