[BE1] Add a simple buffer to rumor

be1-go/internal/database/sqlite/query.go

@@ -141,28 +141,39 @@ func (s *SQLite) GetParamsForGetMessageByID(params map[string][]string) (map[str
 	return missingIDs, nil
 }
 
-func (s *SQLite) CheckRumor(senderID string, rumorID int) (bool, error) {
+func (s *SQLite) CheckRumor(senderID string, rumorID int) (bool, bool, error) {
 	dbLock.Lock()
 	defer dbLock.Unlock()
 
+	s.log.Info().Msgf("trying to check rumor %s:%d", senderID, rumorID)
+
 	var id int
 	if rumorID == 0 {
 		err := s.database.QueryRow(selectAnyRumor, senderID).Scan(&id)
 		if err != nil && !errors.Is(err, sql.ErrNoRows) {
-			return false, poperrors.NewDatabaseSelectErrorMsg(err.Error())
+			return false, false, poperrors.NewDatabaseSelectErrorMsg(err.Error())
 		} else if errors.Is(err, sql.ErrNoRows) {
-			return true, nil
+			return true, false, nil
 		}
-		return false, nil
+		return false, true, nil
 	}
 
 	err := s.database.QueryRow(selectLastRumor, senderID).Scan(&id)
 	if err != nil && !errors.Is(err, sql.ErrNoRows) {
-		return false, poperrors.NewDatabaseSelectErrorMsg(err.Error())
+		s.log.Error().Err(err).Msg("")
+		return false, false, poperrors.NewDatabaseSelectErrorMsg(err.Error())
 	} else if errors.Is(err, sql.ErrNoRows) {
-		return false, nil
+		s.log.Error().Err(err).Msg("")
+		return false, false, nil
 	}
-	return id == rumorID-1, nil
+
+	s.log.Debug().Msgf("ID = %d", id)
+
+	alreadyHas := id >= rumorID
+
+	valid := id == rumorID-1
+
+	return valid, alreadyHas, nil
 }
 
 //======================================================================================================================

be1-go/internal/database/sqlite/sqlite_const.go

@@ -332,7 +332,7 @@ const (
 		                                       WHERE sender = (SELECT publicKey FROM key WHERE channelPath = ?)))`
 
 	selectMyRumorInfos = `SELECT max(ID), sender FROM rumor WHERE sender = (SELECT publicKey FROM key WHERE channelPath = ?)`
-	selectLastRumor    = `SELECT max(ID) FROM rumor WHERE sender = ?`
+	selectLastRumor    = `SELECT ID FROM rumor WHERE sender = ? ORDER BY ID DESC LIMIT 1;`
 
 	selectValidFederationChallenges = `
 	SELECT messageData

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)