Cyrene_v2/internal/runtime/model/runtime_test.go

package model

import (
	"context"
	"path/filepath"
	"sync"
	"testing"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/config"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/config/runtimeconfig"
)

func rtEnv() config.LLMConfig {
	// Env fallback matches "openai default" (provider not anthropic).
	return config.LLMConfig{
		Provider: ProviderOpenAI,
		BaseURL:  "https://api.openai.com/v1",
		APIKey:   "sk-env",
		Model:    "gpt-4o",
	}
}

func writeRTFile(t *testing.T, groups []runtimeconfig.Group) string {
	t.Helper()
	path := filepath.Join(t.TempDir(), "models.json")
	if err := runtimeconfig.SaveModels(path, groups); err != nil {
		t.Fatalf("SaveModels: %v", err)
	}
	return path
}

func TestRuntimeLLM_EnvFallback(t *testing.T) {
	// Missing file → env fallback provider/model.
	m := NewRuntimeLLM(filepath.Join(t.TempDir(), "nope.json"), rtEnv(), nil)
	if m.Provider() != ProviderOpenAI || m.Model() != "gpt-4o" {
		t.Fatalf("fallback Provider=%q Model=%q, want openai/gpt-4o", m.Provider(), m.Model())
	}
	chain, router := m.Current()
	if router == nil {
		t.Fatal("router is nil after env fallback")
	}
	if chain == nil {
		// No real endpoint is fine; the adapter should report ErrNoModel, not panic.
		if _, err := m.Chat(context.Background(), Request{Messages: nil}, Options{}); err != ErrNoModel {
			t.Fatalf("Chat on empty config err = %v, want ErrNoModel", err)
		}
	}
}

func TestRuntimeLLM_FileLoad(t *testing.T) {
	path := writeRTFile(t, []runtimeconfig.Group{
		{ID: "deepseek", Provider: ProviderOpenAI, BaseURL: "https://api.deepseek.com/v1", APIKey: "sk-ds", Model: "deepseek-chat"},
	})
	m := NewRuntimeLLM(path, rtEnv(), nil)
	if m.Provider() != ProviderOpenAI || m.Model() != "deepseek-chat" {
		t.Fatalf("Provider=%q Model=%q, want openai/deepseek-chat", m.Provider(), m.Model())
	}
	if m.Group().ID != "deepseek" {
		t.Fatalf("Group().ID = %q, want deepseek", m.Group().ID)
	}
}

func TestRuntimeLLM_ReloadReflectsNewProviderModel(t *testing.T) {
	path := writeRTFile(t, []runtimeconfig.Group{
		{ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://api.openai.com/v1", APIKey: "sk-1", Model: "gpt-4o"},
	})
	m := NewRuntimeLLM(path, rtEnv(), nil)
	if m.Model() != "gpt-4o" {
		t.Fatalf("before reload Model = %q, want gpt-4o", m.Model())
	}
	// Rewrite the file with an anthropic provider/model, then reload.
	if err := runtimeconfig.SaveModels(path, []runtimeconfig.Group{
		{ID: "claude", Provider: ProviderAnthropic, BaseURL: "https://api.anthropic.com", APIKey: "sk-ant", Model: "claude-sonnet-4"},
	}); err != nil {
		t.Fatalf("SaveModels: %v", err)
	}
	if err := m.Reload(); err != nil {
		t.Fatalf("Reload: %v", err)
	}
	if m.Provider() != ProviderAnthropic || m.Model() != "claude-sonnet-4" {
		t.Fatalf("after reload Provider=%q Model=%q, want anthropic/claude-sonnet-4", m.Provider(), m.Model())
	}
	chain, router := m.Current()
	if router == nil || chain == nil {
		t.Fatal("after reload Current() returned nil chain/router")
	}
}

func TestRuntimeLLM_ImplementsAdapterAndRouter(t *testing.T) {
	path := writeRTFile(t, []runtimeconfig.Group{
		{ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://x", APIKey: "sk", Model: "m"},
	})
	m := NewRuntimeLLM(path, rtEnv(), nil)
	var _ Adapter = m
	var _ ModelRouter = m
	if m.Name() != "openai" {
		t.Fatalf("Name = %q, want openai", m.Name())
	}
	modelName, _ := m.RouteRequest(Request{})
	if modelName != "m" {
		t.Fatalf("RouteRequest = %q, want the active model m", modelName)
	}
}

func TestRuntimeLLM_ConcurrentReadDuringReloadNoPanic(t *testing.T) {
	path := writeRTFile(t, []runtimeconfig.Group{
		{ID: "openai", Provider: ProviderOpenAI, BaseURL: "https://api.openai.com/v1", APIKey: "sk-1", Model: "gpt-4o"},
	})
	m := NewRuntimeLLM(path, rtEnv(), nil)

	const readers = 8
	var wg sync.WaitGroup
	stop := make(chan struct{})
	for i := 0; i < readers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for {
				select {
				case <-stop:
					return
				default:
				}
				_ = m.Provider()
				_ = m.Model()
				chain, router := m.Current()
				if router == nil {
					t.Error("router is nil during concurrent read")
					return
				}
				if chain == nil {
					// A nil chain means the config had no base/model; our test file has one,
					// so a swap must always produce a chain. Guard anyway.
					t.Error("chain is nil during concurrent read")
					return
				}
			}
		}()
	}
	// Reload a number of times while the readers spin.
	for i := 0; i < 200; i++ {
		if err := m.Reload(); err != nil {
			t.Fatalf("reload %d: %v", i, err)
		}
	}
	close(stop)
	wg.Wait()
}