This commit is contained in:
@@ -0,0 +1,72 @@
|
||||
package action_commit_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
"git.cin.su/m/Assistant/contracts/capability"
|
||||
commitcontract "git.cin.su/m/Assistant/contracts/commit"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
authoritydomain "git.cin.su/m/Assistant/modules/authority/domain"
|
||||
commitdomain "git.cin.su/m/Assistant/modules/commit/domain"
|
||||
"git.cin.su/m/Assistant/modules/commit/ports"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
type validator struct{}
|
||||
|
||||
func (validator) Validate(context authority.AuthorizationContext) error {
|
||||
return authoritydomain.ValidateGrant(context.Binding, context.Scope, context.Grant)
|
||||
}
|
||||
|
||||
type unknownExecutor struct{}
|
||||
|
||||
func (unknownExecutor) Execute(commitcontract.AuthorizedAction) ports.ExecutionResult {
|
||||
return ports.ExecutionResult{Known: false}
|
||||
}
|
||||
|
||||
func TestWS003RejectsRevokedGrantAndNeverExecutesProposalDirectly(t *testing.T) {
|
||||
context, proposal := testContextAndProposal()
|
||||
context.Grant.Active = false
|
||||
_, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized")))
|
||||
if !errors.Is(err, authoritydomain.ErrInvalidGrant) {
|
||||
t.Fatalf("authorization error = %v, want invalid grant", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWS003RejectsMissingActorPrincipalBinding(t *testing.T) {
|
||||
context, proposal := testContextAndProposal()
|
||||
context.Binding.Active = false
|
||||
_, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized")))
|
||||
if !errors.Is(err, authoritydomain.ErrInvalidGrant) {
|
||||
t.Fatalf("authorization error = %v, want invalid grant", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWS003UnknownOutcomeBlocksBlindRetry(t *testing.T) {
|
||||
context, proposal := testContextAndProposal()
|
||||
action, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized")))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
attempt, err := commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-one")), unknownExecutor{})
|
||||
if !errors.Is(err, commitdomain.ErrUnknownOutcome) || attempt.State != commitcontract.ActionUnknownOutcome {
|
||||
t.Fatalf("unknown result = %#v, %v", attempt, err)
|
||||
}
|
||||
action.State = commitcontract.ActionUnknownOutcome
|
||||
if _, err := commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-two")), unknownExecutor{}); !errors.Is(err, commitdomain.ErrUnknownOutcome) {
|
||||
t.Fatalf("blind retry error = %v, want unknown outcome", err)
|
||||
}
|
||||
}
|
||||
|
||||
func testContextAndProposal() (commitdomain.AuthorizationContext, commitcontract.ActionProposal) {
|
||||
actor := identity.ActorID(ids.ID("creator-actor"))
|
||||
principal := identity.PrincipalID(ids.ID("creator-principal"))
|
||||
scope := authority.Scope{ID: authority.ScopeID(ids.ID("global")), Global: true, Label: "all"}
|
||||
grant := authority.AuthorityGrant{ID: authority.GrantID(ids.ID("grant")), ActorID: actor, PrincipalID: principal, ScopeID: scope.ID, Class: authority.GrantClassCreator, Revision: 1, Active: true}
|
||||
context := commitdomain.AuthorizationContext{Binding: identity.PrincipalBinding{ActorID: actor, PrincipalID: principal, Active: true}, Scope: scope, Grant: grant}
|
||||
proposal := commitcontract.ActionProposal{IntentID: commitcontract.ActionIntentID(ids.ID("intent")), ActorID: actor, CapabilityID: capability.CapabilityID(ids.ID("executor")), Target: work.TaskTarget{TaskID: work.TaskID(ids.ID("task")), GoalID: work.GoalID(ids.ID("goal")), ScopeID: scope.ID, Revision: 1}, Operation: "mutate-external-world"}
|
||||
return context, proposal
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
package action_commit_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/adapters/testexecutor"
|
||||
commitcontract "git.cin.su/m/Assistant/contracts/commit"
|
||||
commitdomain "git.cin.su/m/Assistant/modules/commit/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestWS003UnknownOutcomeReconcilesWithoutDuplicateEffect(t *testing.T) {
|
||||
context, proposal := testContextAndProposal()
|
||||
action, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized-reconcile")))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
executor := testexecutor.New(true)
|
||||
unknown, err := commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-execute")), executor)
|
||||
if !errors.Is(err, commitdomain.ErrUnknownOutcome) || unknown.State != commitcontract.ActionUnknownOutcome || executor.EffectCount() != 1 {
|
||||
t.Fatalf("execute = %#v, %v, effects=%d", unknown, err, executor.EffectCount())
|
||||
}
|
||||
verified, err := commitdomain.Reconcile(action, unknown, commitcontract.ActionAttemptID(ids.ID("attempt-reconcile")), executor)
|
||||
if err != nil || verified.State != commitcontract.ActionSucceeded || executor.EffectCount() != 1 {
|
||||
t.Fatalf("reconcile = %#v, %v, effects=%d", verified, err, executor.EffectCount())
|
||||
}
|
||||
// Even an adversarial duplicate delivery is idempotent at the external boundary.
|
||||
_, _ = commitdomain.Execute(action, commitcontract.ActionAttemptID(ids.ID("attempt-duplicate")), executor)
|
||||
if executor.EffectCount() != 1 {
|
||||
t.Fatalf("duplicate delivery created %d effects", executor.EffectCount())
|
||||
}
|
||||
}
|
||||
|
||||
func TestWS003ReconciliationRequiresUnknownOutcome(t *testing.T) {
|
||||
context, proposal := testContextAndProposal()
|
||||
action, err := commitdomain.Authorize(proposal, context, validator{}, commitcontract.AuthorizedActionID(ids.ID("authorized-invalid-reconcile")))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
previous := commitcontract.ActionAttempt{ID: "attempt-failed", AuthorizedID: action.ID, IntentID: action.Proposal.IntentID, State: commitcontract.ActionFailed}
|
||||
if _, err = commitdomain.Reconcile(action, previous, "attempt-next", testexecutor.New(false)); !errors.Is(err, commitdomain.ErrInvalidReconciliation) {
|
||||
t.Fatalf("reconciliation error = %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package architecture_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestArchitectureRegistryParses(t *testing.T) {
|
||||
b, err := os.ReadFile("../../architecture/architecture-registry.json")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var v map[string]any
|
||||
if err := json.Unmarshal(b, &v); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if v["semantic_generation"] == nil {
|
||||
t.Fatal("semantic_generation missing")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
package cognitive_fake_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/adapters/models"
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
"git.cin.su/m/Assistant/contracts/capability"
|
||||
commitcontract "git.cin.su/m/Assistant/contracts/commit"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestDeterministicFakeEmitsCandidateOnly(t *testing.T) {
|
||||
request := models.DeterministicRequest{ActorID: identity.ActorID(ids.ID("creator")), CapabilityID: capability.CapabilityID(ids.ID("fake")), Target: work.TaskTarget{TaskID: work.TaskID(ids.ID("task")), GoalID: work.GoalID(ids.ID("goal")), ScopeID: authority.ScopeID(ids.ID("scope")), Revision: 1}, Operation: commitcontract.ExternalOperation("test-operation")}
|
||||
first, second := models.Propose(request), models.Propose(request)
|
||||
if first.Proposal.IntentID != second.Proposal.IntentID || first.Seed != second.Seed {
|
||||
t.Fatal("same request produced different candidate")
|
||||
}
|
||||
if first.Proposal.State != commitcontract.ActionProposed {
|
||||
t.Fatalf("state = %s, want PROPOSED", first.Proposal.State)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package creator_auth_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"git.cin.su/m/Assistant/modules/identity/domain"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestCreatorSessionIsTimeBoundAndDoesNotCarryAuthority(t *testing.T) {
|
||||
now := time.Unix(1000, 0)
|
||||
token, session, err := domain.IssueCreatorSession([]byte("01234567890123456789012345678901"), now, time.Minute)
|
||||
if err != nil || session.ExpiresAtUnix != 1060 {
|
||||
t.Fatal("issue failed")
|
||||
}
|
||||
if _, err = domain.ValidateCreatorSession([]byte("01234567890123456789012345678901"), token, now); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err = domain.ValidateCreatorSession([]byte("01234567890123456789012345678901"), token, now.Add(time.Minute)); err == nil {
|
||||
t.Fatal("expired session accepted")
|
||||
}
|
||||
if _, err = domain.ValidateCreatorSession([]byte("01234567890123456789012345678901"), token+"tampered", now); err == nil {
|
||||
t.Fatal("tampered session accepted")
|
||||
}
|
||||
payload, err := json.Marshal(session)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(string(payload), "Grant") || strings.Contains(string(payload), "Scope") {
|
||||
t.Fatal("identity session must not carry authority")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreatorBootstrapCredentialMustMatch(t *testing.T) {
|
||||
if !domain.BootstrapMatches("expected", "expected") {
|
||||
t.Fatal("matching bootstrap credential rejected")
|
||||
}
|
||||
for _, supplied := range []string{"", "wrong"} {
|
||||
if domain.BootstrapMatches("expected", supplied) {
|
||||
t.Fatalf("invalid bootstrap credential %q accepted", supplied)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package creator_authority_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
authoritydomain "git.cin.su/m/Assistant/modules/authority/domain"
|
||||
identitydomain "git.cin.su/m/Assistant/modules/identity/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestCreatorRequiresDistinctActiveBindingAndGlobalGrant(t *testing.T) {
|
||||
binding := identity.PrincipalBinding{ActorID: identity.ActorID(ids.ID("creator-actor")), PrincipalID: identity.PrincipalID(ids.ID("creator-principal")), Active: true}
|
||||
scope := authority.Scope{ID: authority.ScopeID(ids.ID("all-domovoy")), Label: "All Domovoy scopes", Global: true}
|
||||
grant := authority.AuthorityGrant{ID: authority.GrantID(ids.ID("creator-grant")), ActorID: binding.ActorID, PrincipalID: binding.PrincipalID, ScopeID: scope.ID, Class: authority.GrantClassCreator, Revision: 1, Active: true}
|
||||
if err := identitydomain.ValidateCreatorBinding(binding); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := authoritydomain.ValidateCreatorGrant(binding, scope, grant); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
grant.Active = false
|
||||
if err := authoritydomain.ValidateCreatorGrant(binding, scope, grant); err == nil {
|
||||
t.Fatal("revoked creator grant was accepted")
|
||||
}
|
||||
grant.Active = true
|
||||
scope.Global = false
|
||||
if err := authoritydomain.ValidateCreatorGrant(binding, scope, grant); err == nil {
|
||||
t.Fatal("non-global creator grant was accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package degraded_continuity_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/capability"
|
||||
"git.cin.su/m/Assistant/modules/capability/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestCognitiveProviderLossIsExplicitDegradedCapability(t *testing.T) {
|
||||
observed := int64(1)
|
||||
status := capability.Health{
|
||||
CapabilityID: capability.CapabilityID(ids.ID("cognitive-proposal")),
|
||||
State: capability.HealthDegraded,
|
||||
Reason: capability.ReasonCognitiveProvidersUnavailable,
|
||||
Revision: 1,
|
||||
SemanticVersion: capability.HealthV2,
|
||||
ObservedAtUnixMillis: &observed,
|
||||
}
|
||||
if err := domain.ValidateHealth(status); err != nil {
|
||||
t.Fatalf("valid degraded health rejected: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAvailableCapabilityCannotClaimDegradedReason(t *testing.T) {
|
||||
observed := int64(1)
|
||||
status := capability.Health{
|
||||
CapabilityID: capability.CapabilityID(ids.ID("cognitive-proposal")),
|
||||
State: capability.HealthAvailable,
|
||||
Reason: capability.ReasonCognitiveProvidersUnavailable,
|
||||
Revision: 1,
|
||||
SemanticVersion: capability.HealthV2,
|
||||
ObservedAtUnixMillis: &observed,
|
||||
}
|
||||
if err := domain.ValidateHealth(status); err == nil {
|
||||
t.Fatal("available status with degraded reason was accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
param(
|
||||
[string]$DockerContext = "docker-prod",
|
||||
[string]$PostgresContainer = "assistant-postgres-1"
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
$environment = docker --context $DockerContext inspect --format '{{range .Config.Env}}{{println .}}{{end}}' $PostgresContainer
|
||||
$userLine = $environment | Where-Object { $_.StartsWith("POSTGRES_USER=") } | Select-Object -First 1
|
||||
$databaseLine = $environment | Where-Object { $_.StartsWith("POSTGRES_DB=") } | Select-Object -First 1
|
||||
if (-not $userLine -or -not $databaseLine) { throw "PostgreSQL bootstrap identity is unavailable" }
|
||||
$user = $userLine.Substring("POSTGRES_USER=".Length)
|
||||
$database = $databaseLine.Substring("POSTGRES_DB=".Length)
|
||||
|
||||
$previousErrorAction = $ErrorActionPreference
|
||||
$ErrorActionPreference = "Continue"
|
||||
$denied = "SET ROLE continuity_role; INSERT INTO work.tasks (task_id, goal_id, scope_id, revision) VALUES ('acl-negative-probe', 'goal', 'scope', 1);" | docker --context $DockerContext exec -i $PostgresContainer psql -U $user -d $database -v ON_ERROR_STOP=1 2>&1
|
||||
$deniedExitCode = $LASTEXITCODE
|
||||
$ErrorActionPreference = $previousErrorAction
|
||||
if ($deniedExitCode -eq 0) { throw "cross-owner write unexpectedly succeeded" }
|
||||
|
||||
"SET ROLE work_role; SELECT count(*) FROM work.tasks;" | docker --context $DockerContext exec -i $PostgresContainer psql -U $user -d $database -v ON_ERROR_STOP=1 | Out-Null
|
||||
if ($LASTEXITCODE -ne 0) { throw "owner-local read failed" }
|
||||
|
||||
Write-Output "INV-OWN-001 owner ACL verification: PASS"
|
||||
@@ -0,0 +1,39 @@
|
||||
package prospective_memory_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
contract "git.cin.su/m/Assistant/contracts/continuity"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
"git.cin.su/m/Assistant/modules/continuity/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestWS002SurvivesSchedulerLossAndRevalidatesBeforeDelivery(t *testing.T) {
|
||||
item := contract.ProspectiveItem{ID: contract.ProspectiveItemID(ids.ID("reminder")), CommitmentID: contract.CommitmentID(ids.ID("commitment")), OwnerPrincipalID: identity.PrincipalID(ids.ID("creator")), ScopeID: authority.ScopeID(ids.ID("global")), GoalID: work.GoalID(ids.ID("goal")), TriggerAtUnixMillis: 1_800_000_000_000, State: contract.ProspectiveArmed, Revision: 1}
|
||||
store := domain.Recover([]contract.ProspectiveItem{item})
|
||||
|
||||
// Scheduler state is discarded; only the canonical snapshot reconstructs work.
|
||||
recovered := domain.Recover(store.Snapshot())
|
||||
triggered, err := recovered.Trigger(item.ID, 1)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := recovered.Trigger(item.ID, 1); !errors.Is(err, domain.ErrProspectiveRevision) {
|
||||
t.Fatalf("duplicate trigger error = %v, want revision conflict", err)
|
||||
}
|
||||
revalidating, err := recovered.BeginRevalidation(item.ID, triggered.Revision)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
suppressed, err := recovered.FinishRevalidation(item.ID, revalidating.Revision, false)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if suppressed.State != contract.ProspectiveSuppressed {
|
||||
t.Fatalf("state = %s, want SUPPRESSED", suppressed.State)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package semantic_evolution_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/capability"
|
||||
"git.cin.su/m/Assistant/modules/capability/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestHistoricalV1HealthRemainsExplicitlyInterpretable(t *testing.T) {
|
||||
historical := capability.Health{CapabilityID: capability.CapabilityID(ids.ID("historical")), State: capability.HealthDegraded, Reason: capability.ReasonCognitiveProvidersUnavailable, Revision: 1, SemanticVersion: capability.HealthV1}
|
||||
if err := domain.ValidateHealth(historical); err != nil {
|
||||
t.Fatalf("historical V1 health rejected: %v", err)
|
||||
}
|
||||
if historical.ObservedAtUnixMillis != nil {
|
||||
t.Fatal("V1 must preserve the absence of V2 observation time")
|
||||
}
|
||||
}
|
||||
|
||||
func TestV2RequiresObservationTimeAndRejectsUnknownVersion(t *testing.T) {
|
||||
observed := int64(1720000000000)
|
||||
v2 := capability.Health{CapabilityID: capability.CapabilityID(ids.ID("current")), State: capability.HealthAvailable, Reason: capability.ReasonNone, Revision: 2, SemanticVersion: capability.HealthV2, ObservedAtUnixMillis: &observed}
|
||||
if err := domain.ValidateHealth(v2); err != nil {
|
||||
t.Fatalf("V2 health rejected: %v", err)
|
||||
}
|
||||
v2.SemanticVersion = 3
|
||||
if err := domain.ValidateHealth(v2); !errors.Is(err, domain.ErrUnsupportedHealthVersion) {
|
||||
t.Fatalf("unknown version error = %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
package topology_equivalence_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
commitcontract "git.cin.su/m/Assistant/contracts/commit"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestWS004UnknownOutcomeSurvivesSerialization(t *testing.T) {
|
||||
attempt := commitcontract.ActionAttempt{ID: commitcontract.ActionAttemptID(ids.ID("attempt")), AuthorizedID: commitcontract.AuthorizedActionID(ids.ID("authorized")), IntentID: commitcontract.ActionIntentID(ids.ID("intent")), State: commitcontract.ActionUnknownOutcome}
|
||||
raw, err := json.Marshal(attempt)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var restored commitcontract.ActionAttempt
|
||||
if err := json.Unmarshal(raw, &restored); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if restored != attempt || restored.State != commitcontract.ActionUnknownOutcome {
|
||||
t.Fatalf("semantic state changed: %#v", restored)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package topology_equivalence_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
situationcontract "git.cin.su/m/Assistant/contracts/situation"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
situation "git.cin.su/m/Assistant/modules/situation/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestWS004FocusContractSurvivesSerialization(t *testing.T) {
|
||||
binding := situationcontract.FocusBinding{ID: situationcontract.FocusBindingID(ids.ID("focus")), ActorID: identity.ActorID(ids.ID("actor")), SessionID: situationcontract.SessionID(ids.ID("session")), Workspace: situationcontract.WorkspaceID(ids.ID("workspace")), ProjectID: situationcontract.ProjectID(ids.ID("project")), GoalID: work.GoalID(ids.ID("goal")), ScopeID: authority.ScopeID(ids.ID("scope")), Active: true}
|
||||
runtime := situationcontract.RuntimeBinding{SessionID: binding.SessionID, Workspace: binding.Workspace}
|
||||
direct, err := situation.NewResolver([]situationcontract.FocusBinding{binding}).Resolve(runtime)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
encoded, err := json.Marshal([]situationcontract.FocusBinding{binding})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var remote []situationcontract.FocusBinding
|
||||
if err := json.Unmarshal(encoded, &remote); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
extracted, err := situation.NewResolver(remote).Resolve(runtime)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if direct != extracted {
|
||||
t.Fatalf("topology changed focus: %#v != %#v", direct, extracted)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
param([string]$DockerContext = "docker-prod")
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
function Post-Json([string]$container, [string]$url, [object]$body) {
|
||||
$json = $body | ConvertTo-Json -Depth 8 -Compress
|
||||
$local = New-TemporaryFile
|
||||
$remote = "/tmp/domovoy-$([guid]::NewGuid().ToString('N')).json"
|
||||
try {
|
||||
[IO.File]::WriteAllText($local, $json, [Text.UTF8Encoding]::new($false))
|
||||
docker --context $DockerContext cp $local "${container}:$remote" | Out-Null
|
||||
docker --context $DockerContext exec $container wget -qO- --header "Content-Type: application/json" --post-file $remote $url
|
||||
if ($LASTEXITCODE -ne 0) { throw "POST $url failed" }
|
||||
} finally {
|
||||
docker --context $DockerContext exec --user root $container rm -f $remote 2>$null
|
||||
Remove-Item -LiteralPath $local -Force
|
||||
}
|
||||
}
|
||||
|
||||
function Expect-PostStatus([string]$container, [string]$url, [object]$body, [int]$status) {
|
||||
$json = $body | ConvertTo-Json -Depth 8 -Compress
|
||||
$local = New-TemporaryFile
|
||||
$remote = "/tmp/domovoy-$([guid]::NewGuid().ToString('N')).json"
|
||||
try {
|
||||
[IO.File]::WriteAllText($local, $json, [Text.UTF8Encoding]::new($false))
|
||||
docker --context $DockerContext cp $local "${container}:$remote" | Out-Null
|
||||
$previous = $ErrorActionPreference
|
||||
$ErrorActionPreference = "Continue"
|
||||
$response = (docker --context $DockerContext exec $container wget -S -O /dev/null --header "Content-Type: application/json" --post-file $remote $url 2>&1) -join "`n"
|
||||
$ErrorActionPreference = $previous
|
||||
if (-not $response.Contains("$status")) { throw "POST $url did not return $status" }
|
||||
} finally {
|
||||
docker --context $DockerContext exec --user root $container rm -f $remote 2>$null
|
||||
Remove-Item -LiteralPath $local -Force
|
||||
}
|
||||
}
|
||||
|
||||
$suffix = [guid]::NewGuid().ToString("N")
|
||||
$scope = "domovoy-global-scope"
|
||||
$goal = "goal-$suffix"
|
||||
$task = "task-$suffix"
|
||||
$session = "session-$suffix"
|
||||
$workspace = "workspace-$suffix"
|
||||
|
||||
Post-Json assistant-core-runtime-1 http://localhost:8080/v1/focus-bindings @{
|
||||
ID="focus-$suffix"; ActorID="domovoy-creator-actor"; SessionID=$session; Workspace=$workspace
|
||||
ProjectID="project-$suffix"; GoalID=$goal; ScopeID=$scope; Active=$true
|
||||
} | Out-Null
|
||||
Post-Json assistant-core-runtime-1 http://localhost:8080/v1/tasks @{
|
||||
TaskID=$task; GoalID=$goal; ScopeID=$scope; Revision=1
|
||||
} | Out-Null
|
||||
$wrongCommit = @{ SessionID=$session; Workspace=$workspace; Target=@{TaskID=$task;GoalID="wrong-$goal";ScopeID=$scope;Revision=1} }
|
||||
Expect-PostStatus assistant-core-runtime-1 http://localhost:8080/v1/focus-task-commits $wrongCommit 409
|
||||
$rightCommit = @{ SessionID=$session; Workspace=$workspace; Target=@{TaskID=$task;GoalID=$goal;ScopeID=$scope;Revision=1} }
|
||||
$commitResult = Post-Json assistant-core-runtime-1 http://localhost:8080/v1/focus-task-commits $rightCommit
|
||||
if (($commitResult | ConvertFrom-Json).Revision -ne 2) { throw "remote task revision did not advance" }
|
||||
|
||||
$prospectiveID = "prospective-$suffix"
|
||||
Post-Json assistant-continuity-runtime-1 http://localhost:8081/v1/prospective-items @{
|
||||
ID=$prospectiveID; CommitmentID="commitment-$suffix"; OwnerPrincipalID="domovoy-creator-principal"
|
||||
ScopeID=$scope; GoalID=$goal; TriggerAtUnixMillis=1800000000000; State="ARMED"; Revision=1
|
||||
} | Out-Null
|
||||
docker --context $DockerContext restart assistant-continuity-runtime-1 | Out-Null
|
||||
for ($attempt=0; $attempt -lt 15; $attempt++) {
|
||||
$restored = docker --context $DockerContext exec assistant-continuity-runtime-1 wget -qO- "http://localhost:8081/v1/prospective-items/$prospectiveID" 2>$null
|
||||
if ($LASTEXITCODE -eq 0) { break }
|
||||
Start-Sleep -Seconds 2
|
||||
}
|
||||
if ($LASTEXITCODE -ne 0 -or $restored -notmatch $prospectiveID) { throw "prospective item did not survive restart" }
|
||||
|
||||
$intent = "intent-$suffix"
|
||||
$authorized = "authorized-$suffix"
|
||||
Post-Json assistant-commit-runtime-1 http://localhost:8082/v1/authorized-actions @{
|
||||
Proposal=@{IntentID=$intent;ActorID="domovoy-creator-actor";CapabilityID="test-executor";Target=@{TaskID=$task;GoalID=$goal;ScopeID=$scope;Revision=2};Operation="test-idempotent-effect"}
|
||||
AuthorizedID=$authorized;GrantID="domovoy-creator-grant";PrincipalID="domovoy-creator-principal"
|
||||
} | Out-Null
|
||||
Post-Json assistant-commit-runtime-1 http://localhost:8082/v1/action-attempts @{
|
||||
ID="attempt-$suffix";AuthorizedID=$authorized;IntentID=$intent;State="UNKNOWN_OUTCOME"
|
||||
} | Out-Null
|
||||
|
||||
Write-Output "WS-004 remote topology verification: PASS"
|
||||
@@ -0,0 +1,5 @@
|
||||
# Walking skeleton tests
|
||||
|
||||
Black-box semantic acceptance tests go here. They must test properties rather than implementation call sequences.
|
||||
|
||||
Initial scenario IDs are defined in `architecture/WALKING_SKELETON_SPEC.md`.
|
||||
@@ -0,0 +1,84 @@
|
||||
package walking_skeleton_test
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
situationcontract "git.cin.su/m/Assistant/contracts/situation"
|
||||
workcontract "git.cin.su/m/Assistant/contracts/work"
|
||||
situation "git.cin.su/m/Assistant/modules/situation/domain"
|
||||
work "git.cin.su/m/Assistant/modules/work/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
func TestWS001FocusIsolationPreventsWrongProjectMutation(t *testing.T) {
|
||||
actor := identity.ActorID(ids.ID("actor"))
|
||||
scope := authority.ScopeID(ids.ID("scope"))
|
||||
project := situationcontract.ProjectID(ids.ID("same-repository"))
|
||||
goalA := workcontract.GoalID(ids.ID("goal-a"))
|
||||
goalB := workcontract.GoalID(ids.ID("goal-b"))
|
||||
bindings := []situationcontract.FocusBinding{
|
||||
{ID: situationcontract.FocusBindingID(ids.ID("focus-a")), ActorID: actor, SessionID: situationcontract.SessionID(ids.ID("session-a")), Workspace: situationcontract.WorkspaceID(ids.ID("worktree-a")), ProjectID: project, GoalID: goalA, ScopeID: scope, Active: true},
|
||||
{ID: situationcontract.FocusBindingID(ids.ID("focus-b")), ActorID: actor, SessionID: situationcontract.SessionID(ids.ID("session-b")), Workspace: situationcontract.WorkspaceID(ids.ID("worktree-b")), ProjectID: project, GoalID: goalB, ScopeID: scope, Active: true},
|
||||
}
|
||||
resolver := situation.NewResolver(bindings)
|
||||
store := work.NewStore([]work.Task{
|
||||
{ID: workcontract.TaskID(ids.ID("task-a")), GoalID: goalA, ScopeID: scope, Revision: 1},
|
||||
{ID: workcontract.TaskID(ids.ID("task-b")), GoalID: goalB, ScopeID: scope, Revision: 1},
|
||||
})
|
||||
|
||||
// The identical phrase is intentionally not supplied to resolution: runtime
|
||||
// session/workspace bindings, including two worktrees of one repository,
|
||||
// are the only project-selection inputs.
|
||||
focusA, err := resolver.Resolve(situationcontract.RuntimeBinding{SessionID: bindings[0].SessionID, Workspace: bindings[0].Workspace})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
focusB, err := resolver.Resolve(situationcontract.RuntimeBinding{SessionID: bindings[1].SessionID, Workspace: bindings[1].Workspace})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if focusA.GoalID == focusB.GoalID {
|
||||
t.Fatal("two worktrees resolved to the same goal")
|
||||
}
|
||||
|
||||
wrongTarget := workcontract.TaskTarget{TaskID: workcontract.TaskID(ids.ID("task-b")), GoalID: goalB, ScopeID: scope, Revision: 1}
|
||||
if err := situation.ValidateTaskTarget(focusA, wrongTarget); !errors.Is(err, situation.ErrTargetMismatch) {
|
||||
t.Fatalf("wrong cognition target error = %v, want ErrTargetMismatch", err)
|
||||
}
|
||||
|
||||
targetA := workcontract.TaskTarget{TaskID: workcontract.TaskID(ids.ID("task-a")), GoalID: goalA, ScopeID: scope, Revision: 1}
|
||||
if err := situation.ValidateTaskTarget(focusA, targetA); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
committed, err := store.Commit(targetA)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if committed.Revision != 2 {
|
||||
t.Fatalf("revision = %d, want 2", committed.Revision)
|
||||
}
|
||||
if _, err := store.Commit(targetA); !errors.Is(err, work.ErrRevisionConflict) {
|
||||
t.Fatalf("stale revision error = %v, want ErrRevisionConflict", err)
|
||||
}
|
||||
if _, err := store.Commit(wrongTarget); err != nil {
|
||||
t.Fatalf("other context must retain its original revision: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWS001RejectsStaleAndAmbiguousFocusWithoutMutation(t *testing.T) {
|
||||
runtime := situationcontract.RuntimeBinding{SessionID: situationcontract.SessionID(ids.ID("session")), Workspace: situationcontract.WorkspaceID(ids.ID("workspace"))}
|
||||
stale := situation.NewResolver([]situationcontract.FocusBinding{{SessionID: runtime.SessionID, Workspace: runtime.Workspace, Active: false}})
|
||||
if _, err := stale.Resolve(runtime); !errors.Is(err, situation.ErrStaleFocus) {
|
||||
t.Fatalf("stale error = %v, want ErrStaleFocus", err)
|
||||
}
|
||||
ambiguous := situation.NewResolver([]situationcontract.FocusBinding{
|
||||
{ID: situationcontract.FocusBindingID(ids.ID("one")), SessionID: runtime.SessionID, Workspace: runtime.Workspace, Active: true},
|
||||
{ID: situationcontract.FocusBindingID(ids.ID("two")), SessionID: runtime.SessionID, Workspace: runtime.Workspace, Active: true},
|
||||
})
|
||||
if _, err := ambiguous.Resolve(runtime); !errors.Is(err, situation.ErrAmbiguousFocus) {
|
||||
t.Fatalf("ambiguity error = %v, want ErrAmbiguousFocus", err)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user