Files

111 lines
3.5 KiB
Go

package openshell
import (
"context"
"slices"
"strings"
"testing"
"time"
v1 "github.com/ai-openshell/sdk-go/openshell/v1"
"github.com/ai-openshell/sdk-go/openshell/v1/fake"
"github.com/samcharles93/archie-core/internal/infrastructure/egress"
)
// TestTaskSandboxEndsWithItsTask guards the sandbox lifecycle: a task sees its
// sandbox end however it ends (the agent exits, or it outlives its maximum
// uptime), and the sandbox is gone from the gateway once the task is done, so
// sandboxes never pile up.
func TestTaskSandboxEndsWithItsTask(t *testing.T) {
tests := []struct {
name string
maxUptime time.Duration
agentExits bool
wantExit bool
wantDetail string
}{
{name: "released while running"},
{name: "agent exits", agentExits: true, wantExit: true, wantDetail: "exit code 3"},
{name: "outlives its maximum uptime", maxUptime: 30 * time.Millisecond, wantExit: true, wantDetail: "maximum uptime"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
client := fake.NewClient()
defer func() { _ = client.Close() }()
rt := New(client, Options{Instance: "archie", Poll: 5 * time.Millisecond, MaxUptime: func() time.Duration { return tt.maxUptime }})
sb, err := rt.Acquire(t.Context(), Launch{Image: "agent:test", Worker: egress.Endpoints{NATS: "nats://nats.example.internal:4222"}})
if err != nil {
t.Fatal(err)
}
if tt.agentExits {
got, err := client.Sandboxes().Get(t.Context(), "default", sb.name)
if err != nil {
t.Fatal(err)
}
code := int32(3)
got.Status.ExitCode = &code
got.Status.Phase = v1.SandboxError
client.AddSandbox("default", got)
}
wait := 2 * time.Second
if !tt.wantExit {
wait = 50 * time.Millisecond
}
select {
case <-sb.Exited():
if !tt.wantExit {
t.Fatalf("sandbox reported an exit (%q) while still running", sb.ExitDetail())
}
if !strings.Contains(sb.ExitDetail(), tt.wantDetail) {
t.Fatalf("exit detail = %q, want it to say %q", sb.ExitDetail(), tt.wantDetail)
}
case <-time.After(wait):
if tt.wantExit {
t.Fatal("sandbox exit never reported")
}
}
rt.Release(t.Context(), sb)
if _, err := client.Sandboxes().Get(t.Context(), "default", sb.name); !v1.IsNotFound(err) {
t.Fatalf("sandbox still on the gateway after release: err=%v", err)
}
})
}
}
// TestSweepRemovesOnlyThisInstancesSandboxes guards instances sharing a
// gateway: a restarted daemon removes the sandboxes it left, never another
// instance's or ones archie did not create.
func TestSweepRemovesOnlyThisInstancesSandboxes(t *testing.T) {
client := fake.NewClient()
defer func() { _ = client.Close() }()
for name, labels := range map[string]map[string]string{
"archie-agent-1": {InstanceLabel: "archie"},
"staging-agent-1": {InstanceLabel: "staging"},
"someone-else": nil,
} {
client.AddSandbox("default", &v1.Sandbox{Name: name, Spec: v1.SandboxSpec{Template: &v1.SandboxTemplate{Labels: labels}}})
}
rt := New(client, Options{Instance: "archie"})
if err := rt.Sweep(context.Background()); err != nil {
t.Fatal(err)
}
pager, err := client.Sandboxes().List("default", v1.ListOptions{})
if err != nil {
t.Fatal(err)
}
left, err := pager.All(context.Background())
if err != nil {
t.Fatal(err)
}
var names []string
for _, sb := range left {
names = append(names, sb.Name)
}
slices.Sort(names)
if want := []string{"someone-else", "staging-agent-1"}; !slices.Equal(names, want) {
t.Fatalf("sandboxes left after sweep = %v, want %v", names, want)
}
}