From c362847ff5f385499453052da83964b10cd50de2 Mon Sep 17 00:00:00 2001 From: Hermes Bot Date: Tue, 14 Jul 2026 14:29:19 +0200 Subject: [PATCH] M4: Persistenz - JSON-Dateispeicher mit Load/Save, Konvertierung zu/from Logik --- internal/persistenz/persistenz.go | 89 ++++++++++++ internal/persistenz/persistenz_test.go | 191 +++++++++++++++++++++++++ 2 files changed, 280 insertions(+) create mode 100644 internal/persistenz/persistenz.go create mode 100644 internal/persistenz/persistenz_test.go diff --git a/internal/persistenz/persistenz.go b/internal/persistenz/persistenz.go new file mode 100644 index 0000000..504ecbf --- /dev/null +++ b/internal/persistenz/persistenz.go @@ -0,0 +1,89 @@ +// Package persistenz provides file-based persistence for the scoreboard state. +package persistenz + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + + "git.jlserver.de/goSportpunktetafel/internal/logik" +) + +// State represents the persisted scoreboard state. +type State struct { + CurrentRound int `json:"current_round"` + Rounds []logik.Round `json:"rounds"` + RedScore int `json:"red_score"` + GreenScore int `json:"green_score"` +} + +// Manager handles loading and saving of scoreboard state. +type Manager struct { + stateFile string +} + +// NewManager creates a new state manager. +func NewManager(dataDir string) (*Manager, error) { + // Ensure data directory exists + if err := os.MkdirAll(dataDir, 0755); err != nil { + return nil, fmt.Errorf("failed to create data directory %s: %w", dataDir, err) + } + + return &Manager{ + stateFile: filepath.Join(dataDir, "state.json"), + }, nil +} + +// Load loads the scoreboard state from disk. +// Returns nil if no state file exists. +func (m *Manager) Load() (*State, error) { + data, err := os.ReadFile(m.stateFile) + if err != nil { + if os.IsNotExist(err) { + return nil, nil // No state file yet + } + return nil, fmt.Errorf("failed to read state file: %w", err) + } + + var state State + if err := json.Unmarshal(data, &state); err != nil { + return nil, fmt.Errorf("failed to parse state file: %w", err) + } + + return &state, nil +} + +// Save saves the current scoreboard state to disk. +func (m *Manager) Save(state *State) error { + data, err := json.MarshalIndent(state, "", " ") + if err != nil { + return fmt.Errorf("failed to marshal state: %w", err) + } + + if err := os.WriteFile(m.stateFile, data, 0644); err != nil { + return fmt.Errorf("failed to write state file: %w", err) + } + + return nil +} + +// StateToLogik converts a persisted State to a logik.Scoreboard. +func StateToLogik(state *State) *logik.Scoreboard { + return &logik.Scoreboard{ + CurrentRound: state.CurrentRound, + Rounds: state.Rounds, + RedScore: state.RedScore, + GreenScore: state.GreenScore, + } +} + +// LogikToState converts a logik.Scoreboard to a persisted State. +func LogikToState(sb *logik.Scoreboard) *State { + return &State{ + CurrentRound: sb.CurrentRound, + Rounds: sb.Rounds, + RedScore: sb.RedScore, + GreenScore: sb.GreenScore, + } +} diff --git a/internal/persistenz/persistenz_test.go b/internal/persistenz/persistenz_test.go new file mode 100644 index 0000000..25fc312 --- /dev/null +++ b/internal/persistenz/persistenz_test.go @@ -0,0 +1,191 @@ +package persistenz + +import ( + "os" + "path/filepath" + "testing" + + "git.jlserver.de/goSportpunktetafel/internal/logik" +) + +func TestLoad_NoFile(t *testing.T) { + tmpDir := t.TempDir() + m, err := NewManager(tmpDir) + if err != nil { + t.Fatalf("NewManager() error = %v", err) + } + + state, err := m.Load() + if err != nil { + t.Fatalf("Load() error = %v", err) + } + if state != nil { + t.Errorf("Load() = %+v, want nil", state) + } +} + +func TestSaveAndLoad(t *testing.T) { + tmpDir := t.TempDir() + m, err := NewManager(tmpDir) + if err != nil { + t.Fatalf("NewManager() error = %v", err) + } + + // Create and save state + state := &State{ + CurrentRound: 3, + Rounds: []logik.Round{ + {Red: 2, Green: 1}, + {Red: 0, Green: 4}, + }, + RedScore: 1, + GreenScore: 0, + } + + if err := m.Save(state); err != nil { + t.Fatalf("Save() error = %v", err) + } + + // Load it back + loaded, err := m.Load() + if err != nil { + t.Fatalf("Load() error = %v", err) + } + if loaded == nil { + t.Fatal("Load() returned nil") + } + + if loaded.CurrentRound != state.CurrentRound { + t.Errorf("CurrentRound = %d, want %d", loaded.CurrentRound, state.CurrentRound) + } + if loaded.RedScore != state.RedScore { + t.Errorf("RedScore = %d, want %d", loaded.RedScore, state.RedScore) + } + if loaded.GreenScore != state.GreenScore { + t.Errorf("GreenScore = %d, want %d", loaded.GreenScore, state.GreenScore) + } + if len(loaded.Rounds) != len(state.Rounds) { + t.Fatalf("len(Rounds) = %d, want %d", len(loaded.Rounds), len(state.Rounds)) + } + for i, r := range state.Rounds { + if loaded.Rounds[i].Red != r.Red { + t.Errorf("Rounds[%d].Red = %d, want %d", i, loaded.Rounds[i].Red, r.Red) + } + if loaded.Rounds[i].Green != r.Green { + t.Errorf("Rounds[%d].Green = %d, want %d", i, loaded.Rounds[i].Green, r.Green) + } + } +} + +func TestStateFileExists(t *testing.T) { + tmpDir := t.TempDir() + m, err := NewManager(tmpDir) + if err != nil { + t.Fatalf("NewManager() error = %v", err) + } + + state := &State{CurrentRound: 1, RedScore: 0, GreenScore: 0} + if err := m.Save(state); err != nil { + t.Fatalf("Save() error = %v", err) + } + + // Check file exists + info, err := os.Stat(m.stateFile) + if err != nil { + t.Fatalf("state file does not exist: %v", err) + } + if info.IsDir() { + t.Error("state file is a directory") + } + if filepath.Base(m.stateFile) != "state.json" { + t.Errorf("state file name = %s, want state.json", filepath.Base(m.stateFile)) + } +} + +func TestStateToLogik(t *testing.T) { + state := &State{ + CurrentRound: 2, + Rounds: []logik.Round{ + {Red: 3, Green: 1}, + }, + RedScore: 0, + GreenScore: 2, + } + + sb := StateToLogik(state) + + if sb.CurrentRound != state.CurrentRound { + t.Errorf("CurrentRound = %d, want %d", sb.CurrentRound, state.CurrentRound) + } + if sb.RedScore != state.RedScore { + t.Errorf("RedScore = %d, want %d", sb.RedScore, state.RedScore) + } + if sb.GreenScore != state.GreenScore { + t.Errorf("GreenScore = %d, want %d", sb.GreenScore, state.GreenScore) + } +} + +func TestLogikToState(t *testing.T) { + sb := &logik.Scoreboard{ + CurrentRound: 5, + Rounds: []logik.Round{ + {Red: 1, Green: 0}, + {Red: 0, Green: 2}, + {Red: 3, Green: 3}, + }, + RedScore: 2, + GreenScore: 1, + } + + state := LogikToState(sb) + + if state.CurrentRound != sb.CurrentRound { + t.Errorf("CurrentRound = %d, want %d", state.CurrentRound, sb.CurrentRound) + } + if state.RedScore != sb.RedScore { + t.Errorf("RedScore = %d, want %d", state.RedScore, sb.RedScore) + } + if state.GreenScore != sb.GreenScore { + t.Errorf("GreenScore = %d, want %d", state.GreenScore, sb.GreenScore) + } +} + +func TestNewManager_CreatesDirectory(t *testing.T) { + tmpDir := t.TempDir() + newDir := filepath.Join(tmpDir, "data", "subdir") + + m, err := NewManager(newDir) + if err != nil { + t.Fatalf("NewManager() error = %v", err) + } + if m == nil { + t.Fatal("Manager is nil") + } + + // Check directory was created + info, err := os.Stat(newDir) + if err != nil { + t.Fatalf("Directory was not created: %v", err) + } + if !info.IsDir() { + t.Error("Created path is not a directory") + } +} + +func TestLoad_InvalidJSON(t *testing.T) { + tmpDir := t.TempDir() + m, err := NewManager(tmpDir) + if err != nil { + t.Fatalf("NewManager() error = %v", err) + } + + // Write invalid JSON + if err := os.WriteFile(m.stateFile, []byte("not valid json{"), 0644); err != nil { + t.Fatalf("Failed to write test file: %v", err) + } + + _, err = m.Load() + if err == nil { + t.Errorf("Load() should return error for invalid JSON") + } +}