ollie/backend/new_test.go

package backend

import (
	"fmt"
	"os"
	"testing"
)

// newFromEnv constructs a Backend from OLLIE_BACKEND env var (test helper).
func newFromEnv() (Backend, error) {
	which := os.Getenv("OLLIE_BACKEND")
	if which == "" {
		return nil, fmt.Errorf("OLLIE_BACKEND is not set")
	}
	return newBackend(which)
}

// setEnv sets env vars for a test and restores them on cleanup.
func setEnv(t *testing.T, vars map[string]string) {
	t.Helper()
	for k, v := range vars {
		old, existed := os.LookupEnv(k)
		os.Setenv(k, v)
		if existed {
			t.Cleanup(func() { os.Setenv(k, old) })
		} else {
			t.Cleanup(func() { os.Unsetenv(k) })
		}
	}
}

func clearEnv(t *testing.T, keys ...string) {
	t.Helper()
	for _, k := range keys {
		old, existed := os.LookupEnv(k)
		os.Unsetenv(k)
		if existed {
			t.Cleanup(func() { os.Setenv(k, old) })
		}
	}
}

func TestNewFromEnv_NoBackendErrors(t *testing.T) {
	clearEnv(t, "OLLIE_BACKEND", "OLLIE_OLLAMA_URL")
	_, err := newFromEnv()
	if err == nil {
		t.Fatal("expected error when OLLIE_BACKEND is unset, got nil")
	}
}

func TestNewFromEnv_Ollama(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "ollama"})
	b, err := newFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	if b.Name() != "ollama" {
		t.Errorf("name = %q", b.Name())
	}
}

func TestNewFromEnv_OpenAI(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "openai", "OLLIE_OPENAI_URL": "https://api.openai.com", "OLLIE_OPENAI_KEY": "sk-test"})
	b, err := newFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	if b.Name() != "openai" {
		t.Errorf("name = %q", b.Name())
	}
}

func TestNewFromEnv_OpenRouter(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "openrouter", "OLLIE_OPENAI_URL": "https://openrouter.ai/api", "OLLIE_OPENAI_KEY": "sk-or-test"})
	b, err := newFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	if b.Name() != "openrouter" {
		t.Errorf("name = %q", b.Name())
	}
}

func TestNewFromEnv_Anthropic(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "anthropic", "OLLIE_ANTHROPIC_KEY": "sk-ant-test"})
	b, err := newFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	if b.Name() != "anthropic" {
		t.Errorf("name = %q", b.Name())
	}
}

func TestNewFromEnv_AnthropicMissingKey(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "anthropic"})
	clearEnv(t, "OLLIE_ANTHROPIC_KEY")
	_, err := newFromEnv()
	if err == nil {
		t.Fatal("expected error for missing key")
	}
}

func TestNewFromEnv_Copilot(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "copilot", "OLLIE_COPILOT_TOKEN": "tok"})
	b, err := newFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	if b.Name() != "copilot" {
		t.Errorf("name = %q", b.Name())
	}
}

func TestNewFromEnv_CopilotMissingToken(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "copilot"})
	clearEnv(t, "OLLIE_COPILOT_TOKEN")
	_, err := newFromEnv()
	if err == nil {
		t.Fatal("expected error for missing token")
	}
}

func TestNewFromEnv_Kiro(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "kiro", "OLLIE_KIRO_TOKEN": "fake"})
	b, err := newFromEnv()
	if err != nil {
		t.Fatal(err)
	}
	if b.Name() != "kiro" {
		t.Errorf("name = %q", b.Name())
	}
}

func TestNewFromEnv_Unknown(t *testing.T) {
	setEnv(t, map[string]string{"OLLIE_BACKEND": "bogus"})
	_, err := newFromEnv()
	if err == nil {
		t.Fatal("expected error for unknown backend")
	}
}

func TestNewOllama_InvalidURL(t *testing.T) {
	_, err := NewOllama("://bad")
	if err == nil {
		t.Fatal("expected error for invalid URL")
	}
}

func TestNewOpenAI_InvalidURL(t *testing.T) {
	_, err := NewOpenAI("openai", "://bad", "k")
	if err == nil {
		t.Fatal("expected error for invalid URL")
	}
}

func TestBackends(t *testing.T) {
	bs := Backends()
	if len(bs) != 7 {
		t.Fatalf("len = %d; want 7", len(bs))
	}
	want := map[string]bool{"ollama": true, "openai": true, "openrouter": true, "anthropic": true, "copilot": true, "kiro": true, "gemini": true}
	for _, b := range bs {
		if !want[b] {
			t.Errorf("unexpected backend %q", b)
		}
	}
}