Files
archie/internal/infrastructure/staterpc/error_test.go
T
sam e16ba86b30 feat(harness): ingest OAuth storage and recover workflow write handling
Recover the OAuth storage slice from f6079e9d and the missing workflow persistence error handling from f07c314e, adapted to the current step contract. Require encryption for OAuth token storage and verify RPC round trips and task-grant denial.
2026-09-27 13:09:41 +10:00

134 lines
5.9 KiB
Go

package staterpc
import (
"context"
"errors"
"strings"
"testing"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
)
// TestUnmapErrorPreservesContextIdentity pins the §6 deadline contract that
// unmapError must rehydrate a gRPC Canceled / DeadlineExceeded status back to
// the standard context sentinels. The agent's deadlineStore bounds each Store
// call with context.WithTimeout and the workflow consumer checks
// errors.Is(err, context.DeadlineExceeded) to mark a stage interrupted rather
// than failed (workflow.go); if unmapError folded those into a sanitised
// internal error, a merely interrupted stage would be parked as a failure.
func TestUnmapErrorPreservesContextIdentity(t *testing.T) {
tests := []struct {
name string
err error
want error
}{
{name: "cancelled", err: status.Error(codes.Canceled, context.Canceled.Error()), want: context.Canceled},
{name: "deadline exceeded", err: status.Error(codes.DeadlineExceeded, context.DeadlineExceeded.Error()), want: context.DeadlineExceeded},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := unmapError(tt.err)
if !errors.Is(got, tt.want) {
t.Fatalf("unmapError(%q) = %v, want errors.Is(err, %v)", tt.err, got, tt.want)
}
if errors.Is(got, storecontract.ErrStaleTransition) {
t.Fatalf("unmapError(%q) = %v, must not map to a store sentinel", tt.err, got)
}
})
}
}
// TestMapErrorPreservesContextIdentity pins the server side of the same §6
// contract: if the store (or a server handler) returns a context error because
// the caller's ctx expired mid-call, mapError must map it to the matching
// gRPC code rather than sanitising it into codes.Internal. Otherwise the
// client never sees the deadline identity and an interrupted stage is wrongly
// treated as a failure.
func TestMapErrorPreservesContextIdentity(t *testing.T) {
tests := []struct {
name string
err error
want error
}{
{name: "cancelled", err: context.Canceled, want: context.Canceled},
{name: "deadline exceeded", err: context.DeadlineExceeded, want: context.DeadlineExceeded},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mapped := mapError(tt.err)
if got := unmapError(mapped); !errors.Is(got, tt.want) {
t.Fatalf("mapError/unmapError round-trip for %q = %v, want errors.Is(err, %v)", tt.err, got, tt.want)
}
})
}
}
// TestUnmapErrorSentinelFidelity pins the §7 sentinel rehydration round-trip
// for each store error code, so a consumer's errors.Is(err, storecontract.ErrX) keeps
// working across the wire.
func TestUnmapErrorSentinelFidelity(t *testing.T) {
tests := []struct {
name string
store error
rehyd error
}{
{name: "harness secret not found", store: storecontract.ErrHarnessSecretNotFound, rehyd: storecontract.ErrHarnessSecretNotFound},
{name: "stale transition", store: storecontract.ErrStaleTransition, rehyd: storecontract.ErrStaleTransition},
{name: "illegal transition", store: storecontract.ErrIllegalTransition, rehyd: storecontract.ErrIllegalTransition},
{name: "invalid step", store: storecontract.ErrInvalidStep, rehyd: storecontract.ErrInvalidStep},
{name: "binding not found", store: storecontract.ErrBindingNotFound, rehyd: storecontract.ErrBindingNotFound},
{name: "mapping not found", store: storecontract.ErrMappingNotFound, rehyd: storecontract.ErrMappingNotFound},
{name: "binding overlap", store: storecontract.ErrBindingOverlap, rehyd: storecontract.ErrBindingOverlap},
{name: "binding transition", store: storecontract.ErrBindingTransition, rehyd: storecontract.ErrBindingTransition},
{name: "already dispatched", store: storecontract.ErrAlreadyDispatched, rehyd: storecontract.ErrAlreadyDispatched},
{name: "source not found", store: storecontract.ErrSourceNotFound, rehyd: storecontract.ErrSourceNotFound},
{name: "source path taken", store: storecontract.ErrSourcePathTaken, rehyd: storecontract.ErrSourcePathTaken},
{name: "source signing stale", store: storecontract.ErrSourceSigningStale, rehyd: storecontract.ErrSourceSigningStale},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// mapError converts the store sentinel to a gRPC status; unmapError
// must recover the same sentinel. This is the round-trip the wire
// contract guarantees (§7).
mapped := mapError(tt.store)
got := unmapError(mapped)
if !errors.Is(got, tt.rehyd) {
t.Fatalf("round-trip %q -> %q: got %v, want %v", tt.store, mapped, got, tt.rehyd)
}
})
}
}
// TestUnmapErrorDoesNotLeakInternalDetail pins the §7 sanitisation rule: an
// infra/unknown error maps to codes.Internal and must not rehydrate to a store
// sentinel, the public message must not carry the raw wrapped detail (SQL
// paths, provider details), and a non-status error is returned unchanged.
func TestUnmapErrorDoesNotLeakInternalDetail(t *testing.T) {
const detail = "sql: path=/var/lib/archie/archie.db secret=abcdef"
internal := mapError(errors.New(detail))
got := unmapError(internal)
if errors.Is(got, storecontract.ErrStaleTransition) || errors.Is(got, storecontract.ErrBindingNotFound) || errors.Is(got, storecontract.ErrAlreadyDispatched) {
t.Fatalf("unmapError(internal) = %v, must not map to a store sentinel", got)
}
if st, ok := status.FromError(got); !ok || st.Code() != codes.Internal {
t.Fatalf("unmapError(internal) = %v, want a codes.Internal status", got)
}
if strings.Contains(got.Error(), detail) {
t.Fatalf("unmapError leaked raw internal detail: %q", got.Error())
}
// A raw (non-status) error is returned unchanged (not wrapped into a
// status or a store sentinel).
raw := errors.New("transport failure")
got = unmapError(raw)
if errors.Is(got, storecontract.ErrStaleTransition) {
t.Fatalf("unmapError(raw) = %v, must not map to a store sentinel", got)
}
if !errors.Is(got, raw) {
t.Fatalf("unmapError(raw) = %v, want an error chain including the original", got)
}
}