Files
archie/internal/infrastructure/embedding/embedding_test.go
T
sam 6affe0eea3 chore(curator): add embedding client and sampler interface prerequisites (#752)
* feat(curator): add embedding client and sampler wave-1 prerequisites

Bead archie-core-1786637500752-415-434e5bb9 (GitHub #436) was closed with
no linked PR/commits, and the surprisal-sampling bead
archie-core-1786637500776-416-600a66e5 (GitHub #437) found none of its
stated prerequisites -- an embedding client, a Sampler interface, or the
four wave-1 cheap sampling strategies -- actually exist. This builds them:

- internal/domain/embedding + internal/infrastructure/embedding: a narrow
  typed embedding client, config-driven via a providers table + a role in
  [models], mirroring the existing chat model role convention. Degrades to
  capability-unavailable (never fails startup or a call) for a missing
  role, unknown provider, unsupported class, or unresolved credential.
  Wired as an optional capability in bootstrap.go's setupEmbeddings.
- internal/domain/sampling: the Sampler interface plus recency, random,
  all, and staleness-proxy strategies, per docs/prds/curator-sampler-wave1.md.
  Deterministic given fixed inputs, matching GitHub #437's stated
  acceptance criterion for the embedding-backed strategy it will add
  behind this same interface (not part of this change).

Table-driven tests throughout; httptest for the embedding client, no live
service. No curator wiring yet -- nothing consumes either capability in
this change.

* no-mistakes(document): docs(architecture): mark curator sampling prereqs as landed
2026-09-05 22:53:08 +10:00

212 lines
6.6 KiB
Go

package embedding
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/config"
domainembedding "github.com/samcharles93/archie-core/internal/domain/embedding"
)
func TestNewDegradesWhenNoRoleConfigured(t *testing.T) {
t.Parallel()
cfg := config.Config{}
if _, ok := New(cfg, Options{}); ok {
t.Fatal("New() ok = true, want false when models[embedding] is unset")
}
}
func TestNewDegradesWhenProviderUnknown(t *testing.T) {
t.Parallel()
cfg := config.Config{
Models: map[string]string{Role: "openai/text-embedding-3-small"},
}
if _, ok := New(cfg, Options{}); ok {
t.Fatal("New() ok = true, want false when the provider is not configured")
}
}
func TestNewDegradesWhenRefHasNoProviderPrefix(t *testing.T) {
t.Parallel()
cfg := config.Config{
Models: map[string]string{Role: "text-embedding-3-small"},
Providers: map[string]config.Provider{"openai": {Class: "openai", APIKeyEnv: "TEST_KEY"}},
}
if _, ok := New(cfg, Options{Getenv: constEnv("secret")}); ok {
t.Fatal("New() ok = true, want false for a model ref with no provider/ prefix")
}
}
func TestNewDegradesWhenCredentialMissing(t *testing.T) {
t.Parallel()
cfg := config.Config{
Models: map[string]string{Role: "openai/text-embedding-3-small"},
Providers: map[string]config.Provider{"openai": {Class: "openai", APIKeyEnv: "TEST_MISSING_KEY"}},
}
if _, ok := New(cfg, Options{Getenv: constEnv("")}); ok {
t.Fatal("New() ok = true, want false when the configured credential env var is empty")
}
}
func TestNewDegradesForUnsupportedProviderClass(t *testing.T) {
t.Parallel()
cfg := config.Config{
Models: map[string]string{Role: "custom/some-model"},
Providers: map[string]config.Provider{"custom": {Class: "azure", APIKeyEnv: "TEST_KEY"}},
}
if _, ok := New(cfg, Options{Getenv: constEnv("secret")}); ok {
t.Fatal("New() ok = true, want false for a provider class embeddings doesn't support")
}
}
func TestNewSucceedsWhenNoCredentialRequired(t *testing.T) {
t.Parallel()
cfg := config.Config{
Models: map[string]string{Role: "local/nomic-embed-text"},
Providers: map[string]config.Provider{"local": {Class: "ollama"}},
}
if _, ok := New(cfg, Options{}); !ok {
t.Fatal("New() ok = false, want true for a credential-free provider class (ollama)")
}
}
func TestClientEmbedReturnsVectorsInInputOrder(t *testing.T) {
t.Parallel()
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/v1/embeddings" {
t.Fatalf("unexpected path %q", r.URL.Path)
}
var body struct {
Model string `json:"model"`
Input []string `json:"input"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
t.Fatalf("decode request: %v", err)
}
if body.Model != "text-embedding-3-small" {
t.Fatalf("model = %q, want %q", body.Model, "text-embedding-3-small")
}
resp := map[string]any{
"object": "list",
"model": body.Model,
"data": []map[string]any{
{"object": "embedding", "index": 1, "embedding": []float32{0.4, 0.5}},
{"object": "embedding", "index": 0, "embedding": []float32{0.1, 0.2}},
},
"usage": map[string]any{"prompt_tokens": 3, "total_tokens": 3},
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(resp)
}))
t.Cleanup(srv.Close)
cfg := config.Config{
Models: map[string]string{Role: "openai/text-embedding-3-small"},
Providers: map[string]config.Provider{
"openai": {Class: "openai", APIKeyEnv: "TEST_OPENAI_KEY", BaseURL: srv.URL},
},
}
c, ok := New(cfg, Options{Getenv: constEnv("secret")})
if !ok {
t.Fatal("New() ok = false, want true")
}
vectors, err := c.Embed(context.Background(), []string{"hello", "world"})
if err != nil {
t.Fatalf("Embed() error = %v", err)
}
if len(vectors) != 2 {
t.Fatalf("len(vectors) = %d, want 2", len(vectors))
}
if got := vectors[0]; len(got) != 2 || got[0] != 0.1 || got[1] != 0.2 {
t.Fatalf("vectors[0] = %v, want [0.1 0.2]", got)
}
if got := vectors[1]; len(got) != 2 || got[0] != 0.4 || got[1] != 0.5 {
t.Fatalf("vectors[1] = %v, want [0.4 0.5]", got)
}
}
func TestClientEmbedSurfacesProviderFailureAsError(t *testing.T) {
t.Parallel()
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusUnauthorized)
_, _ = w.Write([]byte(`{"error":"invalid api key"}`))
}))
t.Cleanup(srv.Close)
cfg := config.Config{
Models: map[string]string{Role: "openai/text-embedding-3-small"},
Providers: map[string]config.Provider{
"openai": {Class: "openai", APIKeyEnv: "TEST_OPENAI_KEY", BaseURL: srv.URL},
},
}
c, ok := New(cfg, Options{Getenv: constEnv("bad-key")})
if !ok {
t.Fatal("New() ok = false, want true")
}
if _, err := c.Embed(context.Background(), []string{"hello"}); err == nil {
t.Fatal("Embed() error = nil, want a reported error for the 401 response")
}
}
func TestClientEmbedRespectsTimeout(t *testing.T) {
t.Parallel()
release := make(chan struct{})
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
<-release
}))
// Cleanups run LIFO: srv.Close (registered first) waits for the
// in-flight handler to return, so release must close before it does --
// hence registering it second, not for statement-order readability.
t.Cleanup(srv.Close)
t.Cleanup(func() { close(release) })
cfg := config.Config{
Models: map[string]string{Role: "openai/text-embedding-3-small"},
Providers: map[string]config.Provider{
"openai": {Class: "openai", APIKeyEnv: "TEST_OPENAI_KEY", BaseURL: srv.URL},
},
}
c, ok := New(cfg, Options{Getenv: constEnv("secret"), Timeout: 50 * time.Millisecond})
if !ok {
t.Fatal("New() ok = false, want true")
}
start := time.Now()
_, err := c.Embed(context.Background(), []string{"hello"})
if err == nil {
t.Fatal("Embed() error = nil, want a timeout error")
}
if elapsed := time.Since(start); elapsed > 2*time.Second {
t.Fatalf("Embed() took %v, want it bounded by the configured timeout", elapsed)
}
}
func TestClientEmbedRejectsEmptyInput(t *testing.T) {
t.Parallel()
cfg := config.Config{
Models: map[string]string{Role: "local/nomic-embed-text"},
Providers: map[string]config.Provider{"local": {Class: "ollama"}},
}
c, ok := New(cfg, Options{})
if !ok {
t.Fatal("New() ok = false, want true")
}
if _, err := c.Embed(context.Background(), nil); !errors.Is(err, domainembedding.ErrEmptyInput) {
t.Fatalf("Embed() error = %v, want %v", err, domainembedding.ErrEmptyInput)
}
}
func constEnv(value string) func(string) string {
return func(string) string { return value }
}