226 lines
6.8 KiB
Go
226 lines
6.8 KiB
Go
package postgres
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
)
|
|
|
|
func newStoreForAccess(t *testing.T) *Store {
|
|
t.Helper()
|
|
pool, _ := migrated(t)
|
|
return New(pool)
|
|
}
|
|
|
|
func TestAccessPolicyStore(t *testing.T) {
|
|
s := newStoreForAccess(t)
|
|
ctx := t.Context()
|
|
|
|
// PutPolicy stores one policy and reports a versioned level.
|
|
p := access.Policy{
|
|
ID: "test-policy", Level: access.LevelOrg, OrgID: "soc",
|
|
Text: `permit(principal, action, resource) when { resource.kind == "binding" };`,
|
|
}
|
|
v1, err := s.PutPolicy(ctx, p)
|
|
if err != nil {
|
|
t.Fatalf("PutPolicy: %v", err)
|
|
}
|
|
if v1 != 2 { // the counter starts at 1; the first write bumps it
|
|
t.Fatalf("PutPolicy version = %d, want 2", v1)
|
|
}
|
|
v2, err := s.PutPolicy(ctx, p)
|
|
if err != nil {
|
|
t.Fatalf("second PutPolicy: %v", err)
|
|
}
|
|
if v2 <= v1 {
|
|
t.Fatalf("second PutPolicy version = %d, want > %d", v2, v1)
|
|
}
|
|
|
|
// A malformed policy is refused by the store's own structural check.
|
|
bad := access.Policy{ID: "bad", Level: access.LevelOrg, OrgID: "soc"}
|
|
if _, err := s.PutPolicy(ctx, bad); !errors.Is(err, access.ErrInvalidPolicy) {
|
|
t.Fatalf("PutPolicy(structurally invalid) = %v, want ErrInvalidPolicy", err)
|
|
}
|
|
|
|
// ListPolicies round-trips the scope tuple.
|
|
list, err := s.ListPolicies(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListPolicies: %v", err)
|
|
}
|
|
if len(list) != 1 {
|
|
t.Fatalf("ListPolicies = %d policies, want 1", len(list))
|
|
}
|
|
if list[0].ID != "test-policy" || list[0].OrgID != "soc" {
|
|
t.Fatalf("ListPolicies[0] = %+v, want the stored policy", list[0])
|
|
}
|
|
|
|
// DeletePolicy removes it and reports an unknown key as a sentinel.
|
|
if err := s.DeletePolicy(ctx, p); err != nil {
|
|
t.Fatalf("DeletePolicy: %v", err)
|
|
}
|
|
if err := s.DeletePolicy(ctx, p); !errors.Is(err, access.ErrPolicyNotFound) {
|
|
t.Fatalf("second DeletePolicy = %v, want ErrPolicyNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestEnsureShippedOrgPolicies(t *testing.T) {
|
|
s := newStoreForAccess(t)
|
|
ctx := t.Context()
|
|
|
|
if err := s.EnsureShippedOrgPolicies(ctx, "soc"); err != nil {
|
|
t.Fatalf("EnsureShippedOrgPolicies: %v", err)
|
|
}
|
|
list, err := s.ListPolicies(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListPolicies: %v", err)
|
|
}
|
|
if len(list) != 4 {
|
|
t.Fatalf("seeding produced %d policies, want the 4 shipped roles", len(list))
|
|
}
|
|
|
|
// An edited role policy survives a re-seed: an org that already carries
|
|
// the shipped IDs is left untouched.
|
|
edited := list[0]
|
|
edited.Text = `permit(principal, action, resource) when { resource.kind == "edited" };`
|
|
if _, err := s.PutPolicy(ctx, edited); err != nil {
|
|
t.Fatalf("PutPolicy(edit): %v", err)
|
|
}
|
|
if err := s.EnsureShippedOrgPolicies(ctx, "soc"); err != nil {
|
|
t.Fatalf("re-seed: %v", err)
|
|
}
|
|
after, err := s.ListPolicies(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListPolicies after re-seed: %v", err)
|
|
}
|
|
for _, p := range after {
|
|
if p.ID == edited.ID && p.Text != edited.Text {
|
|
t.Fatalf("re-seed overwrote an edited role policy %s", p.ID)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResetPolicies(t *testing.T) {
|
|
s := newStoreForAccess(t)
|
|
ctx := t.Context()
|
|
|
|
if err := s.ResetOrgPolicies(ctx, "soc"); err != nil {
|
|
t.Fatalf("ResetOrgPolicies: %v", err)
|
|
}
|
|
// An operator's custom org policy on top of the shipped set.
|
|
custom := access.Policy{
|
|
ID: "org-lockdown", Level: access.LevelOrg, OrgID: "soc",
|
|
Text: `forbid(principal, action, resource) when { resource.kind == "source" };`,
|
|
}
|
|
if _, err := s.PutPolicy(ctx, custom); err != nil {
|
|
t.Fatalf("PutPolicy(custom): %v", err)
|
|
}
|
|
// A workspace policy must survive an org reset.
|
|
ws := access.Policy{
|
|
ID: "ws-rule", Level: access.LevelWorkspace, OrgID: "soc", WorkspaceID: "net",
|
|
Text: `permit(principal, action, resource) when { resource.kind == "binding" };`,
|
|
}
|
|
if _, err := s.PutPolicy(ctx, ws); err != nil {
|
|
t.Fatalf("PutPolicy(ws): %v", err)
|
|
}
|
|
// And an instance policy must survive an org reset but not an instance
|
|
// reset.
|
|
instance := access.Policy{
|
|
ID: "instance-rule", Level: access.LevelInstance,
|
|
Text: `forbid(principal, action, resource) when { resource.kind == "secret" };`,
|
|
}
|
|
if _, err := s.PutPolicy(ctx, instance); err != nil {
|
|
t.Fatalf("PutPolicy(instance): %v", err)
|
|
}
|
|
|
|
if err := s.ResetOrgPolicies(ctx, "soc"); err != nil {
|
|
t.Fatalf("org reset: %v", err)
|
|
}
|
|
after, err := s.ListPolicies(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListPolicies: %v", err)
|
|
}
|
|
orgPolicies := 0
|
|
for _, p := range after {
|
|
switch {
|
|
case p.Level == access.LevelOrg && p.OrgID == "soc":
|
|
orgPolicies++
|
|
case p.Level == access.LevelOrg:
|
|
t.Fatalf("org reset touched policy %s of another org", p.ID)
|
|
}
|
|
}
|
|
if orgPolicies != 4 {
|
|
t.Fatalf("org-level policies after reset = %d, want the 4 shipped roles", orgPolicies)
|
|
}
|
|
|
|
if err := s.ResetInstancePolicies(ctx); err != nil {
|
|
t.Fatalf("ResetInstancePolicies: %v", err)
|
|
}
|
|
after, err = s.ListPolicies(ctx)
|
|
if err != nil {
|
|
t.Fatalf("ListPolicies after instance reset: %v", err)
|
|
}
|
|
for _, p := range after {
|
|
if p.Level == access.LevelInstance {
|
|
t.Fatalf("instance reset left policy %s", p.ID)
|
|
}
|
|
}
|
|
if len(after) == 0 {
|
|
t.Fatal("instance reset removed non-instance policies")
|
|
}
|
|
}
|
|
|
|
func TestDenialStore(t *testing.T) {
|
|
s := newStoreForAccess(t)
|
|
ctx := t.Context()
|
|
|
|
denial := access.Denial{
|
|
Principal: identity.IdentityID("11111111-1111-5111-8111-111111111111"),
|
|
Org: "soc", Action: access.ActionRead, Kind: access.KindBinding,
|
|
ResourceID: "b1", Level: access.LevelOrg,
|
|
Policies: []string{access.PolicyOrgRead, access.PolicyOrgEdit},
|
|
}
|
|
if err := s.RecordDenial(ctx, denial); err != nil {
|
|
t.Fatalf("RecordDenial: %v", err)
|
|
}
|
|
if err := s.RecordDenial(ctx, denial); err != nil {
|
|
t.Fatalf("repeat RecordDenial: %v", err)
|
|
}
|
|
// A different action is a separate row.
|
|
other := denial
|
|
other.Action = access.ActionDelete
|
|
if err := s.RecordDenial(ctx, other); err != nil {
|
|
t.Fatalf("RecordDenial(other action): %v", err)
|
|
}
|
|
|
|
rows, err := s.ListDenials(ctx, "soc", 10)
|
|
if err != nil {
|
|
t.Fatalf("ListDenials: %v", err)
|
|
}
|
|
if len(rows) != 2 {
|
|
t.Fatalf("ListDenials = %d rows, want 2", len(rows))
|
|
}
|
|
if rows[0].Action != access.ActionDelete {
|
|
t.Fatalf("newest denial = %v, want the delete denial", rows[0].Action)
|
|
}
|
|
for _, r := range rows {
|
|
if r.Action == access.ActionRead {
|
|
if r.Count != 2 {
|
|
t.Fatalf("repeated denial count = %d, want 2 (coalesced within the minute)", r.Count)
|
|
}
|
|
if len(r.Policies) != 2 {
|
|
t.Fatalf("denial policies = %v, want the deciding policies", r.Policies)
|
|
}
|
|
}
|
|
}
|
|
// Another org sees none of these.
|
|
if rows, err := s.ListDenials(ctx, "other", 10); err != nil || len(rows) != 0 {
|
|
t.Fatalf("ListDenials(other org) = %d rows %v, want none", len(rows), err)
|
|
}
|
|
// An org-less denial is refused at the producer.
|
|
if err := s.RecordDenial(ctx, access.Denial{Action: access.ActionRead}); err == nil {
|
|
t.Fatal("RecordDenial accepted a denial with no org or principal")
|
|
}
|
|
}
|