dtoro
e074f04bdf
Problem: the hexagonal-architecture plan (plans/2026-08-15-hexagonal-
architecture.md) needs its foundation — an accepted ADR, the target
directory tree, and machine-checked dependency rules — before any
service extraction starts. Also folds the four outstanding review
findings (F3.1/F5/F6/F7) into the plan: ObservationService owns the
bounded probe-concurrency contract (scheduler.go:133), Phase 9 gates
ExecutionService+PolicyService ≥ 90% with a gating-matrix test,
per-phase abort criteria, and the §3.2 internal/config note.
Change:
- docs/adr/0016-hexagonal-ports-adapters.md records context, decision,
and consequences of the ports & adapters migration.
- internal/domain → internal/core/domain (mechanical import rewrite,
20 files), new internal/core/{ports,app}, internal/adapters trees
with package docs.
- .golangci.yml: depguard rules for §3.1 (core purity, no agent-client
tech in core, nomos isolation — the nomos rules self-activate when
internal/nomos exists in Phase 8). Config migrated to golangci-lint
v2 format so it loads at all (the v1 config errored under v2, masked
by CI's advisory continue-on-error). Verified depguard fires on a
planted openai-go import in internal/core/app.
- CONTRIBUTING.md layout section now shows the core/adapters tree.
Risk: import path churn is mechanical and tests pass unchanged; the
lint config migration surfaces the pre-existing 400-issue baseline
(advisory in CI, unchanged policy) — new/moved packages lint clean.
Verification: go vet ./..., make test (race, core/domain at 100%
coverage), make generate-check, golangci-lint on internal/core/... and
internal/adapters/... — 0 issues; depguard violation probe confirmed.
103 lines
3.2 KiB
Go
103 lines
3.2 KiB
Go
package ontology
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/dtoro/oikos/internal/core/domain"
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
// The lifecycle precondition checks split into a pure attribute/type guard
|
|
// and a DB query. These cover the pure guards at 0%: the entity-type skip
|
|
// rules and the attribute presence/absence semantics. The DB-backed checks
|
|
// (health, edges, backups, docs) are exercised by make test-db.
|
|
//
|
|
// ctx/pool/entityID are unused by the pure guards, so nil is safe here.
|
|
var (
|
|
noCtx = context.Background()
|
|
noPool *pgxpool.Pool // nil: the pure guards never touch the pool
|
|
noID = uuid.New()
|
|
)
|
|
|
|
func TestCheckAgeKeyEnrolled(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
entityType string
|
|
attrs map[string]any
|
|
wantErr bool
|
|
}{
|
|
{"workstation with age key", "workstation", map[string]any{"age_pubkey": "age1abc"}, false},
|
|
{"workstation missing age key", "workstation", map[string]any{}, true},
|
|
{"server needs a key too", "server", map[string]any{}, true},
|
|
{"lxc is exempt", "lxc", map[string]any{}, false},
|
|
{"vm is exempt", "vm", map[string]any{}, false},
|
|
{"docker-container is exempt", "docker-container", map[string]any{}, false},
|
|
{"nil attrs on a workstation", "workstation", nil, true},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
err := checkAgeKeyEnrolled(noCtx, noPool, noID, c.entityType, c.attrs)
|
|
if c.wantErr && !errors.Is(err, domain.ErrInvalidTransition) {
|
|
t.Errorf("want ErrInvalidTransition, got %v", err)
|
|
}
|
|
if !c.wantErr && err != nil {
|
|
t.Errorf("want nil, got %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckMeshJoined(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
entityType string
|
|
attrs map[string]any
|
|
wantErr bool
|
|
}{
|
|
{"workstation with mesh_ip", "workstation", map[string]any{"mesh_ip": "10.0.0.5"}, false},
|
|
{"workstation missing mesh_ip", "workstation", map[string]any{}, true},
|
|
{"server missing mesh_ip", "server", map[string]any{}, true},
|
|
{"lxc is exempt", "lxc", map[string]any{}, false},
|
|
{"vm is exempt", "vm", map[string]any{}, false},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
err := checkMeshJoined(noCtx, noPool, noID, c.entityType, c.attrs)
|
|
if c.wantErr && !errors.Is(err, domain.ErrInvalidTransition) {
|
|
t.Errorf("want ErrInvalidTransition, got %v", err)
|
|
}
|
|
if !c.wantErr && err != nil {
|
|
t.Errorf("want nil, got %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckSecretsRevoked(t *testing.T) {
|
|
// checkSecretsRevoked treats an ABSENT age_pubkey as "secrets revoked"
|
|
// (the inverse of checkAgeKeyEnrolled). It is type-agnostic.
|
|
cases := []struct {
|
|
name string
|
|
attrs map[string]any
|
|
wantErr bool
|
|
}{
|
|
{"age key gone → revoked", map[string]any{}, false},
|
|
{"age key still present → blocked", map[string]any{"age_pubkey": "age1abc"}, true},
|
|
{"nil attrs → revoked", nil, false},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
err := checkSecretsRevoked(noCtx, noPool, noID, "workstation", c.attrs)
|
|
if c.wantErr && !errors.Is(err, domain.ErrInvalidTransition) {
|
|
t.Errorf("want ErrInvalidTransition, got %v", err)
|
|
}
|
|
if !c.wantErr && err != nil {
|
|
t.Errorf("want nil, got %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|