jellybit/internal/config/config_test.go

package config

import (
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

// validCfg возвращает минимально валидный конфиг поверх Default() с медиа-путями
// во временном каталоге (существуют как директории).
func validCfg(t *testing.T) *Config {
	t.Helper()
	dir := t.TempDir()
	c := Default()
	c.QBittorrent.Password = "secret"
	c.Paths.Downloads = filepath.Join(dir, "downloads")
	c.Paths.Movies = filepath.Join(dir, "movies")
	c.Paths.Series = filepath.Join(dir, "series")
	for _, p := range []string{c.Paths.Downloads, c.Paths.Movies, c.Paths.Series} {
		if err := os.MkdirAll(p, 0o755); err != nil {
			t.Fatalf("mkdir %s: %v", p, err)
		}
	}
	// LLM по умолчанию без base_url — секция выключена, api_key не требуется.
	c.LLM.BaseURL = ""
	return c
}

func TestValidate_OK(t *testing.T) {
	if err := validCfg(t).validate(); err != nil {
		t.Fatalf("ожидался валидный конфиг, got %v", err)
	}
}

// TestValidate_NoQBittorrentPassword — пустой пароль qBittorrent валиден:
// клиент может работать без аутентификации (обход авторизации для доверенной
// подсети).
func TestValidate_NoQBittorrentPassword(t *testing.T) {
	c := validCfg(t)
	c.QBittorrent.Password = ""
	if err := c.validate(); err != nil {
		t.Fatalf("пустой пароль qBittorrent должен быть валиден, got %v", err)
	}
}

// TestValidate_KeylessLocalLLM — keyless-local LLM (задан base_url, пустой
// api_key, напр. LM Studio) — валиден: ключ не обязателен.
func TestValidate_KeylessLocalLLM(t *testing.T) {
	c := validCfg(t)
	c.LLM.BaseURL = "http://host.docker.internal:1234/v1"
	c.LLM.APIKey = ""
	if err := c.validate(); err != nil {
		t.Fatalf("keyless-local LLM должен быть валиден, got %v", err)
	}
}

// TestDisplayLocation — зона отображения: пусто → UTC, валидная зона грузится,
// zoneinfo встроен (time/tzdata) → доступна на любом хосте.
func TestDisplayLocation(t *testing.T) {
	empty := &Config{}
	if loc, err := empty.DisplayLocation(); err != nil || loc != time.UTC {
		t.Fatalf("пустая зона → UTC, got %v, %v", loc, err)
	}

	c := &Config{General: General{Timezone: "Europe/Moscow"}}
	loc, err := c.DisplayLocation()
	if err != nil {
		t.Fatalf("Europe/Moscow должна грузиться (tzdata встроен): %v", err)
	}
	if loc.String() != "Europe/Moscow" {
		t.Fatalf("loc = %q, want Europe/Moscow", loc.String())
	}
}

// TestContentLanguage — язык вывода: дефолт en (в т.ч. из Default()), пусто → en,
// коды ru/en возвращаются как есть.
func TestContentLanguage(t *testing.T) {
	if got := Default().ContentLanguage(); got != "en" {
		t.Fatalf("Default().ContentLanguage() = %q, want en", got)
	}
	cases := map[string]string{"": "en", "ru": "ru", "en": "en"}
	for in, want := range cases {
		c := &Config{General: General{Language: in}}
		if got := c.ContentLanguage(); got != want {
			t.Errorf("ContentLanguage(%q) = %q, want %q", in, got, want)
		}
	}
}

// TestValidate_EmptyLanguageOK — пустой язык валиден (нормализуется в en аксессором).
func TestValidate_EmptyLanguageOK(t *testing.T) {
	c := validCfg(t)
	c.General.Language = ""
	if err := c.validate(); err != nil {
		t.Fatalf("пустой general.language должен быть валиден, got %v", err)
	}
}

func TestValidate_Errors(t *testing.T) {
	cases := []struct {
		name   string
		mutate func(*Config)
		want   string
	}{
		{"empty qbittorrent.url", func(c *Config) { c.QBittorrent.URL = "" }, "qbittorrent.url"},
		{"empty db_path", func(c *Config) { c.Storage.DBPath = "" }, "storage.db_path"},
		{"bad llm.type", func(c *Config) { c.LLM.Type = "anthropic" }, "llm.type"},
		{"relative movies", func(c *Config) { c.Paths.Movies = "movies" }, "absolute"},
		{"traversal series", func(c *Config) { c.Paths.Series = c.Paths.Series + "/../x" }, "clean"},
		{"missing downloads", func(c *Config) { c.Paths.Downloads = "/no/such/dir/jellybit" }, "not accessible"},
		{"threshold high", func(c *Config) { c.Recognition.AutoConfidenceThreshold = 1.5 }, "auto_confidence_threshold"},
		{"negative retries", func(c *Config) { c.LLM.MaxRetries = -1 }, "max_retries"},
		{"tmdb enabled no key", func(c *Config) { c.Metadata.TMDB.Enabled = true }, "metadata.tmdb"},
		{"tvdb enabled no key", func(c *Config) { c.Metadata.TVDB.Enabled = true }, "metadata.tvdb"},
		{"jellyfin enabled no url", func(c *Config) { c.Jellyfin.Enabled = true; c.Jellyfin.URL = "" }, "jellyfin.url"},
		{"jellyfin enabled no key", func(c *Config) { c.Jellyfin.Enabled = true; c.Jellyfin.URL = "http://j"; c.Jellyfin.APIKey = "" }, "jellyfin.api_key"},
		{"telegram enabled no token", func(c *Config) { c.Telegram.Enabled = true }, "telegram.token"},
		{"bad timezone", func(c *Config) { c.General.Timezone = "Mars/Phobos" }, "general.timezone"},
		{"bad language", func(c *Config) { c.General.Language = "de" }, "general.language"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			c := validCfg(t)
			tc.mutate(c)
			err := c.validate()
			if err == nil || !strings.Contains(err.Error(), tc.want) {
				t.Fatalf("ожидалась ошибка про %q, got %v", tc.want, err)
			}
		})
	}
}

// Пределы распознавания: дефолты применяются к конфигу, где секции нет вовсе,
// а нулевые/отрицательные значения отвергаются — молча дефолтить их нельзя,
// иначе выключенный предохранитель неотличим от настроенного.
func TestValidate_RecognitionLimits(t *testing.T) {
	if d := Default().Recognition; d.MaxFiles != 500 || d.MaxTokens != 8000 {
		t.Errorf("дефолты = %+v, want max_files 500 / max_tokens 8000", d)
	}

	dir := t.TempDir()
	for _, p := range []string{"downloads", "movies", "series"} {
		if err := os.MkdirAll(filepath.Join(dir, p), 0o755); err != nil {
			t.Fatalf("mkdir: %v", err)
		}
	}
	path := filepath.Join(dir, "config.toml")
	body := "[qbittorrent]\nurl = \"http://qbit:8080\"\n" +
		"[paths]\ndownloads = \"" + filepath.Join(dir, "downloads") + "\"\n" +
		"movies = \"" + filepath.Join(dir, "movies") + "\"\n" +
		"series = \"" + filepath.Join(dir, "series") + "\"\n"
	if err := os.WriteFile(path, []byte(body), 0o600); err != nil {
		t.Fatalf("write config: %v", err)
	}
	cfg, err := Load(path)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	if cfg.Recognition.MaxFiles != 500 || cfg.Recognition.MaxTokens != 8000 {
		t.Errorf("конфиг без секции не получил дефолты: %+v", cfg.Recognition)
	}

	for _, tt := range []struct {
		name string
		mut  func(*Config)
		want string
	}{
		{"max_files 0", func(c *Config) { c.Recognition.MaxFiles = 0 }, "recognition.max_files"},
		{"max_files negative", func(c *Config) { c.Recognition.MaxFiles = -1 }, "recognition.max_files"},
		{"max_tokens 0", func(c *Config) { c.Recognition.MaxTokens = 0 }, "recognition.max_tokens"},
		{"max_tokens negative", func(c *Config) { c.Recognition.MaxTokens = -10 }, "recognition.max_tokens"},
	} {
		t.Run(tt.name, func(t *testing.T) {
			c := validCfg(t)
			tt.mut(c)
			err := c.validate()
			if err == nil || !strings.Contains(err.Error(), tt.want) {
				t.Errorf("err = %v, want contains %q", err, tt.want)
			}
		})
	}
}