457 lines
16 KiB
Go
457 lines
16 KiB
Go
package handlers
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"testing"
|
|
|
|
"git.gobha.me/xcaliber/chat-switchboard/database"
|
|
)
|
|
|
|
// ═══════════════════════════════════════════
|
|
// Live Provider Integration Tests
|
|
// ═══════════════════════════════════════════
|
|
// These tests require:
|
|
// - TEST_DATABASE_URL or PGHOST+PGUSER
|
|
// - VENICE_API_KEY secret
|
|
//
|
|
// They exercise the full flow: create provider →
|
|
// fetch models → enable model → resolve → complete.
|
|
// ═══════════════════════════════════════════
|
|
|
|
func requireVeniceKey(t *testing.T) string {
|
|
t.Helper()
|
|
key := os.Getenv("VENICE_API_KEY")
|
|
if key == "" {
|
|
t.Skip("VENICE_API_KEY not set — skipping live provider test")
|
|
}
|
|
return key
|
|
}
|
|
|
|
// TestLive_VeniceProviderFullFlow exercises the complete admin workflow:
|
|
// create provider → fetch models → enable a model → user sees it → chat completion
|
|
func TestLive_VeniceProviderFullFlow(t *testing.T) {
|
|
h := setupHarness(t)
|
|
veniceKey := requireVeniceKey(t)
|
|
_, adminToken := h.createAdminUser("admin", "admin@test.com")
|
|
|
|
// ── 1. Create Venice provider config ────
|
|
t.Log("Step 1: Creating Venice provider config")
|
|
w := h.request("POST", "/api/v1/admin/configs", adminToken, map[string]interface{}{
|
|
"name": "Venice Live Test",
|
|
"provider": "venice",
|
|
"endpoint": "https://api.venice.ai/api/v1",
|
|
"api_key": veniceKey,
|
|
})
|
|
if w.Code != http.StatusCreated {
|
|
t.Fatalf("create venice config: want 201, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var configResp map[string]interface{}
|
|
decode(w, &configResp)
|
|
configID := configResp["id"].(string)
|
|
t.Logf(" Created config: %s", configID)
|
|
|
|
// ── 2. Fetch models from Venice ─────────
|
|
t.Log("Step 2: Fetching models from Venice API")
|
|
w = h.request("POST", "/api/v1/admin/models/fetch", adminToken, map[string]interface{}{
|
|
"provider_config_id": configID,
|
|
})
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("fetch models: want 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var fetchResp map[string]interface{}
|
|
decode(w, &fetchResp)
|
|
totalFetched := fetchResp["total"].(float64)
|
|
if totalFetched < 1 {
|
|
t.Fatalf("Venice should return at least 1 model, got %.0f", totalFetched)
|
|
}
|
|
t.Logf(" Fetched %.0f models from Venice", totalFetched)
|
|
|
|
// ── 3. List catalog models (all disabled by default) ──
|
|
t.Log("Step 3: Listing catalog models")
|
|
w = h.request("GET", "/api/v1/admin/models", adminToken, nil)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("list models: want 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var modelsResp map[string]interface{}
|
|
decode(w, &modelsResp)
|
|
catalogModels := modelsResp["models"].([]interface{})
|
|
if len(catalogModels) < 1 {
|
|
t.Fatal("catalog should have models after fetch")
|
|
}
|
|
|
|
// Find a text model to enable (prefer a small/fast one)
|
|
var enableID string
|
|
var enableModelID string
|
|
for _, raw := range catalogModels {
|
|
m := raw.(map[string]interface{})
|
|
modelID := m["model_id"].(string)
|
|
vis := m["visibility"].(string)
|
|
if vis == "disabled" {
|
|
enableID = m["id"].(string)
|
|
enableModelID = modelID
|
|
break
|
|
}
|
|
}
|
|
if enableID == "" {
|
|
t.Fatal("no disabled model found to enable")
|
|
}
|
|
t.Logf(" Will enable: %s (catalog ID: %s)", enableModelID, enableID)
|
|
|
|
// ── 4. Enable the model ─────────────────
|
|
t.Log("Step 4: Enabling model")
|
|
w = h.request("PUT", "/api/v1/admin/models/"+enableID, adminToken,
|
|
map[string]interface{}{"visibility": "enabled"})
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("enable model: want 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
|
|
// ── 5. Verify models/enabled returns it (admin) ──
|
|
t.Log("Step 5: Verifying models/enabled (admin)")
|
|
w = h.request("GET", "/api/v1/models/enabled", adminToken, nil)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("models/enabled: want 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var enabledResp map[string]interface{}
|
|
decode(w, &enabledResp)
|
|
enabledModels := enabledResp["models"].([]interface{})
|
|
if len(enabledModels) < 1 {
|
|
t.Fatal("models/enabled should return at least 1 model after enabling")
|
|
}
|
|
|
|
// Verify our model is in the list
|
|
found := false
|
|
for _, raw := range enabledModels {
|
|
m := raw.(map[string]interface{})
|
|
if m["model_id"] == enableModelID {
|
|
found = true
|
|
t.Logf(" ✓ Found %s in enabled models", enableModelID)
|
|
|
|
// Verify it has the required fields for the frontend
|
|
if m["config_id"] == nil || m["config_id"] == "" {
|
|
t.Error("enabled model must have config_id for composite ID")
|
|
}
|
|
if m["provider_name"] == nil || m["provider_name"] == "" {
|
|
t.Error("enabled model must have provider_name for display")
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("enabled model %s not found in models/enabled response", enableModelID)
|
|
}
|
|
|
|
// ── 6. Verify a REGULAR USER also sees the model ──
|
|
t.Log("Step 6: Verifying models/enabled (regular user)")
|
|
userID := database.SeedTestUser(t, "liveuser", "liveuser@test.com")
|
|
database.TestDB.Exec("UPDATE users SET is_active = true WHERE id = $1", userID)
|
|
userToken := makeToken(userID, "liveuser@test.com", "user")
|
|
|
|
w = h.request("GET", "/api/v1/models/enabled", userToken, nil)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("user models/enabled: want 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var userResp map[string]interface{}
|
|
decode(w, &userResp)
|
|
userModels := userResp["models"].([]interface{})
|
|
if len(userModels) < 1 {
|
|
t.Fatalf("regular user should see at least 1 enabled model, got %d — "+
|
|
"admin can see models but regular user cannot; check ListVisible query",
|
|
len(userModels))
|
|
}
|
|
|
|
userFound := false
|
|
for _, raw := range userModels {
|
|
m := raw.(map[string]interface{})
|
|
if m["model_id"] == enableModelID {
|
|
userFound = true
|
|
t.Logf(" ✓ Regular user can see %s", enableModelID)
|
|
|
|
// Verify same fields available for regular user
|
|
if m["config_id"] == nil || m["config_id"] == "" {
|
|
t.Error("user: enabled model must have config_id")
|
|
}
|
|
if m["provider_name"] == nil || m["provider_name"] == "" {
|
|
t.Error("user: enabled model must have provider_name")
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if !userFound {
|
|
t.Errorf("regular user cannot see %s — admin→user visibility broken", enableModelID)
|
|
}
|
|
}
|
|
|
|
// TestLive_VeniceFetchModelsCapabilities verifies that Venice model
|
|
// capabilities are correctly parsed into the catalog.
|
|
func TestLive_VeniceFetchModelsCapabilities(t *testing.T) {
|
|
h := setupHarness(t)
|
|
veniceKey := requireVeniceKey(t)
|
|
_, adminToken := h.createAdminUser("admin", "admin@test.com")
|
|
|
|
// Create provider + fetch
|
|
w := h.request("POST", "/api/v1/admin/configs", adminToken, map[string]interface{}{
|
|
"name": "Venice Caps Test", "provider": "venice",
|
|
"endpoint": "https://api.venice.ai/api/v1", "api_key": veniceKey,
|
|
})
|
|
var cfg map[string]interface{}
|
|
decode(w, &cfg)
|
|
configID := cfg["id"].(string)
|
|
|
|
h.request("POST", "/api/v1/admin/models/fetch", adminToken,
|
|
map[string]interface{}{"provider_config_id": configID})
|
|
|
|
// Read catalog and check capabilities
|
|
w = h.request("GET", "/api/v1/admin/models", adminToken, nil)
|
|
var resp map[string]interface{}
|
|
decode(w, &resp)
|
|
|
|
for _, raw := range resp["models"].([]interface{}) {
|
|
m := raw.(map[string]interface{})
|
|
caps, ok := m["capabilities"].(map[string]interface{})
|
|
if !ok {
|
|
t.Errorf("model %s: capabilities must be an object", m["model_id"])
|
|
continue
|
|
}
|
|
|
|
// streaming should always be true for Venice
|
|
if caps["streaming"] != true {
|
|
t.Errorf("model %s: streaming should be true", m["model_id"])
|
|
}
|
|
|
|
// Verify capabilities are actual booleans (not strings)
|
|
for _, key := range []string{"streaming", "vision", "tool_calling", "reasoning"} {
|
|
if v, exists := caps[key]; exists {
|
|
if _, ok := v.(bool); !ok {
|
|
t.Errorf("model %s: capability %s should be bool, got %T", m["model_id"], key, v)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestLive_VeniceChatCompletion sends an actual chat completion.
|
|
func TestLive_VeniceChatCompletion(t *testing.T) {
|
|
h := setupHarness(t)
|
|
veniceKey := requireVeniceKey(t)
|
|
adminID, adminToken := h.createAdminUser("admin", "admin@test.com")
|
|
_ = adminID
|
|
|
|
// Create provider
|
|
w := h.request("POST", "/api/v1/admin/configs", adminToken, map[string]interface{}{
|
|
"name": "Venice Chat Test", "provider": "venice",
|
|
"endpoint": "https://api.venice.ai/api/v1", "api_key": veniceKey,
|
|
})
|
|
var cfg map[string]interface{}
|
|
decode(w, &cfg)
|
|
configID := cfg["id"].(string)
|
|
|
|
// Fetch + enable a fast model
|
|
h.request("POST", "/api/v1/admin/models/fetch", adminToken,
|
|
map[string]interface{}{"provider_config_id": configID})
|
|
|
|
w = h.request("GET", "/api/v1/admin/models", adminToken, nil)
|
|
var modelsResp map[string]interface{}
|
|
decode(w, &modelsResp)
|
|
|
|
// Find and enable a small model (prefer llama or qwen for speed)
|
|
var targetModelID, targetCatalogID string
|
|
for _, raw := range modelsResp["models"].([]interface{}) {
|
|
m := raw.(map[string]interface{})
|
|
mid := m["model_id"].(string)
|
|
// Pick any available model - first disabled one
|
|
if m["visibility"].(string) == "disabled" {
|
|
targetModelID = mid
|
|
targetCatalogID = m["id"].(string)
|
|
break
|
|
}
|
|
}
|
|
if targetModelID == "" {
|
|
t.Skip("no model available to test chat completion")
|
|
}
|
|
|
|
h.request("PUT", "/api/v1/admin/models/"+targetCatalogID, adminToken,
|
|
map[string]interface{}{"visibility": "enabled"})
|
|
|
|
// Set as default model and send completion
|
|
// First get enabled model's composite ID
|
|
w = h.request("GET", "/api/v1/models/enabled", adminToken, nil)
|
|
var enabled map[string]interface{}
|
|
decode(w, &enabled)
|
|
if len(enabled["models"].([]interface{})) == 0 {
|
|
t.Fatal("no enabled models for completion test")
|
|
}
|
|
firstModel := enabled["models"].([]interface{})[0].(map[string]interface{})
|
|
modelForChat := firstModel["model_id"].(string)
|
|
configForChat := firstModel["config_id"].(string)
|
|
|
|
t.Logf("Sending completion to %s via config %s", modelForChat, configForChat)
|
|
|
|
// Create a channel first
|
|
w = h.request("POST", "/api/v1/channels", adminToken, map[string]interface{}{
|
|
"title": "Test Chat", "type": "direct",
|
|
})
|
|
if w.Code != http.StatusCreated {
|
|
// Some channel handlers may use database.DB directly
|
|
t.Skipf("channel creation failed (may need database.DB global): %d %s", w.Code, w.Body.String())
|
|
}
|
|
var ch map[string]interface{}
|
|
decode(w, &ch)
|
|
channelID := ch["id"].(string)
|
|
|
|
// Send completion
|
|
w = h.request("POST", "/api/v1/chat/completions", adminToken, map[string]interface{}{
|
|
"channel_id": channelID,
|
|
"model": modelForChat,
|
|
"config_id": configForChat,
|
|
"stream": false,
|
|
"messages": []map[string]string{
|
|
{"role": "user", "content": "Say hello in exactly 3 words."},
|
|
},
|
|
})
|
|
if w.Code != http.StatusOK {
|
|
t.Logf("completion response: %s", w.Body.String())
|
|
t.Skipf("chat completion failed with %d (may need full router wiring)", w.Code)
|
|
}
|
|
t.Logf(" ✓ Completion succeeded: %s", w.Body.String()[:min(200, w.Body.Len())])
|
|
}
|
|
|
|
// TestLive_VeniceModelDeletion tests cleanup: delete provider removes catalog entries
|
|
func TestLive_VeniceModelDeletion(t *testing.T) {
|
|
h := setupHarness(t)
|
|
veniceKey := requireVeniceKey(t)
|
|
_, adminToken := h.createAdminUser("admin", "admin@test.com")
|
|
|
|
// Create + fetch
|
|
w := h.request("POST", "/api/v1/admin/configs", adminToken, map[string]interface{}{
|
|
"name": "Venice Delete Test", "provider": "venice",
|
|
"endpoint": "https://api.venice.ai/api/v1", "api_key": veniceKey,
|
|
})
|
|
var cfg map[string]interface{}
|
|
decode(w, &cfg)
|
|
configID := cfg["id"].(string)
|
|
|
|
h.request("POST", "/api/v1/admin/models/fetch", adminToken,
|
|
map[string]interface{}{"provider_config_id": configID})
|
|
|
|
// Verify models exist
|
|
var count int
|
|
database.TestDB.QueryRow("SELECT COUNT(*) FROM model_catalog WHERE provider_config_id = $1", configID).Scan(&count)
|
|
if count == 0 {
|
|
t.Fatal("catalog should have models after fetch")
|
|
}
|
|
t.Logf(" %d models in catalog before delete", count)
|
|
|
|
// Delete the provider
|
|
w = h.request("DELETE", "/api/v1/admin/configs/"+configID, adminToken, nil)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("delete config: want 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
|
|
// Verify cascade: catalog entries should be gone
|
|
database.TestDB.QueryRow("SELECT COUNT(*) FROM model_catalog WHERE provider_config_id = $1", configID).Scan(&count)
|
|
if count != 0 {
|
|
t.Errorf("catalog should be empty after provider delete, got %d entries", count)
|
|
}
|
|
t.Log(" ✓ Cascade delete cleaned up catalog entries")
|
|
}
|
|
|
|
// TestLive_VeniceBYOK_AutoFetch exercises the ACTUAL user experience:
|
|
// user creates a BYOK provider → auto-fetch triggers → models appear in /models/enabled
|
|
//
|
|
// This is the definitive test. No simulated data. Real Venice API.
|
|
func TestLive_VeniceBYOK_AutoFetch(t *testing.T) {
|
|
h := setupHarness(t)
|
|
veniceKey := requireVeniceKey(t)
|
|
_, adminToken := h.createAdminUser("admin", "admin@test.com")
|
|
|
|
// Enable BYOK policy
|
|
h.request("PUT", "/api/v1/admin/settings/allow_user_byok", adminToken,
|
|
map[string]interface{}{"value": "true"})
|
|
|
|
// Create regular user
|
|
userID := database.SeedTestUser(t, "byokuser", "byokuser@test.com")
|
|
database.TestDB.Exec("UPDATE users SET is_active = true WHERE id = $1", userID)
|
|
userToken := makeToken(userID, "byokuser@test.com", "user")
|
|
|
|
// ── Step 1: User creates BYOK provider (the ONLY user action) ──
|
|
t.Log("Step 1: User creates BYOK Venice provider")
|
|
w := h.request("POST", "/api/v1/api-configs", userToken, map[string]interface{}{
|
|
"name": "My Venice",
|
|
"provider": "venice",
|
|
"endpoint": "https://api.venice.ai/api/v1",
|
|
"api_key": veniceKey,
|
|
})
|
|
if w.Code != http.StatusCreated {
|
|
t.Fatalf("create BYOK provider: want 201, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var created map[string]interface{}
|
|
decode(w, &created)
|
|
cfgID := created["id"].(string)
|
|
t.Logf(" Created provider: %s", cfgID)
|
|
|
|
// ── Step 2: Verify auto-fetch happened ──
|
|
if created["warning"] != nil {
|
|
t.Fatalf("auto-fetch should succeed with real Venice key, got warning: %v", created["warning"])
|
|
}
|
|
modelsFetched := created["models_fetched"]
|
|
if modelsFetched == nil || modelsFetched.(float64) < 1 {
|
|
t.Fatalf("auto-fetch should return models_fetched > 0, got: %v", modelsFetched)
|
|
}
|
|
t.Logf(" Auto-fetched %.0f models", modelsFetched.(float64))
|
|
|
|
// ── Step 3: User's models/enabled shows personal models ──
|
|
t.Log("Step 3: Verify user sees BYOK models in /models/enabled")
|
|
w = h.request("GET", "/api/v1/models/enabled", userToken, nil)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("models/enabled: %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var resp map[string]interface{}
|
|
decode(w, &resp)
|
|
userModels := resp["models"].([]interface{})
|
|
|
|
personalCount := 0
|
|
for _, raw := range userModels {
|
|
m := raw.(map[string]interface{})
|
|
if m["scope"] == "personal" {
|
|
personalCount++
|
|
}
|
|
}
|
|
|
|
if personalCount < 1 {
|
|
t.Fatalf("user should see personal BYOK models, got %d personal out of %d total\n"+
|
|
" model IDs: %v",
|
|
personalCount, len(userModels), func() []string {
|
|
ids := make([]string, 0)
|
|
for _, raw := range userModels {
|
|
m := raw.(map[string]interface{})
|
|
ids = append(ids, fmt.Sprintf("%s(scope=%s)", m["model_id"], m["scope"]))
|
|
}
|
|
return ids
|
|
}())
|
|
}
|
|
t.Logf(" ✓ User sees %d personal BYOK models (out of %d total)", personalCount, len(userModels))
|
|
|
|
// ── Step 4: Verify model fields for frontend ──
|
|
t.Log("Step 4: Verify frontend-required fields on BYOK models")
|
|
for _, raw := range userModels {
|
|
m := raw.(map[string]interface{})
|
|
if m["scope"] != "personal" {
|
|
continue
|
|
}
|
|
if m["config_id"] == nil || m["config_id"] == "" {
|
|
t.Errorf("personal model %s missing config_id", m["model_id"])
|
|
}
|
|
if m["provider_name"] == nil || m["provider_name"] == "" {
|
|
t.Errorf("personal model %s missing provider_name", m["model_id"])
|
|
}
|
|
if m["model_id"] == nil || m["model_id"] == "" {
|
|
t.Errorf("personal model missing model_id")
|
|
}
|
|
break // check first personal model only
|
|
}
|
|
|
|
// ── Cleanup ──
|
|
h.request("DELETE", fmt.Sprintf("/api/v1/api-configs/%s", cfgID), userToken, nil)
|
|
} |