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.
134 lines
5.9 KiB
Go
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)
|
|
}
|
|
}
|