Files
archie/internal/infrastructure/staterpc/harness_secret_test.go
T
sam 0dae907dad refactor(state)!: split StateStoreService into per-domain services
One gRPC service per domain in state.v1 (tasks, executions, accounts, identities, packages, captures, bindings, access, orgs, alerts and so on), each with its own server type in staterpc. RPC and message names and numbers are unchanged.
2026-10-25 19:54:27 +11:00

176 lines
6.1 KiB
Go

package staterpc
import (
"context"
"errors"
"strings"
"testing"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/proto"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
)
type harnessCapture struct{ got harnesssecret.Secret }
func (h *harnessCapture) GetHarnessSecret(_ context.Context, org, service string) (harnesssecret.Secret, error) {
h.got = harnesssecret.Secret{Org: org, Service: service}
return h.got, nil
}
func (h *harnessCapture) PutHarnessSecret(_ context.Context, value harnesssecret.Secret) error {
h.got = value
return nil
}
func TestHarnessSecretsUseCallerOrg(t *testing.T) {
for _, caller := range []org.OrgID{"acme", org.DefaultOrgID, ""} {
t.Run(string(caller), func(t *testing.T) {
capture := &harnessCapture{}
s := &harnessSecretServer{server: &server{deps: Deps{HarnessSecrets: capture}}}
ctx := org.WithOrg(context.Background(), caller)
// A stale or malicious client still sending field 1 cannot choose the org.
wire := protowire.AppendString(protowire.AppendTag(nil, 1, protowire.BytesType), "victim")
req := &pb.GetHarnessSecretRequest{}
if err := proto.Unmarshal(wire, req); err != nil {
t.Fatal(err)
}
req.Service = "provider"
if _, err := s.GetHarnessSecret(ctx, req); err != nil {
t.Fatal(err)
}
if capture.got.Org != string(org.OrgFromContext(ctx)) {
t.Fatalf("read org = %q, want caller org %q", capture.got.Org, org.OrgFromContext(ctx))
}
secret := &pb.HarnessSecret{}
if err := proto.Unmarshal(wire, secret); err != nil {
t.Fatal(err)
}
secret.Service = "provider"
if _, err := s.PutHarnessSecret(ctx, &pb.PutHarnessSecretRequest{Secret: secret}); err != nil {
t.Fatal(err)
}
if capture.got.Org != string(org.OrgFromContext(ctx)) {
t.Fatalf("write org = %q, want caller org %q", capture.got.Org, org.OrgFromContext(ctx))
}
})
}
}
type harnessTasks struct {
storecontract.TaskStore
err error
}
func (h harnessTasks) TaskByID(context.Context, int64) (*task.Task, error) {
return &task.Task{ID: 7, Org: "acme"}, h.err
}
func TestHarnessSecretsUseTaskGrant(t *testing.T) {
for _, tt := range []struct {
name, token string
scope org.OrgID
taskErr error
want codes.Code
}{
{name: "live grant", token: strings.Repeat("ab", 32)},
{name: "unknown grant", token: strings.Repeat("cd", 32), want: codes.Unauthenticated},
{name: "another org", token: strings.Repeat("ab", 32), scope: "other", want: codes.PermissionDenied},
{name: "system principal cannot cross org", token: strings.Repeat("ab", 32), scope: org.DefaultOrgID, want: codes.PermissionDenied},
{name: "task lookup failure", token: strings.Repeat("ab", 32), taskErr: errors.New("store unavailable"), want: codes.Internal},
} {
t.Run(tt.name, func(t *testing.T) {
grants := &TaskGrants{Store: credentials{}}
if err := grants.register(t.Context(), 7, strings.Repeat("ab", 32), time.Hour); err != nil {
t.Fatal(err)
}
capture := &harnessCapture{}
s := &harnessSecretServer{server: &server{deps: Deps{Grants: grants, Tasks: harnessTasks{err: tt.taskErr}, HarnessSecrets: capture}}}
ctx := org.WithScope(t.Context(), tt.scope)
for _, write := range []bool{false, true} {
capture.got = harnesssecret.Secret{}
var err error
if write {
_, err = s.PutHarnessSecret(ctx, &pb.PutHarnessSecretRequest{RunCredential: tt.token, Secret: &pb.HarnessSecret{Service: "provider"}})
} else {
_, err = s.GetHarnessSecret(ctx, &pb.GetHarnessSecretRequest{RunCredential: tt.token, Service: "provider"})
}
if status.Code(err) != tt.want {
t.Fatalf("write %v: error %v, want %v", write, err, tt.want)
}
if tt.want == codes.OK && capture.got.Org != "acme" {
t.Fatalf("write %v: org %q, want acme", write, capture.got.Org)
}
if tt.want != codes.OK && capture.got.Org != "" {
t.Fatalf("unauthorized access reached store: %+v", capture.got)
}
}
})
}
}
type harnessRPC struct {
pb.HarnessSecretServiceClient
server *harnessSecretServer
}
func (h harnessRPC) GetHarnessSecret(ctx context.Context, r *pb.GetHarnessSecretRequest, _ ...grpc.CallOption) (*pb.GetHarnessSecretResponse, error) {
return h.server.GetHarnessSecret(ctx, r)
}
func (h harnessRPC) PutHarnessSecret(ctx context.Context, r *pb.PutHarnessSecretRequest, _ ...grpc.CallOption) (*pb.PutHarnessSecretResponse, error) {
return h.server.PutHarnessSecret(ctx, r)
}
func TestHarnessSecretClientGrant(t *testing.T) {
grants := &TaskGrants{Store: credentials{}}
token := strings.Repeat("ab", 32)
if err := grants.register(t.Context(), 7, token, time.Hour); err != nil {
t.Fatal(err)
}
capture := &harnessCapture{}
c := &Client{harnessSecret: harnessRPC{server: &harnessSecretServer{server: &server{deps: Deps{Grants: grants, Tasks: harnessTasks{}, HarnessSecrets: capture}}}}}
ctx := harnesssecret.WithRunCredential(t.Context(), token)
for _, tt := range []struct {
name, org string
revoke bool
want codes.Code
}{
{name: "task org", org: "acme"},
{name: "another org", org: "victim", want: codes.PermissionDenied},
{name: "revoked grant", org: "acme", revoke: true, want: codes.Unauthenticated},
} {
t.Run(tt.name, func(t *testing.T) {
if tt.revoke {
if err := grants.revoke(ctx, token); err != nil {
t.Fatal(err)
}
}
secret, err := c.GetHarnessSecret(ctx, tt.org, "provider")
if status.Code(err) != tt.want {
t.Fatalf("error %v, want %v", err, tt.want)
}
if tt.want == codes.OK {
if secret.Org != "acme" {
t.Fatalf("secret org %q, want acme", secret.Org)
}
if err := c.PutHarnessSecret(ctx, secret); err != nil {
t.Fatal(err)
}
if capture.got.Org != "acme" {
t.Fatalf("stored org %q, want acme", capture.got.Org)
}
}
})
}
}