192 lines
4.3 KiB
Go
192 lines
4.3 KiB
Go
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")
|
|
}
|
|
}
|