323 lines
27 KiB
GDScript
323 lines
27 KiB
GDScript
extends "res://tests/s5/test_runtime_defense_cycle.gd"
|
|
|
|
## Acceptance tests for the configured Event -> Defense bridge. Source causes, facilities and every
|
|
## combat value below are disclosed fixtures. This does not prove normal thief,
|
|
## male bankruptcy or bank delinquency generation or an approved balance.
|
|
|
|
|
|
func _run() -> void:
|
|
print("Configured Event -> Defense: identity, rollback and save")
|
|
_test_failure_policy_and_expiry()
|
|
_test_event_rollback_preserves_failed_round_guard()
|
|
_test_serialized_action_enum_rejection()
|
|
_test_source_families_from_ordinary_event_phase()
|
|
_test_replay_conflict_and_manual_provenance_rejection()
|
|
_test_rollback_of_later_failed_action()
|
|
_test_choice_replay_and_real_cost_commit_failure()
|
|
_test_save_branch_provenance_corruption_and_legacy()
|
|
_cleanup()
|
|
if _failures == 0: print("PASS: %d checks" % _checks)
|
|
else: push_error("FAIL: %d of %d checks failed" % [_failures, _checks])
|
|
quit(_failures)
|
|
|
|
|
|
func _test_source_families_from_ordinary_event_phase() -> void:
|
|
_reset_runtime(92_001)
|
|
for kind: String in ["THIEF", "BANKRUPTCY_RIOT", "BANK_DELINQUENCY", "AUTHORITY_ESCALATION"]:
|
|
var objective := StringName("objective.event." + kind)
|
|
_create_staff_and_facility(StringName("guard.event." + kind), objective)
|
|
var action := _event_raid_action(objective, kind)
|
|
var instance := StringName("event.instance.fixture." + kind)
|
|
_expect(_register_threat_event(StringName("event.fixture." + kind), [action]).is_success(), "explicit configured event definition registers for " + kind)
|
|
_expect(_enqueue_threat_event(StringName("event.fixture." + kind), instance, StringName("cause.fixture." + kind)).is_success(), "disclosed cause enters the actual Event queue for " + kind)
|
|
var before := int(_runtime.defense_service.get_raid_ids().size())
|
|
var commands_before := int(_runtime.command_queue.processed_count())
|
|
_advance(1)
|
|
var raid_id := _event_raid_id(instance, action.action_id)
|
|
var raid: Dictionary = _runtime.defense_service.get_raid(raid_id)
|
|
_expect(_runtime.defense_service.get_raid_ids().size() == before + 1 and raid[&"state"] == DefenseService.RaidState.PREPARING, "ordinary event phase creates an existing preparing threat for " + kind)
|
|
_expect(raid[&"created_at"] == _clock.absolute_minute and raid[&"source_id"] == StringName("cause.fixture." + kind) and raid[&"event_source"]["source_kind"] == kind, "creation time and source families are preserved independently")
|
|
_expect(_runtime.event_service.get_instance(instance).state == EventInstance.State.COMPLETED and _count_domain_events(&"DEFENSE_RAID_CREATED", raid_id) == 1, "automatic Event action completes once and emits one real incident event")
|
|
_expect(_runtime.command_queue.processed_count() == commands_before, "ordinary event sink creates no synthetic player command")
|
|
# Incomplete templates fail closed rather than using Defense defaults.
|
|
var incomplete := _event_raid_action(&"objective.event.THIEF", "THIEF")
|
|
(incomplete.payload[&"definition"] as Dictionary).erase(&"round_minutes")
|
|
_expect(_register_threat_event(&"event.fixture.incomplete", [incomplete]).is_success(), "schema accepts an action whose runtime configuration must still be checked")
|
|
_expect(_enqueue_threat_event(&"event.fixture.incomplete", &"event.instance.incomplete", &"cause.incomplete").is_success(), "incomplete disclosed template enters the event queue")
|
|
var raids_before: Dictionary = _runtime.defense_service.create_snapshot()
|
|
_advance(1)
|
|
raids_before[&"current_minute"] = _clock.absolute_minute
|
|
_expect(_runtime.defense_service.create_snapshot() == raids_before and _runtime.event_service.get_instance(&"event.instance.incomplete").state == EventInstance.State.CANCELLED, "missing interval creates no threat and preserves every existing raid")
|
|
|
|
|
|
func _test_replay_conflict_and_manual_provenance_rejection() -> void:
|
|
_reset_runtime(92_002)
|
|
_create_staff_and_facility(&"guard.event.replay", &"objective.event.replay")
|
|
var action := _event_raid_action(&"objective.event.replay", "BANKRUPTCY_RIOT")
|
|
_expect(_register_threat_event(&"event.fixture.replay", [action]).is_success(), "replay fixture definition registers")
|
|
_expect(_enqueue_threat_event(&"event.fixture.replay", &"event.instance.replay", &"male.guest.cause.fixture").is_success(), "disclosed cause is queued")
|
|
_advance(1)
|
|
var raid_id := _event_raid_id(&"event.instance.replay", action.action_id)
|
|
_expect(_register_defender(raid_id, &"guard.event.replay", 50).is_success() and _register_objective(raid_id, &"objective.event.replay", 20).is_success(), "ordinary defense assignment connects real employee and facility")
|
|
_expect(_submit(&"start_defense_raid", {&"raid_id": raid_id}).is_success(), "ordinary start command begins the configured incident")
|
|
_advance(5)
|
|
var context := {&"event_instance_id": &"event.instance.replay", &"threat_source_id": &"male.guest.cause.fixture"}
|
|
var before: Dictionary = _runtime.create_snapshot()
|
|
var replay: Dictionary = _runtime._execute_event_action_boundary(action, &"apply", context, null)
|
|
_expect(replay.get(&"ok", false) and replay.get(&"is_replay", false) and _runtime.create_snapshot() == before, "event-action replay preserves active combat, staff locks, resources, RNG, clock and event log")
|
|
var conflicting := EventAction.from_variant(action.create_snapshot())
|
|
(conflicting.payload[&"definition"][&"waves"] as Array)[0][&"threat_strength"] += 1
|
|
var rejected: Dictionary = _runtime._execute_event_action_boundary(conflicting, &"apply", context, null)
|
|
_expect(not rejected.get(&"ok", true) and _runtime.create_snapshot() == before, "same cause/action with a conflicting template never replaces its existing battle")
|
|
var forged_definition := _threat_definition(&"objective.event.replay")
|
|
forged_definition[&"event_source"] = _runtime.defense_service.get_raid(raid_id)[&"event_source"]
|
|
var defense_before: Dictionary = _runtime.defense_service.create_snapshot()
|
|
_expect(not _submit(&"create_defense_raid", {&"raid_id": &"forged.manual.provenance", &"definition": forged_definition}).is_success() and _runtime.defense_service.create_snapshot() == defense_before, "manual raid API cannot forge event provenance")
|
|
|
|
|
|
func _test_rollback_of_later_failed_action() -> void:
|
|
_reset_runtime(92_003)
|
|
_create_staff_and_facility(&"guard.event.rollback", &"objective.event.rollback")
|
|
_expect(_runtime.staff_service.create_task(&"fixture.work", 20, _clock.absolute_minute, {}, &"task.event.duplicate").is_success(), "disclosed duplicate task is prepared for apply-time failure")
|
|
var threat := _event_raid_action(&"objective.event.rollback", "BANK_DELINQUENCY")
|
|
var duplicate := EventAction.new().configure(&"fail.after.threat", EventAction.Type.CREATE_TASK, {&"task_id": &"task.event.duplicate", &"task_type": &"fixture.work"})
|
|
_expect(_register_threat_event(&"event.fixture.rollback", [threat, duplicate]).is_success(), "rollback-all event includes threat followed by an apply-time failure")
|
|
_expect(_enqueue_threat_event(&"event.fixture.rollback", &"event.instance.rollback", &"loan.overdue.cause.fixture").is_success(), "disclosed overdue cause enters the queue without claiming a real loan")
|
|
var before: Dictionary = _runtime.defense_service.create_snapshot()
|
|
var rng_before: Dictionary = _runtime.get_rng_stream(&"defense").snapshot()
|
|
_advance(1)
|
|
before[&"current_minute"] = _clock.absolute_minute
|
|
var raid_id := _event_raid_id(&"event.instance.rollback", threat.action_id)
|
|
_expect(_runtime.defense_service.create_snapshot() == before and _runtime.get_rng_stream(&"defense").snapshot() == rng_before, "later action failure rolls the new incident and its provenance back")
|
|
_expect(_runtime.defense_service.get_raid(raid_id).is_empty() and _count_domain_events(&"DEFENSE_RAID_CREATED", raid_id) == 0, "rolled-back incident leaves no committed creation event")
|
|
_expect(_runtime.event_service.get_instance(&"event.instance.rollback").state == EventInstance.State.CANCELLED, "failed event follows the existing cancellation policy")
|
|
|
|
|
|
func _test_save_branch_provenance_corruption_and_legacy() -> void:
|
|
_reset_runtime(92_004)
|
|
_create_staff_and_facility(&"guard.event.save", &"objective.event.save")
|
|
var action := _event_raid_action(&"objective.event.save", "THIEF")
|
|
_expect(_register_threat_event(&"event.fixture.save", [action]).is_success(), "save fixture definition registers")
|
|
_expect(_enqueue_threat_event(&"event.fixture.save", &"event.instance.save", &"thief.cause.fixture").is_success(), "save fixture source enters queue")
|
|
var queued: Dictionary = _runtime.create_snapshot()
|
|
_advance(1)
|
|
var expected: Dictionary = _runtime.create_snapshot()
|
|
_expect(_runtime.restore_snapshot(queued), "queued configured threat restores before execution")
|
|
_advance(1)
|
|
_expect(_runtime.create_snapshot() == expected, "save/restart branch produces the exact same event-derived raid ID, provenance, event and command state")
|
|
var raid_id := _event_raid_id(&"event.instance.save", action.action_id)
|
|
for kind: String in ["digest", "type", "event", "source", "interval", "wave_limit", "wave_strength"]:
|
|
var corrupt: Dictionary = expected.duplicate(true)
|
|
var raids: Array = corrupt[&"systems"][&"runtime"][&"defense"][&"raids"]
|
|
var raid: Dictionary = raids[0]
|
|
if kind == "digest": raid[&"event_source"]["template_digest"] = "a".repeat(64)
|
|
elif kind == "type": raid[&"event_source"] = []
|
|
elif kind == "event": raid[&"event_source"]["event_instance_id"] = "missing.event"
|
|
elif kind == "interval": raid[&"round_minutes"] = 7
|
|
elif kind == "wave_limit": (raid[&"waves"] as Array)[0][&"max_rounds"] += 1
|
|
elif kind == "wave_strength":
|
|
(raid[&"waves"] as Array)[0][&"threat_strength"] += 1
|
|
(raid[&"waves"] as Array)[0][&"remaining_threat"] += 1
|
|
else: raid[&"source_id"] = "unrelated.cause"
|
|
_expect(not _runtime.restore_snapshot(corrupt) and _runtime.create_snapshot() == expected, "corrupt event provenance is rejected atomically: " + kind)
|
|
_expect(_runtime.defense_service.get_raid(raid_id)[&"event_source"]["template_digest"].length() == 64, "valid event provenance remains after all rejected restores")
|
|
_expect(_submit(&"set_defense_retreat_policy", {&"raid_id": raid_id, &"policy": &"PROTECT_AND_RETREAT", &"threshold": 35}).is_success(), "normal player policy remains mutable after event creation")
|
|
var changed_policy: Dictionary = _runtime.create_snapshot()
|
|
_expect(_runtime.restore_snapshot(changed_policy) and _runtime.create_snapshot() == changed_policy, "immutable template validation preserves lawful policy changes")
|
|
_reset_runtime(92_005)
|
|
_create_staff_and_facility(&"guard.event.legacy", &"objective.event.legacy")
|
|
_expect(_submit(&"create_defense_raid", {&"raid_id": &"raid.legacy.manual", &"definition": _threat_definition(&"objective.event.legacy")}).is_success(), "real manual raid exists before legacy provenance migration")
|
|
var legacy: Dictionary = _runtime.create_snapshot()
|
|
legacy[&"systems"][&"runtime"][&"runtime_schema_version"] = 12
|
|
preload("res://tests/fixtures/pre_auto_purchase_runtime.gd").strip_empty(legacy[&"systems"][&"runtime"])
|
|
(legacy[&"systems"][&"runtime"][&"defense"][&"raids"] as Array)[0].erase(&"event_source")
|
|
var clean: Dictionary = legacy[&"systems"][&"runtime"][&"facility_cleanliness"].duplicate(true)
|
|
_expect(_runtime.restore_snapshot(legacy) and _runtime.facility_cleanliness.create_snapshot() == clean, "version-12 save keeps its required cleaning state when migrating to event schema 13")
|
|
_expect(not clean["facilities"].is_empty() and _runtime.defense_service.get_raid(&"raid.legacy.manual")[&"event_source"].is_empty(), "legacy migration preserves a nonempty cleanliness participant and old manual raid")
|
|
var migrated: Dictionary = _runtime.create_snapshot()
|
|
_expect(migrated[&"systems"][&"runtime"][&"runtime_schema_version"] == 14, "legacy12 re-emits current14 without losing required12 data")
|
|
var missing_clean: Dictionary = legacy.duplicate(true)
|
|
missing_clean[&"systems"][&"runtime"].erase(&"facility_cleanliness")
|
|
_expect(not _runtime.restore_snapshot(missing_clean) and _runtime.create_snapshot() == migrated, "legacy12 missing mandatory cleanliness is rejected atomically")
|
|
var malformed_clean: Dictionary = legacy.duplicate(true)
|
|
malformed_clean[&"systems"][&"runtime"][&"facility_cleanliness"]["schema_version"] = 99
|
|
_expect(not _runtime.restore_snapshot(malformed_clean) and _runtime.create_snapshot() == migrated, "legacy12 malformed mandatory cleanliness is rejected atomically")
|
|
var future: Dictionary = _runtime.create_snapshot()
|
|
var current: Dictionary = future.duplicate(true)
|
|
future[&"systems"][&"runtime"][&"runtime_schema_version"] = 15
|
|
_expect(not _runtime.restore_snapshot(future) and _runtime.create_snapshot() == current, "unknown future runtime schema remains rejected")
|
|
|
|
|
|
func _test_choice_replay_and_real_cost_commit_failure() -> void:
|
|
for commit_failure: bool in [false, true]:
|
|
_reset_runtime(92_006 if not commit_failure else 92_007)
|
|
_create_staff_and_facility(&"guard.event.choice", &"objective.event.choice")
|
|
var instance_id := &"event.instance.choice.fixture"
|
|
var threat := _event_raid_action(&"objective.event.choice", "THIEF")
|
|
var actions: Array[Dictionary] = [threat.create_snapshot()]
|
|
if commit_failure:
|
|
# This disclosed action spends the actual reserved escrow before the
|
|
# real commit. There is no mocked executor, cost callback or clock.
|
|
var consume := EventAction.new().configure(&"fixture.consume.escrow", EventAction.Type.ADD_LEDGER_ENTRY, {
|
|
&"from_account": StringName("EVENT_ESCROW:%s" % instance_id),
|
|
&"to_account": &"OPERATING_EXPENSE", &"amount": 7,
|
|
})
|
|
actions.append(consume.create_snapshot())
|
|
var registered: CommandResult = _runtime.submit_command(&"register_event_definition", {&"definition": {
|
|
&"event_id": &"event.fixture.choice", &"category": &"DEFENSE", &"foreground": false,
|
|
&"transaction_policy": &"ROLLBACK_ALL", &"choices": [{&"choice_id": &"fixture.choice",
|
|
&"text_key": &"fixture.choice.text", &"cost": {&"gold": 7}, &"actions": actions}],
|
|
}})
|
|
_expect(registered.is_success() and _enqueue_threat_event(&"event.fixture.choice", instance_id, &"choice.cause.fixture").is_success(), "disclosed choice threat registers and enters the actual event queue")
|
|
_advance(1)
|
|
var instance: EventInstance = _runtime.event_service.get_instance(instance_id)
|
|
_expect(instance.state == EventInstance.State.WAITING_CHOICE, "ordinary event phase waits for an actual choice before creating its raid")
|
|
var before: Dictionary = _runtime.defense_service.create_snapshot()
|
|
var cash_before: int = _runtime.economy_service.get_balance(&"PLAYER_CASH")
|
|
var expense_before: int = _runtime.economy_service.get_balance(&"OPERATING_EXPENSE")
|
|
var payload := {&"event_instance_id": instance_id, &"choice_instance_id": instance.choice_instance_id, &"choice_id": &"fixture.choice"}
|
|
var first := _submit(&"submit_event_choice", payload)
|
|
var raid_id := _event_raid_id(instance_id, threat.action_id)
|
|
if commit_failure:
|
|
_expect(not first.is_success() and _runtime.defense_service.create_snapshot() == before, "real cost commit failure rolls back the newly-created raid and provenance")
|
|
_expect(_runtime.economy_service.get_balance(&"PLAYER_CASH") == cash_before and _runtime.economy_service.get_balance(&"OPERATING_EXPENSE") == expense_before, "failed commit rolls back its drain action and releases the actual escrow once")
|
|
_expect(_count_domain_events(&"DEFENSE_RAID_CREATED", raid_id) == 0 and _runtime.economy_service.get_balance(StringName("EVENT_ESCROW:%s" % instance_id)) == 0, "failed choice leaves no committed threat notification or stranded escrow")
|
|
else:
|
|
_expect(first.is_success() and _runtime.defense_service.get_raid(raid_id)[&"state"] == DefenseService.RaidState.PREPARING, "actual successful choice creates one preparing incident")
|
|
_expect(_runtime.economy_service.get_balance(&"PLAYER_CASH") == cash_before - 7 and _runtime.economy_service.get_balance(&"OPERATING_EXPENSE") == expense_before + 7, "successful choice commits its disclosed fixture cost once")
|
|
var defense_after: Dictionary = _runtime.defense_service.create_snapshot()
|
|
var economy_after: Dictionary = _runtime.economy_service.create_snapshot()
|
|
var events_after: Dictionary = _runtime.event_service.create_snapshot()
|
|
# Successful choice commands legitimately resume the real clock. Pause
|
|
# through its public API to submit and observe the retry immediately.
|
|
_clock.set_paused(true)
|
|
var replay := _submit(&"submit_event_choice", payload)
|
|
_expect(replay.is_replay and replay.is_success() == first.is_success() and _runtime.defense_service.create_snapshot() == defense_after and _runtime.economy_service.create_snapshot() == economy_after and _runtime.event_service.create_snapshot() == events_after, "different command key replays the same real choice result without threat creation or payment retry")
|
|
_expect(_runtime.economy_service.validate_ledger()[&"ok"] and _runtime.event_service.validate_invariants()[&"ok"], "configured threat choice preserves actual Event and double-entry invariants")
|
|
|
|
|
|
func _threat_definition(objective: StringName) -> Dictionary:
|
|
return {&"entry_points": [&"fixture.event.entrance"], &"objective_ids": [objective],
|
|
&"round_minutes": 5, &"max_duration_minutes": 120,
|
|
&"retreat_policy": &"HOLD", &"defender_retreat_threshold": 0,
|
|
&"terrain_bonus": 0, &"command_bonus": 0, &"surprise_penalty": 0, &"multiple_entry_penalty": 0,
|
|
&"waves": [{&"threat_strength": 600, &"max_rounds": 3, &"retreat_threshold": 0}]}
|
|
|
|
|
|
func _event_raid_action(objective: StringName, kind: String) -> EventAction:
|
|
return EventAction.new().configure(&"configured.threat", EventAction.Type.CREATE_DEFENSE_RAID, {&"template_id": &"fixture.template.explicit", &"source_kind": kind, &"definition": _threat_definition(objective)})
|
|
|
|
|
|
func _register_threat_event(event_id: StringName, actions: Array) -> CommandResult:
|
|
var snapshots: Array[Dictionary] = []
|
|
for action: EventAction in actions: snapshots.append(action.create_snapshot())
|
|
return _runtime.submit_command(&"register_event_definition", {&"definition": {&"event_id": event_id, &"category": &"DEFENSE", &"foreground": false, &"transaction_policy": &"ROLLBACK_ALL", &"automatic_actions": snapshots}})
|
|
|
|
|
|
func _enqueue_threat_event(event_id: StringName, instance_id: StringName, source_id: StringName) -> CommandResult:
|
|
return _runtime.submit_command(&"enqueue_event", {&"event_id": event_id, &"actor_ids": [], &"options": {&"event_instance_id": instance_id, &"context": {&"threat_source_id": source_id}}})
|
|
|
|
|
|
func _event_raid_id(instance_id: StringName, action_id: StringName) -> StringName:
|
|
return StringName("event_defense_raid." + JSON.stringify([String(instance_id), String(action_id)], "", true, true).sha256_text())
|
|
|
|
|
|
func _test_serialized_action_enum_rejection() -> void:
|
|
_reset_runtime(92_008)
|
|
_create_staff_and_facility(&"guard.event.enum", &"objective.event.enum")
|
|
var action := _event_raid_action(&"objective.event.enum", "THIEF")
|
|
var bad_types: Array = [999, -1, "FUTURE_UNKNOWN_ACTION", 1.5, true, null]
|
|
for index: int in range(bad_types.size()):
|
|
var raw: Dictionary = action.create_snapshot()
|
|
raw[&"type"] = bad_types[index]
|
|
var event_id := StringName("event.enum.invalid.%d" % index)
|
|
var defense_before: Dictionary = _runtime.defense_service.create_snapshot()
|
|
var result: CommandResult = _runtime.submit_command(&"register_event_definition", {&"definition": {&"event_id": event_id, &"category": &"DEFENSE", &"automatic_actions": [raw]}})
|
|
_expect(not result.is_success() and _runtime.event_service.get_definition(event_id) == null and _runtime.defense_service.create_snapshot() == defense_before, "actual event registration rejects an unknown serialized action type without dropping or coercing it: %d" % index)
|
|
_expect(_register_threat_event(&"event.fixture.enum", [action]).is_success() and _enqueue_threat_event(&"event.fixture.enum", &"event.instance.enum", &"cause.fixture.enum").is_success(), "valid queued event exists for corrupt enum restore tests")
|
|
var queued: Dictionary = _runtime.create_snapshot()
|
|
for raw_type: Variant in bad_types:
|
|
var corrupt: Dictionary = queued.duplicate(true)
|
|
for raw_definition: Dictionary in corrupt[&"systems"][&"runtime"][&"event_definitions"]:
|
|
if String(raw_definition[&"event_id"]) == "event.fixture.enum":
|
|
(raw_definition[&"automatic_actions"] as Array)[0][&"type"] = raw_type
|
|
_expect(not _runtime.restore_snapshot(corrupt) and _runtime.create_snapshot() == queued, "queued complete threat template rejects a corrupt action enum atomically")
|
|
var integer_enum: Dictionary = queued.duplicate(true)
|
|
for raw_definition: Dictionary in integer_enum[&"systems"][&"runtime"][&"event_definitions"]:
|
|
if String(raw_definition[&"event_id"]) == "event.fixture.enum":
|
|
(raw_definition[&"automatic_actions"] as Array)[0][&"type"] = EventAction.Type.CREATE_DEFENSE_RAID
|
|
_expect(_runtime.restore_snapshot(integer_enum) and _runtime.create_snapshot() == queued, "known serialized integer enum remains compatible and canonicalizes to its name")
|
|
|
|
|
|
func _test_failure_policy_and_expiry() -> void:
|
|
for policy: String in ["SKIP_FAILED", "BRANCH_FAILURE", "EXPIRED"]:
|
|
_reset_runtime(92_020)
|
|
_create_staff_and_facility(&"guard.event.policy", &"objective.event.policy")
|
|
_expect(_runtime.staff_service.create_task(&"fixture.work", 20, _clock.absolute_minute, {}, &"task.event.policy.duplicate").is_success(), "actual duplicate task exists for policy failure")
|
|
var primary := _event_raid_action(&"objective.event.policy", "THIEF")
|
|
var duplicate := EventAction.new().configure(&"fail.policy", EventAction.Type.CREATE_TASK, {&"task_id": &"task.event.policy.duplicate", &"task_type": &"fixture.work"})
|
|
var fallback := _event_raid_action(&"objective.event.policy", "AUTHORITY_ESCALATION")
|
|
fallback.action_id = &"fallback.threat"
|
|
var definition := {&"event_id": &"event.fixture.policy", &"category": &"DEFENSE", &"foreground": false, &"automatic_actions": [primary.create_snapshot(), duplicate.create_snapshot()]}
|
|
if policy == "EXPIRED":
|
|
definition[&"transaction_policy"] = &"ROLLBACK_ALL"
|
|
definition[&"fallback_actions"] = [fallback.create_snapshot()]
|
|
else:
|
|
definition[&"transaction_policy"] = policy
|
|
definition[&"failure_actions"] = [fallback.create_snapshot()]
|
|
_expect(_runtime.submit_command(&"register_event_definition", {&"definition": definition}).is_success(), "real Event registers policy " + policy)
|
|
var options := {&"event_instance_id": &"event.instance.policy", &"context": {&"threat_source_id": &"cause.policy.fixture"}}
|
|
if policy == "EXPIRED": options[&"expires_at"] = _clock.absolute_minute
|
|
_expect(_runtime.submit_command(&"enqueue_event", {&"event_id": &"event.fixture.policy", &"actor_ids": [], &"options": options}).is_success(), "real Event queue accepts policy cause " + policy)
|
|
_advance(1)
|
|
var primary_id := _event_raid_id(&"event.instance.policy", primary.action_id)
|
|
var fallback_id := _event_raid_id(&"event.instance.policy", fallback.action_id)
|
|
var expected_id := primary_id if policy == "SKIP_FAILED" else fallback_id
|
|
var missing_id := fallback_id if policy == "SKIP_FAILED" else primary_id
|
|
_expect(_runtime.defense_service.get_raid_ids() == [expected_id] and _runtime.defense_service.get_raid(missing_id).is_empty(), "policy commits only the intended threat and discards rolled-back primary: " + policy)
|
|
_expect(_count_domain_events(&"DEFENSE_RAID_CREATED", expected_id) == 1 and _count_domain_events(&"DEFENSE_RAID_CREATED", missing_id) == 0, "policy leaves exactly one committed incident notification: " + policy)
|
|
var instance: EventInstance = _runtime.event_service.get_instance(&"event.instance.policy")
|
|
_expect(instance.state == (EventInstance.State.EXPIRED if policy == "EXPIRED" else EventInstance.State.COMPLETED), "policy preserves its real Event terminal state: " + policy)
|
|
var saved: Dictionary = _runtime.create_snapshot()
|
|
_expect(_runtime.restore_snapshot(saved) and _runtime.create_snapshot() == saved, "non-primary threat provenance restores exactly: " + policy)
|
|
|
|
|
|
func _test_event_rollback_preserves_failed_round_guard() -> void:
|
|
_reset_runtime(92_021)
|
|
_create_staff_and_facility(&"guard.event.failure", &"objective.event.failure")
|
|
_create_staff_and_facility(&"guard.event.uncommitted", &"objective.event.uncommitted")
|
|
var prior_definition := _threat_definition(&"objective.event.failure")
|
|
prior_definition[&"waves"][0][&"max_rounds"] = 1
|
|
_expect(_submit(&"create_defense_raid", {&"raid_id": &"raid.event.prior", &"definition": prior_definition}).is_success(), "real existing incident precedes Event rollback")
|
|
_expect(_register_defender(&"raid.event.prior", &"guard.event.failure", 90).is_success() and _register_objective(&"raid.event.prior", &"objective.event.failure", 20).is_success() and _submit(&"start_defense_raid", {&"raid_id": &"raid.event.prior"}).is_success(), "prior real defense has an automatic due round")
|
|
var failure := {&"calls": 0}
|
|
var normal_outcome := Callable(_runtime, "_apply_defense_outcome_boundary")
|
|
var injected := func(payload: Dictionary, phase: StringName, token: Variant) -> Dictionary:
|
|
var report: Dictionary = normal_outcome.call(payload, phase, token)
|
|
if phase == &"apply":
|
|
failure[&"calls"] += 1
|
|
if bool(report.get(&"ok", false)):
|
|
report[&"ok"] = false
|
|
report[&"error"] = "Disclosed real post-apply failure before Event rollback."
|
|
return report
|
|
_runtime.defense_service.configure_callbacks(Callable(_runtime, "_roll_defense_round"), Callable(_runtime, "_apply_defense_skill_boundary"), injected, Callable(_runtime, "_apply_defense_rng_boundary"))
|
|
_clock.set_paused(false)
|
|
_clock.advance_minutes(5)
|
|
_expect(_clock.paused and failure[&"calls"] == 1 and _runtime.defense_service.get_raid(&"raid.event.prior")[&"current_round"] == 0, "real automatic round fails atomically and pauses once")
|
|
_expect(_runtime.staff_service.create_task(&"fixture.work", 20, _clock.absolute_minute, {}, &"task.event.guard.duplicate").is_success(), "Event later apply-time failure uses real duplicate task")
|
|
var threat := _event_raid_action(&"objective.event.uncommitted", "THIEF")
|
|
var duplicate := EventAction.new().configure(&"fail.guard", EventAction.Type.CREATE_TASK, {&"task_id": &"task.event.guard.duplicate", &"task_type": &"fixture.work"})
|
|
_expect(_register_threat_event(&"event.fixture.guard", [threat, duplicate]).is_success() and _enqueue_threat_event(&"event.fixture.guard", &"event.instance.guard", &"cause.guard.fixture").is_success(), "real failed-minute Event registers and queues")
|
|
var defense_before: Dictionary = _runtime.defense_service.create_snapshot()
|
|
var rng_before: Dictionary = _runtime.get_rng_stream(&"defense").snapshot()
|
|
var failed_event: CommandResult = _runtime.event_service.start_next_event(_clock.absolute_minute)
|
|
_expect(not failed_event.is_success() and _runtime.defense_service.create_snapshot() == defense_before and _runtime.get_rng_stream(&"defense").snapshot() == rng_before, "Event rollback restores existing Defense and RNG after newly-created incident")
|
|
_expect(_count_domain_events(&"DEFENSE_AUTOMATIC_ROUND_FAILED", &"raid.event.prior") == 1 and _count_domain_events(&"DEFENSE_RAID_CREATED", _event_raid_id(&"event.instance.guard", threat.action_id)) == 0, "Event rollback keeps prior failure diagnostic while removing uncommitted creation")
|
|
_runtime._advance_defense(_clock.absolute_minute)
|
|
_expect(failure[&"calls"] == 1 and _runtime.defense_service.get_raid(&"raid.event.prior")[&"current_round"] == 0, "Event rollback cannot clear the real same-minute automatic attempt guard")
|
|
_runtime._configure_defense_boundaries()
|
|
_clock.set_paused(false)
|
|
_clock.advance_minutes(1)
|
|
_clock.set_paused(true)
|
|
_expect(_runtime.defense_service.get_raid(&"raid.event.prior")[&"current_round"] == 1, "next real minute resumes prior incident after its failed attempt")
|