nexarch/mail/internal/imap/protolog_test.go

package imap

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"log/slog"
	"net"
	"strings"
	"testing"
	"time"

	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protoguard"
	"gitea.perlbach24.de/scripte/nexarch/mail/internal/protolog"
)

func startLoggedTestServer(t *testing.T, logger *slog.Logger) (addr string, stop func()) {
	t.Helper()
	auth := fakeAuthenticator{users: map[string]string{"alice": "geheim123"}}
	store := fakeMailboxStore{mailboxes: map[string][]Message{
		"INBOX": {{SequenceNumber: 1, UID: 101, Flags: []string{}}},
	}}
	srv := NewServerWithGuardTLSAndLogger(auth, store, protoguard.DefaultConfig(), nil, logger)

	listener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("listener: %v", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	done := make(chan struct{})
	go func() {
		_ = srv.Serve(ctx, listener)
		close(done)
	}()
	return listener.Addr().String(), func() {
		cancel()
		<-done
	}
}

func runFullSession(t *testing.T, addr string) {
	t.Helper()
	conn, err := net.DialTimeout("tcp", addr, 2*time.Second)
	if err != nil {
		t.Fatalf("dial: %v", err)
	}
	defer func() { _ = conn.Close() }()
	reader := bufio.NewReader(conn)
	_, _ = reader.ReadString('\n')
	sendTaggedOn(t, conn, reader, "A1", "LOGIN alice geheim123")
	sendTaggedOn(t, conn, reader, "A2", "SELECT INBOX")
	sendTaggedOn(t, conn, reader, "A3", "LOGOUT")
}

// TestProtolog_RedactsCredentialsInRealSessionLog ist die geforderte
// Pflichtprüfung 1 (ING-08) gegen den echten, laufenden IMAP-Server.
func TestProtolog_RedactsCredentialsInRealSessionLog(t *testing.T) {
	var buf bytes.Buffer
	logger := slog.New(slog.NewJSONHandler(&buf, nil))
	addr, stop := startLoggedTestServer(t, logger)
	defer stop()

	runFullSession(t, addr)

	logged := buf.String()
	if strings.Contains(logged, "geheim123") {
		t.Fatalf("passwort im klartext im log gefunden:\n%s", logged)
	}
	if !strings.Contains(logged, "LOGIN [REDACTED]") {
		t.Fatalf("erwartete redigierten LOGIN-eintrag im log, habe:\n%s", logged)
	}
}

// TestProtolog_SessionFullyReconstructableByCorrelationID ist die
// geforderte Pflichtprüfung 2 (ING-08).
func TestProtolog_SessionFullyReconstructableByCorrelationID(t *testing.T) {
	var buf bytes.Buffer
	logger := slog.New(slog.NewJSONHandler(&buf, nil))
	addr, stop := startLoggedTestServer(t, logger)
	defer stop()

	runFullSession(t, addr)
	runFullSession(t, addr)

	firstLine := strings.SplitN(buf.String(), "\n", 2)[0]
	var raw map[string]any
	if err := json.Unmarshal([]byte(firstLine), &raw); err != nil {
		t.Fatalf("erste logzeile parsen: %v", err)
	}
	firstID, _ := raw["correlation_id"].(string)
	if firstID == "" {
		t.Fatalf("keine correlation_id in erster logzeile: %s", firstLine)
	}

	entries, err := protolog.Reconstruct(bytes.NewReader(buf.Bytes()), firstID)
	if err != nil {
		t.Fatalf("Reconstruct: %v", err)
	}
	// session_start, 3 kommandos (LOGIN/SELECT/LOGOUT), session_end.
	if len(entries) != 5 {
		t.Fatalf("erwartete 5 lückenlose einträge für die session, habe %d: %+v", len(entries), entries)
	}
	if entries[0].Msg != "session_start" || entries[len(entries)-1].Msg != "session_end" {
		t.Fatalf("session nicht lückenlos rekonstruierbar: %+v", entries)
	}
}

// TestProtolog_LoggingDoesNotRelevantlyImpactThroughput ist die
// geforderte Pflichtprüfung 3 (ING-08).
func TestProtolog_LoggingDoesNotRelevantlyImpactThroughput(t *testing.T) {
	const sessions = 100

	addrOff, stopOff := startLoggedTestServer(t, nil)
	startOff := time.Now()
	for i := 0; i < sessions; i++ {
		runFullSession(t, addrOff)
	}
	durationOff := time.Since(startOff)
	stopOff()

	var buf bytes.Buffer
	logger := slog.New(slog.NewJSONHandler(&buf, nil))
	addrOn, stopOn := startLoggedTestServer(t, logger)
	startOn := time.Now()
	for i := 0; i < sessions; i++ {
		runFullSession(t, addrOn)
	}
	durationOn := time.Since(startOn)
	stopOn()

	if durationOn > 3*durationOff+5*time.Millisecond {
		t.Fatalf("logging verlangsamt durchsatz relevant: ohne=%v, mit=%v", durationOff, durationOn)
	}
}