349 lines
12 KiB
Go
349 lines
12 KiB
Go
package plugin
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"path/filepath"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
managedaccess "billing/internal/access"
|
|
"billing/internal/repository"
|
|
)
|
|
|
|
func lifecycleRequest(t *testing.T, schema uint32, config string) []byte {
|
|
t.Helper()
|
|
raw, err := json.Marshal(LifecycleRequest{ConfigYAML: []byte(config), SchemaVersion: schema})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return raw
|
|
}
|
|
|
|
func testConfig(t *testing.T, config string) string {
|
|
t.Helper()
|
|
return fmt.Sprintf("database_path: %q\n%s", filepath.Join(t.TempDir(), "usage.db"), config)
|
|
}
|
|
|
|
func TestRegisterNegotiatesSchemaAndDeclaresManagedAccessCapabilities(t *testing.T) {
|
|
app := NewApp()
|
|
raw, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, 99, testConfig(t, "enabled: true\ncodex_only: true\n")))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var env Envelope
|
|
if err := json.Unmarshal(raw, &env); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !env.OK {
|
|
t.Fatalf("register failed: %s", raw)
|
|
}
|
|
var got Registration
|
|
if err := json.Unmarshal(env.Result, &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got.SchemaVersion != SchemaVersion || !got.Capabilities.FrontendAuthProvider || !got.Capabilities.FrontendAuthProviderExclusive ||
|
|
!got.Capabilities.Scheduler || !got.Capabilities.RequestInterceptor || !got.Capabilities.RequestLifecyclePlugin ||
|
|
!got.Capabilities.UsagePlugin || !got.Capabilities.ManagementAPI {
|
|
t.Fatalf("unexpected registration: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestLifecycleConfigYAMLUsesBase64WireEncoding(t *testing.T) {
|
|
raw := lifecycleRequest(t, SchemaVersion, "enabled: true\n")
|
|
if !json.Valid(raw) {
|
|
t.Fatal("invalid JSON")
|
|
}
|
|
var wire map[string]any
|
|
_ = json.Unmarshal(raw, &wire)
|
|
want := base64.StdEncoding.EncodeToString([]byte("enabled: true\n"))
|
|
if wire["config_yaml"] != want {
|
|
t.Fatalf("config_yaml = %v, want %q", wire["config_yaml"], want)
|
|
}
|
|
}
|
|
|
|
func TestConfigRejectsShortBootstrapKey(t *testing.T) {
|
|
if _, err := decodeConfig([]byte("bootstrap_key: 12345\n")); err == nil {
|
|
t.Fatal("short bootstrap_key unexpectedly accepted")
|
|
}
|
|
}
|
|
|
|
func TestConfigDerivesCatalogCacheBesideDatabaseAndValidatesURL(t *testing.T) {
|
|
databasePath := filepath.Join(t.TempDir(), "nested", "usage.db")
|
|
cfg, err := decodeConfig([]byte(fmt.Sprintf("database_path: %q\n", databasePath)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.CatalogPath != filepath.Join(filepath.Dir(databasePath), "models-dev-catalog.json") {
|
|
t.Fatalf("catalog path = %q", cfg.CatalogPath)
|
|
}
|
|
if _, err := decodeConfig([]byte("models_dev_url: file:///tmp/catalog.json\n")); err == nil {
|
|
t.Fatal("non-HTTP models_dev_url unexpectedly accepted")
|
|
}
|
|
}
|
|
|
|
func TestUsageRecordWireFieldsMatchTargetContract(t *testing.T) {
|
|
raw, err := json.Marshal(UsageRecord{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var fields map[string]json.RawMessage
|
|
if err := json.Unmarshal(raw, &fields); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := []string{
|
|
"RequestID", "TraceID", "Provider", "ExecutorType", "Model", "Alias", "APIKey", "AuthID", "AuthIndex", "AuthType",
|
|
"Source", "ReasoningEffort", "ServiceTier", "Generate", "RequestedAt", "Latency", "TTFT",
|
|
"Failed", "Failure", "Detail", "ResponseHeaders",
|
|
}
|
|
if len(fields) != len(want) {
|
|
t.Fatalf("UsageRecord fields=%v", fields)
|
|
}
|
|
for _, name := range want {
|
|
if _, ok := fields[name]; !ok {
|
|
t.Fatalf("UsageRecord missing target field %s", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUsageRecordIdentityReconcilesLifecycleExactly(t *testing.T) {
|
|
app := NewApp()
|
|
if _, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, SchemaVersion, testConfig(t, "enabled: true\ncodex_only: false\n"))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer app.Shutdown()
|
|
|
|
startedAt := time.Now().UTC()
|
|
completionRaw, _ := json.Marshal(RequestCompletion{
|
|
RequestID: "request-identity", TraceID: "trace-identity", Model: "deepseek-v4-flash",
|
|
StartedAt: startedAt, CompletedAt: startedAt.Add(time.Second), Outcome: RequestCompletionSucceeded,
|
|
})
|
|
if _, err := app.HandleMethod(MethodRequestComplete, completionRaw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
usageRaw, _ := json.Marshal(UsageRecord{
|
|
RequestID: "request-identity", TraceID: "trace-identity", Provider: "openai", Model: "deepseek-v4-flash",
|
|
RequestedAt: startedAt.Add(5 * time.Millisecond), Detail: UsageDetail{InputTokens: 10, OutputTokens: 2, TotalTokens: 12},
|
|
})
|
|
if _, err := app.HandleMethod(MethodUsageHandle, usageRaw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
records, err := app.store.ListRecent(context.Background(), 10)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(records) != 1 || records[0].RequestID != "request-identity" || records[0].TraceID != "trace-identity" || records[0].TotalTokens != 12 {
|
|
t.Fatalf("records = %+v", records)
|
|
}
|
|
}
|
|
|
|
func TestReconfigureIsAtomicAndFiltersUsage(t *testing.T) {
|
|
app := NewApp()
|
|
if _, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, SchemaVersion, testConfig(t, "enabled: true\ncodex_only: true\n"))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, record := range []UsageRecord{{Provider: "codex", Model: "gpt-5.5"}, {Provider: "gemini", Model: "gemini-pro"}} {
|
|
raw, _ := json.Marshal(record)
|
|
if _, err := app.HandleMethod(MethodUsageHandle, raw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if got := app.Seen(); got != 1 {
|
|
t.Fatalf("seen = %d, want 1", got)
|
|
}
|
|
if _, err := app.HandleMethod(MethodPluginReconfigure, lifecycleRequest(t, SchemaVersion, "enabled: [invalid")); err == nil {
|
|
t.Fatal("invalid reconfiguration unexpectedly succeeded")
|
|
}
|
|
raw, _ := json.Marshal(UsageRecord{Provider: "codex", Model: "gpt-5.5"})
|
|
_, _ = app.HandleMethod(MethodUsageHandle, raw)
|
|
if got := app.Seen(); got != 2 {
|
|
t.Fatalf("last valid config was not retained: seen = %d", got)
|
|
}
|
|
}
|
|
|
|
func TestReconfigureReleasesAdmissionsWhenDatabaseChanges(t *testing.T) {
|
|
directory := t.TempDir()
|
|
firstPath := filepath.Join(directory, "first.db")
|
|
secondPath := filepath.Join(directory, "second.db")
|
|
store, err := repository.OpenSQLiteUsage(secondPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := store.BootstrapManagedKey(context.Background(), "default", "000000"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := store.UpdateBilling(context.Background(), "key_default", managedaccess.BillingSettings{
|
|
QuotaMicros: 1_000_000, ResetPeriod: managedaccess.ResetNone, MaxConcurrency: 4,
|
|
}, time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := store.AuthorizeBilling(context.Background(), "key_default", "stale-request", time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
app := NewApp()
|
|
if _, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, SchemaVersion, fmt.Sprintf("database_path: %q\n", firstPath))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := app.store.UpdateBilling(context.Background(), "key_default", managedaccess.BillingSettings{
|
|
QuotaMicros: 1_000_000, ResetPeriod: managedaccess.ResetNone, MaxConcurrency: 4,
|
|
}, time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := app.store.AuthorizeBilling(context.Background(), "key_default", "live-request", time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := app.HandleMethod(MethodPluginReconfigure, lifecycleRequest(t, SchemaVersion, fmt.Sprintf("database_path: %q\n", firstPath))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
state, err := app.store.BillingState(context.Background(), "key_default", time.Now())
|
|
if err != nil || state.ActiveRequests != 1 {
|
|
t.Fatalf("same-database reconfiguration released live admission: state=%+v err=%v", state, err)
|
|
}
|
|
if _, err := app.HandleMethod(MethodPluginReconfigure, lifecycleRequest(t, SchemaVersion, fmt.Sprintf("database_path: %q\n", secondPath))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
state, err = app.store.BillingState(context.Background(), "key_default", time.Now())
|
|
if err != nil || state.ActiveRequests != 0 {
|
|
t.Fatalf("reconfigured billing state=%+v err=%v", state, err)
|
|
}
|
|
}
|
|
|
|
func TestConcurrentUsage(t *testing.T) {
|
|
app := NewApp()
|
|
if _, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, SchemaVersion, testConfig(t, "enabled: true\ncodex_only: true\n"))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
raw, _ := json.Marshal(UsageRecord{Provider: "codex", Model: "gpt-5.5"})
|
|
var wg sync.WaitGroup
|
|
for range 100 {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
if _, err := app.HandleMethod(MethodUsageHandle, raw); err != nil {
|
|
t.Errorf("handle usage: %v", err)
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
if got := app.Seen(); got != 100 {
|
|
t.Fatalf("seen = %d, want 100", got)
|
|
}
|
|
}
|
|
|
|
func TestSSELifecycleCleanupDoesNotAccumulatePendingState(t *testing.T) {
|
|
app := NewApp()
|
|
if _, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, SchemaVersion, testConfig(t, "enabled: true\ncodex_only: false\n"))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer app.Shutdown()
|
|
if _, err := app.store.UpdateBilling(context.Background(), "key_default", managedaccess.BillingSettings{
|
|
QuotaMicros: 1_000_000_000, ResetPeriod: managedaccess.ResetNone, MaxConcurrency: 64,
|
|
}, time.Now().UTC()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
scope := managedaccess.CallerScope("key_default")
|
|
outcomes := [...]RequestCompletionOutcome{
|
|
RequestCompletionSucceeded, RequestCompletionFailed, RequestCompletionCanceled, RequestCompletionRejected,
|
|
}
|
|
for index := range 128 {
|
|
requestID := fmt.Sprintf("sse-%d", index)
|
|
beforeRaw, _ := json.Marshal(RequestInterceptRequest{
|
|
RequestID: requestID, Model: "deepseek-v4-flash", RequestedModel: "deepseek-v4-flash",
|
|
Stream: true, Metadata: map[string]any{callerScopeMetadata: scope},
|
|
})
|
|
beforeResponse, err := app.HandleMethod(MethodRequestBefore, beforeRaw)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var beforeEnvelope Envelope
|
|
_ = json.Unmarshal(beforeResponse, &beforeEnvelope)
|
|
var beforeResult RequestInterceptResponse
|
|
_ = json.Unmarshal(beforeEnvelope.Result, &beforeResult)
|
|
if beforeResult.Terminate {
|
|
t.Fatalf("SSE request %s was denied: %+v", requestID, beforeResult)
|
|
}
|
|
completionRaw, _ := json.Marshal(RequestCompletion{
|
|
RequestID: requestID, Model: "deepseek-v4-flash", Stream: true,
|
|
StartedAt: time.Now().Add(-time.Second), CompletedAt: time.Now(),
|
|
Outcome: outcomes[index%len(outcomes)], Metadata: map[string]any{callerScopeMetadata: scope},
|
|
})
|
|
if _, err := app.HandleMethod(MethodRequestComplete, completionRaw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
pending := 0
|
|
app.pending.Range(func(_, _ any) bool { pending++; return true })
|
|
if pending != 0 {
|
|
t.Fatalf("pending SSE requests = %d", pending)
|
|
}
|
|
state, err := app.store.BillingState(context.Background(), "key_default", time.Now().UTC())
|
|
if err != nil || state.ActiveRequests != 0 {
|
|
t.Fatalf("SSE billing state=%+v err=%v", state, err)
|
|
}
|
|
}
|
|
|
|
func TestFailedSSECompletionStillClearsPendingState(t *testing.T) {
|
|
app := NewApp()
|
|
if _, err := app.HandleMethod(MethodPluginRegister, lifecycleRequest(t, SchemaVersion, testConfig(t, "enabled: true\ncodex_only: false\n"))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := app.store.UpdateBilling(context.Background(), "key_default", managedaccess.BillingSettings{
|
|
QuotaMicros: 1_000_000, ResetPeriod: managedaccess.ResetNone, MaxConcurrency: 4,
|
|
}, time.Now().UTC()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
scope := managedaccess.CallerScope("key_default")
|
|
beforeRaw, _ := json.Marshal(RequestInterceptRequest{
|
|
RequestID: "sse-database-failure", Model: "deepseek-v4-flash", Stream: true,
|
|
Metadata: map[string]any{callerScopeMetadata: scope},
|
|
})
|
|
beforeResponse, err := app.HandleMethod(MethodRequestBefore, beforeRaw)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var beforeEnvelope Envelope
|
|
_ = json.Unmarshal(beforeResponse, &beforeEnvelope)
|
|
var beforeResult RequestInterceptResponse
|
|
_ = json.Unmarshal(beforeEnvelope.Result, &beforeResult)
|
|
if beforeResult.Terminate {
|
|
t.Fatalf("SSE request was denied: %+v", beforeResult)
|
|
}
|
|
if err := app.store.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
completionRaw, _ := json.Marshal(RequestCompletion{
|
|
RequestID: "sse-database-failure", Stream: true, Outcome: RequestCompletionCanceled,
|
|
CompletedAt: time.Now(), Metadata: map[string]any{callerScopeMetadata: scope},
|
|
})
|
|
if _, err := app.HandleMethod(MethodRequestComplete, completionRaw); err == nil {
|
|
t.Fatal("completion unexpectedly succeeded against a closed database")
|
|
}
|
|
pending := 0
|
|
app.pending.Range(func(_, _ any) bool { pending++; return true })
|
|
if pending != 0 {
|
|
t.Fatalf("pending requests after failed completion = %d", pending)
|
|
}
|
|
}
|
|
|
|
func TestUnknownMethodReturnsErrorEnvelope(t *testing.T) {
|
|
raw, err := NewApp().HandleMethod("missing", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var env Envelope
|
|
if err := json.Unmarshal(raw, &env); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if env.OK || env.Error == nil || env.Error.Code != "unknown_method" {
|
|
t.Fatalf("unexpected envelope: %s", raw)
|
|
}
|
|
}
|