dyzur-bot/service_test.go

package dyzurbot

import (
	"context"
	"errors"
	"fmt"
	"path/filepath"
	"testing"
	"time"
)

func TestLoadConfigDefaults(t *testing.T) {
	t.Setenv("GOOGLE_SHEETS_ID", "sheet-123")
	t.Setenv("SHEET_RANGE", "")
	t.Setenv("ROTA_CACHE_PATH", "")
	t.Setenv("SYNC_INTERVAL", "")

	cfg, err := LoadConfig()
	if err != nil {
		t.Fatalf("LoadConfig: %v", err)
	}
	if cfg.SpreadsheetID != "sheet-123" {
		t.Errorf("SpreadsheetID: got %q", cfg.SpreadsheetID)
	}
	wantRange := fmt.Sprintf("%d!A1:F100", time.Now().Year())
	if cfg.SheetRange != wantRange {
		t.Errorf("SheetRange default: got %q, want %q", cfg.SheetRange, wantRange)
	}
	if cfg.CachePath != "rota.json" {
		t.Errorf("CachePath default: got %q", cfg.CachePath)
	}
	if cfg.SyncInterval != 30*time.Minute {
		t.Errorf("SyncInterval default: got %v", cfg.SyncInterval)
	}
}

func TestLoadConfigRequiresSpreadsheetID(t *testing.T) {
	t.Setenv("GOOGLE_SHEETS_ID", "")
	if _, err := LoadConfig(); err == nil {
		t.Fatal("expected error when GOOGLE_SHEETS_ID is missing")
	}
}

func TestLoadConfigRejectsBadInterval(t *testing.T) {
	t.Setenv("GOOGLE_SHEETS_ID", "sheet-123")
	t.Setenv("SYNC_INTERVAL", "not-a-duration")
	if _, err := LoadConfig(); err == nil {
		t.Fatal("expected error for unparseable SYNC_INTERVAL")
	}
}

func TestLoadConfigRejectsNonPositiveInterval(t *testing.T) {
	t.Setenv("GOOGLE_SHEETS_ID", "sheet-123")
	t.Setenv("SYNC_INTERVAL", "0s")
	if _, err := LoadConfig(); err == nil {
		t.Fatal("expected error for non-positive SYNC_INTERVAL")
	}
}

func TestLoadReminderConfigDisabled(t *testing.T) {
	t.Setenv("GROUP_CHAT_ID", "")
	r, err := loadReminderConfig()
	if err != nil {
		t.Fatalf("loadReminderConfig: %v", err)
	}
	if r != nil {
		t.Errorf("expected nil (disabled), got %+v", r)
	}
}

func TestLoadReminderConfigParses(t *testing.T) {
	// Negative chat ID guards against ParseInt being swapped for ParseUint:
	// Telegram group IDs are negative.
	t.Setenv("GROUP_CHAT_ID", "-5572351978")
	t.Setenv("REMINDER_WEEKDAY", "Friday")
	t.Setenv("REMINDER_HOUR", "18")
	t.Setenv("DUTY_AHEAD_DAYS", "7")

	r, err := loadReminderConfig()
	if err != nil {
		t.Fatalf("loadReminderConfig: %v", err)
	}
	if r == nil {
		t.Fatal("expected a config, got nil")
	}
	if r.ChatID != -5572351978 {
		t.Errorf("ChatID = %d, want -5572351978", r.ChatID)
	}
	if r.Weekday != time.Friday || r.Hour != 18 || r.AheadDays != 7 {
		t.Errorf("got %v %d ahead=%d, want Friday 18 ahead=7", r.Weekday, r.Hour, r.AheadDays)
	}
	if r.Loc == nil || r.Loc.String() != "Europe/Warsaw" {
		t.Errorf("Loc = %v, want Europe/Warsaw", r.Loc)
	}
}

func TestLoadReminderConfigDefaults(t *testing.T) {
	t.Setenv("GROUP_CHAT_ID", "42")
	t.Setenv("REMINDER_WEEKDAY", "")
	t.Setenv("REMINDER_HOUR", "")
	t.Setenv("DUTY_AHEAD_DAYS", "")

	r, err := loadReminderConfig()
	if err != nil {
		t.Fatalf("loadReminderConfig: %v", err)
	}
	if r.Weekday != time.Monday || r.Hour != 9 || r.AheadDays != 14 {
		t.Errorf("defaults: got %v %d ahead=%d, want Monday 9 ahead=14", r.Weekday, r.Hour, r.AheadDays)
	}
}

func TestLoadReminderConfigRejects(t *testing.T) {
	tests := []struct {
		name string
		key  string
		val  string
	}{
		{"bad chat id", "GROUP_CHAT_ID", "not-a-number"},
		{"hour too high", "REMINDER_HOUR", "24"},
		{"hour negative", "REMINDER_HOUR", "-1"},
		{"ahead negative", "DUTY_AHEAD_DAYS", "-1"},
		{"bad weekday", "REMINDER_WEEKDAY", "Funday"},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Setenv("GROUP_CHAT_ID", "42") // enabled by default; case may override
			t.Setenv("REMINDER_WEEKDAY", "Monday")
			t.Setenv("REMINDER_HOUR", "9")
			t.Setenv("DUTY_AHEAD_DAYS", "14")
			t.Setenv(tc.key, tc.val)

			if _, err := loadReminderConfig(); err == nil {
				t.Fatalf("expected error for %s=%q", tc.key, tc.val)
			}
		})
	}
}

func TestSyncSuccessReplacesCache(t *testing.T) {
	store := NewStore(filepath.Join(t.TempDir(), "rota.json"))
	fixed := time.Date(2026, 6, 17, 20, 0, 0, 0, time.UTC)

	sy := NewSyncer(store, func(context.Context) (Rota, error) { return sampleRota(), nil })
	sy.now = func() time.Time { return fixed }

	if err := sy.Sync(context.Background()); err != nil {
		t.Fatalf("Sync: %v", err)
	}
	rota, ts := store.Snapshot()
	if len(rota.People) != 1 || !ts.Equal(fixed) {
		t.Errorf("cache not updated: people=%d ts=%v", len(rota.People), ts)
	}
}

func TestSyncFailurePreservesCache(t *testing.T) {
	store := NewStore(filepath.Join(t.TempDir(), "rota.json"))
	good := time.Date(2026, 6, 17, 20, 0, 0, 0, time.UTC)
	if err := store.Replace(sampleRota(), good); err != nil {
		t.Fatalf("seed Replace: %v", err)
	}

	wantErr := errors.New("sheet unreachable")
	sy := NewSyncer(store, func(context.Context) (Rota, error) { return Rota{}, wantErr })

	if err := sy.Sync(context.Background()); !errors.Is(err, wantErr) {
		t.Fatalf("Sync error: got %v, want %v", err, wantErr)
	}
	rota, ts := store.Snapshot()
	if len(rota.People) != 1 || !ts.Equal(good) {
		t.Errorf("cache should be untouched: people=%d ts=%v", len(rota.People), ts)
	}
}