admin
b6842a4bc3
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PSK5g6qYLknKj8u3QAFEr6
180 lines
7.1 KiB
Go
180 lines
7.1 KiB
Go
package agentapi
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.dooplex.hu/admin/felhom-controller/internal/util"
|
|
)
|
|
|
|
// Version-aware Supports (v0.115.0, pairs with agent v0.82.0's X-Felhom-Agent-Version): a KNOWN
|
|
// version decides by comparison with ZERO probe traffic; unknown/garbage stays on the v0.114.0
|
|
// probe path byte-identically.
|
|
|
|
// verProber implements SupportProber + AgentVersionReporter with a probe counter.
|
|
type verProber struct {
|
|
ver string
|
|
probes int
|
|
}
|
|
|
|
func (p *verProber) NetVerifyStatus(context.Context) (NetVerifyStatus, error) {
|
|
p.probes++
|
|
return NetVerifyStatus{Phase: "none"}, nil // a live route (probe verdict would be Yes)
|
|
}
|
|
func (p *verProber) AgentVersion() string { return p.ver }
|
|
|
|
// --- B3.1: version known → compare path, probe count 0 -----------------------------------------
|
|
// Companion red-proof: drop the supportsByVersion short-circuit in Supports → probes becomes 1.
|
|
func TestSupports_VersionKnown_ComparesWithoutProbe(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
ver string
|
|
want SupportState
|
|
}{
|
|
{"0.82.0", SupportYes},
|
|
{"0.81.0", SupportYes}, // boundary: MinAgent itself qualifies
|
|
{"1.0.0", SupportYes}, // numeric compare across majors
|
|
{"0.100.0", SupportYes}, // numeric, NOT lexicographic (0.100 > 0.81)
|
|
{"0.79.0", SupportNo}, // below MinAgent → No, still without probing
|
|
{"0.80.9", SupportNo},
|
|
} {
|
|
t.Run(tc.ver, func(t *testing.T) {
|
|
p := &verProber{ver: tc.ver}
|
|
var sc SupportCache
|
|
if got := sc.Supports(context.Background(), p, FeatureNetstorageVerify); got != tc.want {
|
|
t.Errorf("Supports(ver=%s) = %v, want %v", tc.ver, got, tc.want)
|
|
}
|
|
if p.probes != 0 {
|
|
t.Errorf("version-known path must NOT probe (ver=%s, probes=%d)", tc.ver, p.probes)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// --- B3.2: garbage/absent version → the probe fallback, byte-identical --------------------------
|
|
// Companion red-proof: trust the unvalidated header text (compare without ParseVersion error
|
|
// handling) → the garbage rows would refuse or panic instead of probing.
|
|
func TestSupports_GarbageOrNoVersion_ProbeFallback(t *testing.T) {
|
|
for _, ver := range []string{"", "dev", "0.82", "0.82.0-rc1", "v0.82.0-beta", "evil;rm -rf", "9999999999999999999999.0.0"} {
|
|
t.Run("ver="+ver, func(t *testing.T) {
|
|
p := &verProber{ver: ver}
|
|
var sc SupportCache
|
|
got := sc.Supports(context.Background(), p, FeatureNetstorageVerify)
|
|
if p.probes != 1 {
|
|
t.Fatalf("unusable version %q must fall back to EXACTLY one probe, got %d", ver, p.probes)
|
|
}
|
|
if got != SupportYes { // the fake's route answers → the probe decides Yes
|
|
t.Errorf("probe fallback verdict = %v, want SupportYes", got)
|
|
}
|
|
// Second call: the probe verdict is cached (the v0.114.0 behavior, unchanged).
|
|
_ = sc.Supports(context.Background(), p, FeatureNetstorageVerify)
|
|
if p.probes != 1 {
|
|
t.Errorf("cached probe verdict must not re-probe (probes=%d)", p.probes)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A prober that does NOT implement AgentVersionReporter (the web fakes' shape) keeps the pure
|
|
// v0.114.0 behavior — the interface assertion must not change anything for it.
|
|
func TestSupports_NonReporterProber_Unchanged(t *testing.T) {
|
|
p := &fakeProber{} // the existing v0.114.0 test fake (features_test.go)
|
|
var sc SupportCache
|
|
if got := sc.Supports(context.Background(), p, FeatureNetstorageVerify); got != SupportYes {
|
|
t.Fatalf("non-reporter prober = %v, want SupportYes via probe", got)
|
|
}
|
|
if p.calls != 1 {
|
|
t.Errorf("non-reporter prober must probe exactly once, got %d", p.calls)
|
|
}
|
|
}
|
|
|
|
// --- B3.4: the ONE comparator, table-driven (incl. pre-release suffixes) ------------------------
|
|
func TestVersionComparator_Table(t *testing.T) {
|
|
lt := func(a, b string) {
|
|
t.Helper()
|
|
av, err1 := util.ParseVersion(a)
|
|
bv, err2 := util.ParseVersion(b)
|
|
if err1 != nil || err2 != nil {
|
|
t.Fatalf("parse %q/%q: %v %v", a, b, err1, err2)
|
|
}
|
|
if av.Compare(bv) != -1 || bv.Compare(av) != 1 {
|
|
t.Errorf("want %s < %s", a, b)
|
|
}
|
|
}
|
|
lt("0.81.0", "0.82.0")
|
|
lt("0.81.0", "0.100.0") // numeric minor, not lexicographic
|
|
lt("0.99.9", "1.0.0")
|
|
lt("1.2.3", "1.2.10")
|
|
if v, err := util.ParseVersion("v0.82.0"); err != nil || v.Raw != "0.82.0" {
|
|
t.Errorf("v-prefix must parse: %v %v", v, err)
|
|
}
|
|
if eq, _ := util.ParseVersion("0.81.0"); eq.Compare(eq) != 0 {
|
|
t.Error("equal versions must compare 0")
|
|
}
|
|
// Pre-release suffixes are REJECTED by the house comparator — in Supports they mean "fall back
|
|
// to the probe", never a trusted comparison.
|
|
for _, bad := range []string{"1.2.3-rc1", "dev", "latest", "", "1.2", "a.b.c"} {
|
|
if _, err := util.ParseVersion(bad); err == nil {
|
|
t.Errorf("ParseVersion(%q) must error", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- B3.5: wire-level — the header decides over the probe through the REAL pinned client --------
|
|
// A ROUTELESS agent (probe would say No) that sends X-Felhom-Agent-Version 9.9.9 must be judged by
|
|
// the VERSION (Yes): proof the channel takes precedence end-to-end, and that capture happens on an
|
|
// ordinary (even failing) call.
|
|
func TestClient_VersionHeaderWins_WireLevel(t *testing.T) {
|
|
mux := http.NewServeMux() // NO /netstorage/verify-status (the pre-0.81 route shape)
|
|
mux.HandleFunc("/storage", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("X-Felhom-Agent-Version", "9.9.9")
|
|
_, _ = w.Write([]byte(`{"ok":true,"data":{"vmid":1,"mounts":[]}}`))
|
|
})
|
|
wrapped := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("X-Felhom-Agent-Version", "9.9.9") // every response, like the agent's wrap
|
|
mux.ServeHTTP(w, r)
|
|
})
|
|
srv := httptest.NewTLSServer(wrapped)
|
|
defer srv.Close()
|
|
fp := sha256.Sum256(srv.Certificate().Raw)
|
|
c, err := New(strings.TrimPrefix(srv.URL, "https://"), "test-token", hex.EncodeToString(fp[:]))
|
|
if err != nil {
|
|
t.Fatalf("New: %v", err)
|
|
}
|
|
if _, err := c.Storage(context.Background()); err != nil {
|
|
t.Fatalf("storage: %v", err)
|
|
}
|
|
if got := c.AgentVersion(); got != "9.9.9" {
|
|
t.Fatalf("AgentVersion = %q, want 9.9.9 (passive capture)", got)
|
|
}
|
|
if got := c.Supports(context.Background(), FeatureNetstorageVerify); got != SupportYes {
|
|
t.Errorf("Supports = %v, want SupportYes via version despite the missing probe route", got)
|
|
}
|
|
}
|
|
|
|
// A GARBAGE header must never be captured: the routeless agent stays on the probe → SupportNo.
|
|
func TestClient_GarbageHeaderIgnored_WireLevel(t *testing.T) {
|
|
wrapped := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("X-Felhom-Agent-Version", "not-a-version;x")
|
|
http.NotFound(w, r)
|
|
})
|
|
srv := httptest.NewTLSServer(wrapped)
|
|
defer srv.Close()
|
|
fp := sha256.Sum256(srv.Certificate().Raw)
|
|
c, err := New(strings.TrimPrefix(srv.URL, "https://"), "test-token", hex.EncodeToString(fp[:]))
|
|
if err != nil {
|
|
t.Fatalf("New: %v", err)
|
|
}
|
|
_, _ = c.Storage(context.Background()) // 404s; the garbage header must be dropped at capture
|
|
if got := c.AgentVersion(); got != "" {
|
|
t.Fatalf("AgentVersion = %q, want empty (strict validation at capture)", got)
|
|
}
|
|
if got := c.Supports(context.Background(), FeatureNetstorageVerify); got != SupportNo {
|
|
t.Errorf("Supports = %v, want SupportNo via the probe fallback", got)
|
|
}
|
|
}
|