test(backend, logger): complete test of errors and remove pull record

Author: JavierRibaldelRio

backend/pkg/logger/logger.go

@@ -26,8 +26,12 @@ type Logger struct {
 	trace zerolog.Logger
 }
 
+/**************
+* HandlerLogger *
+***************/
 var _ abstraction.Logger = &Logger{}
 
+// Used on subloggers to get the current timestamp for folder or file names
 var Timestamp = time.Now()
 
 func (Logger) HandlerName() string { return HandlerName }
@@ -68,7 +72,12 @@ func (logger *Logger) Start() error {
 	for name, sublogger := range logger.subloggers {
 		err := sublogger.Start()
 		if err != nil {
-			logger.trace.Error().Stack().Err(err).Str("subLogger", string(name)).Msg("start sublogger")
+			logger.trace.
+				Error().
+				Stack().
+				Err(err).
+				Str("subLogger", string(name)).
+				Msg("start sublogger")
 			return err
 		}
 	}
@@ -79,25 +88,44 @@ func (logger *Logger) Start() error {
 
 // PushRecord works as a proxy for the PushRecord method of the subloggers
 func (logger *Logger) PushRecord(record abstraction.LoggerRecord) error {
+
 	logger.trace.Trace().Type("record", record).Msg("push")
 	sublogger, ok := logger.subloggers[record.Name()]
 	if !ok {
-		logger.trace.Warn().Type("record", record).Str("name", string(record.Name())).Msg("no sublogger found for record")
+		logger.trace.
+			Warn().
+			Type("record", record).
+			Str("name", string(record.Name())).
+			Msg("no sublogger found for record")
+
 		return ErrLoggerNotFound{record.Name()}
 	}
 
 	return sublogger.PushRecord(record)
 }
 
-// PullRecord works as a proxy for the PullRecord method of the subloggers
+// ! This method should not be used because any of the subloggers has PullRecord implemented
+// // PullRecord works as a proxy for the PullRecord method of the subloggers
 func (logger *Logger) PullRecord(request abstraction.LoggerRequest) (abstraction.LoggerRecord, error) {
-	logger.trace.Trace().Type("request", request).Msg("request")
-	loggerChecked, ok := logger.subloggers[request.Name()]
-	if !ok {
-		logger.trace.Warn().Type("request", request).Str("name", string(request.Name())).Msg("no subloggger found for request")
-		return nil, ErrLoggerNotFound{request.Name()}
-	}
-	return loggerChecked.PullRecord(request)
+
+	panic("PullRecord")
+
+	// logger.trace.
+	// 	Trace().
+	// 	Type("request", request).
+	// 	Msg("request")
+
+	// loggerChecked, ok := logger.subloggers[request.Name()]
+	// if !ok {
+	// 	logger.trace.
+	// 		Warn().
+	// 		Type("request", request).
+	// 		Str("name", string(request.Name())).
+	// 		Msg("no subloggger found for request")
+
+	// 	return nil, ErrLoggerNotFound{request.Name()}
+	// }
+	// return loggerChecked.PullRecord(request)
 }
 
 func (logger *Logger) Stop() error {

backend/pkg/logger/logger_test.go

@@ -1,39 +1,258 @@
 package logger_test
 
 import (
+	"bufio"
+	"path/filepath"
+	"strings"
 	"testing"
+	"time"
 
 	"os"
 
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/abstraction"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/logger"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/logger/data"
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/logger/order"
-	"github.com/HyperloopUPV-H8/h9-backend/pkg/logger/protection"
-	"github.com/HyperloopUPV-H8/h9-backend/pkg/logger/state"
 	"github.com/rs/zerolog"
+
+	dataPacketer "github.com/HyperloopUPV-H8/h9-backend/pkg/transport/packet/data"
 )
 
+func generatLoggerGroup() *logger.Logger {
+
+	return logger.NewLogger(
+		map[abstraction.LoggerName]abstraction.Logger{
+			data.Name:  data.NewLogger(),
+			order.Name: order.NewLogger(),
+		},
+
+		zerolog.
+			New(os.Stdout).
+			With().
+			Timestamp().
+			Logger())
+}
+
+/**
+*
+**/
+
+// mockSublogger minimally implements abstraction.Logger for testing error propagation.
+type mockSublogger struct {
+	startErr error
+}
+
+func (m *mockSublogger) Start() error {
+	return m.startErr
+}
+func (m *mockSublogger) Stop() error {
+	return nil
+}
+func (m *mockSublogger) PushRecord(_ abstraction.LoggerRecord) error {
+	return nil
+}
+func (m *mockSublogger) PullRecord(_ abstraction.LoggerRequest) (abstraction.LoggerRecord, error) {
+	return nil, nil
+}
+func (m *mockSublogger) HandlerName() string { return "mock" }
+
+// mockRecord minimally implements Name() required by logger's PushRecord.
+type mockRecord struct {
+	n abstraction.LoggerName
+}
+
+func (r *mockRecord) Name() abstraction.LoggerName { return r.n }
+
 func TestCreateLoggerGroup(t *testing.T) {
 
 	// logger handler
 	var loggerHandler *logger.Logger
 
 	// Generate logger group
 	t.Run("Create logger group", func(t *testing.T) {
-		protectionSublogger := protection.NewLogger(map[abstraction.BoardId]string{
-			0: "test",
-		})
-		loggerHandler = logger.NewLogger(map[abstraction.LoggerName]abstraction.Logger{
-			data.Name:       data.NewLogger(),
-			order.Name:      order.NewLogger(),
-			protection.Name: protectionSublogger,
-			state.Name:      state.NewLogger(),
-		}, zerolog.New(os.Stdout).With().Timestamp().Logger())
-
-		if err := loggerHandler.Start(); err != nil {
-			t.Error(err)
+
+		loggerHandler = generatLoggerGroup()
+
+		if loggerHandler == nil {
+			t.Errorf("Failed to create logger group")
 		}
+
 	})
 
+	t.Run(" Check Name", func(t *testing.T) {
+
+		if loggerHandler.HandlerName() != "logger" {
+			t.Errorf("Logger HandlerName() incorrect, got: %s, want: %s", loggerHandler.HandlerName(), "logger")
+		}
+	})
+
+}
+
+func TestLoggerGroup_Errors(t *testing.T) {
+	// Logger with empty map → PushRecord should return error (no sublogger)
+	lEmpty := logger.NewLogger(map[abstraction.LoggerName]abstraction.Logger{}, zerolog.New(os.Stdout))
+	err := lEmpty.PushRecord(&mockRecord{n: abstraction.LoggerName("missing")})
+	if err == nil {
+		t.Fatalf("expected error when PushRecord to non-existent sublogger, got nil")
+	}
+
+	// Logger whose sublogger returns error on Start → Start should propagate the error
+	wantErr := os.ErrPermission
+	badMap := map[abstraction.LoggerName]abstraction.Logger{
+		abstraction.LoggerName("bad"): &mockSublogger{startErr: wantErr},
+	}
+	lBad := logger.NewLogger(badMap, zerolog.New(os.Stdout))
+	if err := lBad.Start(); err != wantErr {
+		t.Fatalf("Start did not propagate the expected error. Got: %v, Want: %v", err, wantErr)
+	}
+}
+
+func TestStartAndStopLoggerGroup(t *testing.T) {
+
+	// logger handler
+	loggerHandler := generatLoggerGroup()
+
+	t.Run("Start logger group", func(t *testing.T) {
+		err := loggerHandler.Start()
+		if err != nil {
+			t.Errorf("Failed to start logger group: %s", err)
+		}
+	})
+
+	// previous line
+
+	var previousLine string
+
+	// Try to write a log to check if the logger is running
+
+	t.Run("Push Record to logger group", func(t *testing.T) {
+
+		// Data
+		dataPacket := dataPacketer.NewPacketWithValues(
+			0,
+			map[dataPacketer.ValueName]dataPacketer.Value{
+				"test": dataPacketer.NewBooleanValue(true),
+			},
+			map[dataPacketer.ValueName]bool{
+				"test": true,
+			})
+		dataPacketTime := time.Now()
+		dataRecord := &data.Record{
+			Packet:    dataPacket,
+			From:      "test",
+			To:        "test",
+			Timestamp: dataPacketTime,
+		}
+		loggerHandler.PushRecord(dataRecord)
+
+		// Read file to ensure it was successfully written
+
+		filePath := filepath.Join("logger", logger.Timestamp.Format(logger.TimestampFormat), "data", "TEST", "test.csv")
+
+		time.Sleep(2 * time.Second) // small wait to stabilize
+
+		_, err := os.Stat(filePath)
+		if os.IsNotExist(err) {
+			t.Errorf("Failed to write log to file: %s", err)
+		}
+
+		// Look last line of the file
+		file, err := os.Open(filePath)
+		if err != nil {
+			t.Errorf("Failed to open log file: %s", err)
+		}
+		defer file.Close()
+
+		var lastLine string
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			lastLine = scanner.Text()
+		}
+
+		line := strings.TrimSpace(string(lastLine))
+		if line == "" {
+			t.Fatalf("file %s is empty", filePath)
+		}
+
+		// split the line by commas
+		fields := strings.Split(line, ",")
+		if len(fields) < 3 {
+			t.Fatalf("CSV line has fewer than 3 fields: %s", line)
+		}
+
+		// check content
+		if fields[1] != "test" {
+			t.Errorf("Incorrect Packet ID, got: %s, want: %s", fields[1], "test")
+		}
+
+		if fields[2] != "test" {
+			t.Errorf("Incorrect Packet ID, got: %s, want: %s", fields[2], "test")
+		}
+
+		if fields[3] != "true" {
+			t.Errorf("Incorrect Packet Value for 'test', got: %s, want: %s", fields[3], "true")
+		}
+
+		previousLine = line
+
+	})
+
+	t.Run("Stop logger group", func(t *testing.T) {
+		err := loggerHandler.Stop()
+		if err != nil {
+			t.Errorf("Failed to stop logger group: %s", err)
+		}
+	})
+
+	t.Run("Push Record when stopped", func(t *testing.T) {
+
+		// Data
+		dataPacket := dataPacketer.NewPacketWithValues(
+			0,
+			map[dataPacketer.ValueName]dataPacketer.Value{
+				"test": dataPacketer.NewBooleanValue(true),
+			},
+			map[dataPacketer.ValueName]bool{
+				"test": true,
+			})
+		dataPacketTime := time.Now()
+		dataRecord := &data.Record{
+			Packet:    dataPacket,
+			From:      "test",
+			To:        "test",
+			Timestamp: dataPacketTime,
+		}
+		loggerHandler.PushRecord(dataRecord)
+
+		// Read file to ensure it was successfully written
+
+		filePath := filepath.Join("logger", logger.Timestamp.Format(logger.TimestampFormat), "data", "TEST", "test.csv")
+
+		time.Sleep(2 * time.Second) // small wait to stabilize
+
+		_, err := os.Stat(filePath)
+		if os.IsNotExist(err) {
+			t.Errorf("Failed to write log to file: %s", err)
+		}
+
+		// Look last line of the file
+		file, err := os.Open(filePath)
+		if err != nil {
+			t.Errorf("Failed to open log file: %s", err)
+		}
+		defer file.Close()
+
+		var lastLine string
+		scanner := bufio.NewScanner(file)
+		for scanner.Scan() {
+			lastLine = scanner.Text()
+		}
+
+		line := strings.TrimSpace(string(lastLine))
+
+		if line != previousLine {
+			t.Errorf("Logger wrote a log when stopped, got: %s, want: %s", line, previousLine)
+		}
+
+	})
 }