681 lines
48 KiB
GDScript
681 lines
48 KiB
GDScript
extends SceneTree
|
|
const FixtureCleanup := preload("res://tests/helpers/ui_audio_fixture_cleanup.gd")
|
|
const Scenes := preload("res://tests/helpers/p16_dismissal_fixture.gd")
|
|
|
|
## P16-01-DISMISS: dismissal of a general employee (FREE_HIRE) by the ordinary
|
|
## dismiss_staff command, with the A14 severance (three days of the effective daily
|
|
## wage from the front fund, the hidden fund covering the rest), the existing
|
|
## removal contract, the refusals R1-R9 and the cleanup of SPEC 6.2/6.2.1 at the
|
|
## command boundary. Every scene runs the production Runtime and its own rules;
|
|
## fixtures only place employees, Tasks, rescue states, Events, raids and balances,
|
|
## never the dismissal under test. The last scene dismisses from the game's own
|
|
## Main staff panel (F9), so the runner gives this suite the ordinary Main audio
|
|
## cleanup proof (tools/regression/suite-policy.json).
|
|
|
|
const FRONT := Scenes.FRONT
|
|
const BACK := Scenes.BACK
|
|
const RESCUE_PHASES := [
|
|
"rescue_pickup/MOVING/-/single", "rescue_pickup/MOVING/QUEUED/single", "rescue_pickup/MOVING/BOARDED/single",
|
|
"rescue_transport/MOVING/QUEUED/pair", "rescue_transport/MOVING/BOARDED/pair",
|
|
"rescue_transport/MOVING/-/single", "rescue_transport/WORKING/-/single",
|
|
]
|
|
|
|
var _checks := 0
|
|
var _failures := 0
|
|
var _scenes: Scenes
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
print("P16-01-DISMISS: general employee dismissal")
|
|
_scenes = Scenes.new(_expect)
|
|
_test_ledger_day()
|
|
_test_top_up_and_insufficient_funds()
|
|
_test_category_refusals()
|
|
_test_queued_commands_for_the_same_employee()
|
|
_test_bankrupt_refusal()
|
|
_test_external_task_refusal()
|
|
_test_reserved_task()
|
|
_test_facility_duty_and_service()
|
|
_test_walking_commute()
|
|
_test_rescue_matrix()
|
|
_test_event_actors()
|
|
_test_defense_refusal()
|
|
_test_commit_failure_rolls_back()
|
|
_test_old_save_gains_the_severance_account()
|
|
await _test_dismiss_from_main()
|
|
await process_frame
|
|
if _failures == 0:
|
|
print("PASS: %d checks" % _checks)
|
|
else:
|
|
push_error("FAIL: %d of %d checks failed" % [_failures, _checks])
|
|
quit(_failures)
|
|
|
|
|
|
func _expect(condition: bool, message: String) -> void:
|
|
_checks += 1
|
|
if not condition:
|
|
_failures += 1
|
|
push_error(message)
|
|
|
|
|
|
# --- SPEC 5: what a refusal may change -------------------------------------------
|
|
|
|
func _without(snapshot: Dictionary, keys: Array) -> Dictionary:
|
|
var copy := snapshot.duplicate(true)
|
|
var runtime_data: Dictionary = copy[&"systems"][&"runtime"]
|
|
for key: Variant in keys:
|
|
runtime_data.erase(key)
|
|
return copy
|
|
|
|
|
|
func _without_command_record(snapshot: Dictionary) -> Dictionary:
|
|
return _without(snapshot, [&"next_command_id", &"command_queue", &"id_generator", &"domain_events"])
|
|
|
|
|
|
## SPEC 5.c/5.d: the four command sections hold exactly the refused command's
|
|
## record; every other section is byte-identical.
|
|
func _only_command_record_added(before: Dictionary, after: Dictionary, command_id: int, result: CommandResult, key: StringName) -> bool:
|
|
var b: Dictionary = before[&"systems"][&"runtime"]
|
|
var a: Dictionary = after[&"systems"][&"runtime"]
|
|
if int(a[&"next_command_id"]) != command_id + 1 or int(b[&"next_command_id"]) != command_id:
|
|
return false
|
|
var counters: Dictionary = (b[&"id_generator"]["counters"] as Dictionary).duplicate()
|
|
counters["domain_event"] = int(counters.get("domain_event", 0)) + 1
|
|
if a[&"id_generator"]["counters"] != counters:
|
|
return false
|
|
var bq: Dictionary = b[&"command_queue"]
|
|
var aq: Dictionary = a[&"command_queue"]
|
|
var processed: Array = aq["processed"]
|
|
var accepted: Array = aq["accepted"]
|
|
var idempotency: Dictionary = (bq["idempotency"] as Dictionary).duplicate()
|
|
if not key.is_empty():
|
|
idempotency[String(key)] = command_id
|
|
if aq["pending"] != bq["pending"] or aq["in_flight"] != bq["in_flight"] or aq["idempotency"] != idempotency \
|
|
or processed.size() != (bq["processed"] as Array).size() + 1 or processed.slice(0, processed.size() - 1) != bq["processed"] \
|
|
or processed[-1] != result.to_dictionary() or accepted.size() != (bq["accepted"] as Array).size() + 1 \
|
|
or accepted.slice(0, accepted.size() - 1) != bq["accepted"] or int(accepted[-1]["command_id"]) != command_id:
|
|
return false
|
|
var b_ids: Array = b[&"domain_events"]["published_ids"]
|
|
var a_ids: Array = a[&"domain_events"]["published_ids"]
|
|
var prior: Array = b[&"domain_events"]["recent_events"]
|
|
var recent: Array = a[&"domain_events"]["recent_events"]
|
|
var added: Dictionary = recent[-1]
|
|
# The stream keeps its newest 256 events; the oldest one may leave it.
|
|
var kept := recent.slice(0, recent.size() - 1)
|
|
return a_ids.size() == b_ids.size() + 1 and a_ids.has(added["event_id"]) and not b_ids.has(added["event_id"]) \
|
|
and added["event_type"] == "COMMAND_FAILED" and int(added["causation_command_id"]) == command_id \
|
|
and kept == prior.slice(prior.size() - kept.size())
|
|
|
|
|
|
func _expect_executor_refusal(fixture: Dictionary, staff_id: StringName, reason: StringName, label: String, key: StringName = &"") -> CommandResult:
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var before: Dictionary = runtime.create_snapshot()
|
|
var command_id := int(before[&"systems"][&"runtime"][&"next_command_id"])
|
|
var result := _scenes.dismiss(fixture, staff_id, key)
|
|
var after: Dictionary = runtime.create_snapshot()
|
|
_expect(not result.is_success() and result.command_id == command_id and StringName(result.details.get(&"reason", &"")) == reason,
|
|
"%s: refused with %s (%s %s)" % [label, reason, result.message, result.details])
|
|
_expect(var_to_bytes(_without_command_record(before)) == var_to_bytes(_without_command_record(after)), "%s: every other section of the save is byte-identical (5.c)" % label)
|
|
_expect(_only_command_record_added(before, after, command_id, result, key), "%s: only the command id, its failed result and one COMMAND_FAILED event were added (5.d)" % label)
|
|
return result
|
|
|
|
|
|
## SPEC 5.b: refused before the command is accepted; the whole save is byte-identical.
|
|
func _expect_admission_refusal(fixture: Dictionary, staff_id: StringName, key: StringName, label: String) -> CommandResult:
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var before := var_to_bytes(runtime.create_snapshot())
|
|
var result := _scenes.dismiss(fixture, staff_id, key)
|
|
_expect(not result.is_success() and var_to_bytes(runtime.create_snapshot()) == before, "%s: refused before acceptance, the whole save is byte-identical (5.b)" % label)
|
|
return result
|
|
|
|
|
|
# --- SPEC 6.2: the cleanup at the command boundary --------------------------------
|
|
|
|
func _count_removed(runtime: Variant, staff_id: StringName) -> int:
|
|
var count := 0
|
|
for event in runtime.domain_events.recent_events():
|
|
if event.event_type == &"STAFF_REMOVED" and staff_id in event.entity_ids:
|
|
count += 1 if StringName(event.payload.get(&"reason", &"")) == &"DISMISSED" else 100
|
|
return count
|
|
|
|
|
|
func _expect_boundary(fixture: Dictionary, staff_id: StringName, label: String) -> void:
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var dangling: Array[String] = _scenes.dangling_references(runtime, staff_id)
|
|
_expect(dangling.is_empty(), "%s: no live reference to the dismissed employee remains %s" % [label, dangling])
|
|
_expect(_count_removed(runtime, staff_id) == 1, "%s: exactly one STAFF_REMOVED with reason DISMISSED" % label)
|
|
_expect(runtime.staff_service.validate_invariants()[&"ok"], "%s: Staff and Task ownership stays consistent" % label)
|
|
var orphans: Dictionary = runtime.staff_service.audit_orphan_tasks()
|
|
_expect((orphans[&"reopened_task_ids"] as Array).is_empty() and (orphans[&"released_staff_ids"] as Array).is_empty()
|
|
and (orphans[&"release_failed_task_ids"] as Array).is_empty(), "%s: audit_orphan_tasks finds no orphan" % label)
|
|
_expect(runtime.economy_service.validate_ledger()[&"ok"], "%s: the ledger stays balanced" % label)
|
|
var saved: Dictionary = runtime.create_snapshot()
|
|
_expect(runtime.restore_snapshot(saved) and runtime.create_snapshot() == saved, "%s: a save right after the command restores exactly" % label)
|
|
var slot := "user://tests/p16-dismiss-boundary-%d" % OS.get_process_id()
|
|
var written: bool = runtime.save_to_path(slot).get(&"ok", false)
|
|
var loaded: bool = runtime.load_from_path(slot).get(&"ok", false)
|
|
SaveService.delete_save(slot)
|
|
# An ordinary load publishes its own load event; nothing else differs.
|
|
var events_only := [&"id_generator", &"domain_events"]
|
|
_expect(written and loaded and var_to_bytes(_without(runtime.create_snapshot(), events_only)) == var_to_bytes(_without(saved, events_only)),
|
|
"%s: the same save written to disk and loaded again is the same game" % label)
|
|
|
|
|
|
# --- Scenes -------------------------------------------------------------------------
|
|
|
|
## A1, A10, F1, F3, F4, F5: the ledger day script with its 00:00 closes.
|
|
func _test_ledger_day() -> void:
|
|
var fixture := _scenes.new_ledger_fixture()
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_scenes.play_ledger(fixture, 360, Scenes.LAST_MINUTE, func(minute: int, phase: String) -> void:
|
|
if minute != Scenes.DISMISS_MINUTE:
|
|
return
|
|
if phase == "before":
|
|
var worker: StaffRuntime = runtime.staff_service.get_staff(Scenes.DISMISSED)
|
|
_expect(worker != null and worker.employment_kind == StaffRuntime.EmploymentKind.FREE_HIRE and worker.current_task_id.is_empty()
|
|
and worker.state == StaffRuntime.State.OFF_DUTY, "A1: the general employee is off duty with no Task before the dismissal")
|
|
_expect(worker != null and worker.unpaid_wages == 120 and worker.get_effective_daily_wage() == 120, "A10: the first close left her daily wage 120 unpaid")
|
|
var preview: Dictionary = runtime.get_staff_dismissal_preview(Scenes.DISMISSED)
|
|
_expect(bool(preview[&"can_dismiss"]) and int(preview[&"severance"]) == 360 and int(preview[&"unpaid_wages"]) == 120
|
|
and int(preview[&"front_cash"]) == 300 and int(preview[&"available_funds"]) == 700, "the preview shows severance 360, unpaid 120 and funds 300 + 400")
|
|
return
|
|
var cash_entries: Array = runtime.economy_service.get_entries().filter(func(entry: LedgerEntry) -> bool:
|
|
return entry.source_entity_id == Scenes.DISMISSED and entry.absolute_minute == minute)
|
|
_expect(cash_entries.size() == 2 and cash_entries[0].transaction_id == cash_entries[1].transaction_id, "F3: the top-up and the severance are one transaction")
|
|
var categories := {}
|
|
for entry: LedgerEntry in cash_entries:
|
|
categories[entry.category] = [entry.debit_account, entry.credit_account, entry.amount, entry.absolute_minute]
|
|
_expect(categories.get(FinancePolicy.TOP_UP_CATEGORY) == [FRONT, BACK, 60, minute]
|
|
and categories.get(FinancePolicy.SEVERANCE_CATEGORY) == [FinancePolicy.SEVERANCE_EXPENSE, FRONT, 360, minute],
|
|
"F3: hidden 60 tops up the front fund, which pays 360 to the severance expense at the command minute")
|
|
_expect(runtime.economy_service.get_balance(FRONT) == 0 and runtime.economy_service.get_balance(BACK) == 340
|
|
and runtime.economy_service.get_balance(FinancePolicy.SEVERANCE_EXPENSE) == 360 and int(fixture[&"state"].get_resource(&"gold")) == 0,
|
|
"F3: front 0, hidden 340, severance expense 360 and the Gold mirror agree")
|
|
_expect(not runtime.staff_service.has_staff(Scenes.DISMISSED) and runtime.staff_service.get_departed_unpaid_wages(Scenes.DISMISSED) == 120,
|
|
"F1/F4: she leaves the roster; her unpaid 120 is held apart from the severance")
|
|
var first: CommandResult = runtime.command_queue.get_result_by_idempotency_key(&"p16.ledger.dismiss")
|
|
_expect(first != null and first.is_success() and int(first.details[&"unpaid_wages_preserved"]) == 120 and (first.details[&"removed_shift_ids"] as Array).size() == 1,
|
|
"4.2: the result lists the severance, the held wages and the removed Shift")
|
|
_expect_boundary(fixture, Scenes.DISMISSED, "A1")
|
|
var replay := _expect_admission_refusal(fixture, Scenes.DISMISSED, &"p16.ledger.dismiss", "F5 same key")
|
|
_expect(replay.code == CommandResult.Code.DUPLICATE_IDEMPOTENCY_KEY and (replay.details.get("original_result", {}) as Dictionary).get("details", {}).get(&"severance") == 360,
|
|
"F5: the resent key returns DUPLICATE_IDEMPOTENCY_KEY with the first result")
|
|
_expect_executor_refusal(fixture, Scenes.DISMISSED, &"NOT_FOUND", "R4 dismissed employee again", &"p16.ledger.dismiss.again")
|
|
_expect(_scenes.count_category(runtime, FinancePolicy.SEVERANCE_CATEGORY) == 1, "F5: the severance is paid once"))
|
|
var day2: Dictionary = runtime.operations_coordinator.get_day_summary(2)
|
|
_expect(not day2.is_empty() and int(day2[&"category_totals"][&"cost_of_goods"]) == 360 and int(day2[&"category_totals"][&"wages"]) == 90,
|
|
"F3/F4: the day 2 close counts the severance as an operating cost and the kept employee's wage only (%s)" % [day2.get(&"category_totals", {})])
|
|
_expect(runtime.staff_service.get_departed_unpaid_wages(Scenes.DISMISSED) == 0 and runtime.staff_service.get_departed_staff_ids().is_empty(),
|
|
"F4: the day 2 00:00 close pays the held wages")
|
|
var first_close := _payroll_payments(runtime, 1)
|
|
var second_close := _payroll_payments(runtime, 2)
|
|
_expect(int(first_close.get(Scenes.DISMISSED, 0)) == 0 and int(first_close.get(Scenes.KEPT, 0)) == 0
|
|
and second_close == {Scenes.DISMISSED: 120, Scenes.KEPT: 180}, "F4: nothing is paid at the first close; the departed 120 is paid once, at the day 2 close (%s %s)" % [first_close, second_close])
|
|
_expect(_scenes.count_category(runtime, FinancePolicy.SEVERANCE_CATEGORY) == 1 and runtime.economy_service.validate_ledger()[&"ok"],
|
|
"F3: one severance posting; the ledger is balanced after both closes")
|
|
_expect(int(day2[&"settlement"][&"funds"][&"rank_tax_arrears"]) == 30 and runtime.operations_coordinator.get_arrears_total() == 30,
|
|
"the hidden fund spent on the severance leaves 30 of the day 2 rank tax unpaid")
|
|
var saved: Dictionary = runtime.create_snapshot()
|
|
_expect(runtime.restore_snapshot(saved) and runtime.create_snapshot() == saved, "the game after the close, with the unpaid tax, restores exactly")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
func _payroll_payments(runtime: Variant, day: int) -> Dictionary:
|
|
var paid := {}
|
|
var settlement: Dictionary = runtime.staff_service.get_payroll_settlement(StringName("payroll-day-%08d" % day))
|
|
for payment: Dictionary in settlement.get(&"input_payments", []):
|
|
paid[StringName(payment[&"staff_id"])] = int(payment[&"amount"])
|
|
return paid
|
|
|
|
|
|
## F3 / R8: the hidden fund covers what the front fund cannot; a total one Gold
|
|
## short refuses the dismissal and changes nothing.
|
|
func _test_top_up_and_insufficient_funds() -> void:
|
|
var fixture := _scenes.new_fixture(16_020, true)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_marc"}).is_success(), "hire staff_marc (daily wage 170)")
|
|
_expect(_scenes.drain_front(fixture, "r8") and _scenes.sale(fixture, FRONT, 100, "r8.front"), "front 100, hidden 0")
|
|
_expect_executor_refusal(fixture, &"staff_marc", &"INSUFFICIENT_FUNDS", "R8 total 100 of 510")
|
|
_expect(_scenes.sale(fixture, BACK, 409, "r8.back"), "hidden 409")
|
|
var refused := _expect_executor_refusal(fixture, &"staff_marc", &"INSUFFICIENT_FUNDS", "R8 total 509 of 510")
|
|
_expect(int(refused.details[&"severance"]) == 510 and int(refused.details[&"available_funds"]) == 509, "R8: the refusal names the severance and the funds")
|
|
_expect(_scenes.sale(fixture, BACK, 1, "r8.back.last"), "hidden 410")
|
|
var result := _scenes.dismiss(fixture, &"staff_marc")
|
|
_expect(result.is_success() and int(result.details[&"severance"]) == 510 and int(result.details[&"severance_top_up"]) == 410
|
|
and runtime.economy_service.get_balance(FRONT) == 0 and runtime.economy_service.get_balance(BACK) == 0,
|
|
"F3: a total of exactly 510 pays it, 410 from the hidden fund")
|
|
_expect_boundary(fixture, &"staff_marc", "F3 top-up")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## R1 UNIQUE, R7 ADULT_CONTRACT, R4 NOT_FOUND and a malformed payload.
|
|
func _test_category_refusals() -> void:
|
|
var fixture := _scenes.new_fixture(16_030)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var anri := _scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"heroine_anri"})
|
|
_expect(anri.is_success() and runtime.staff_service.get_staff(&"heroine_anri").employment_kind == StaffRuntime.EmploymentKind.UNIQUE, "Anri joins as the approved UNIQUE employee")
|
|
var unique := _expect_executor_refusal(fixture, &"heroine_anri", &"UNIQUE", "R1 UNIQUE")
|
|
_expect(unique.message == "Unique Staff cannot be dismissed, sold or permanently removed.", "R1: the existing removal contract's text")
|
|
_expect(_scenes.command(fixture, &"register_staff", {&"staff_id": &"adult_contract", &"role_id": &"attendant",
|
|
&"options": {&"employment_kind": &"ADULT_CONTRACT", &"daily_wage": 100}}).is_success(), "register an ADULT_CONTRACT fixture")
|
|
_expect_executor_refusal(fixture, &"adult_contract", &"NOT_GENERAL_EMPLOYEE", "R7 ADULT_CONTRACT")
|
|
_expect_executor_refusal(fixture, &"nobody", &"NOT_FOUND", "R4 unknown employee")
|
|
var before: Dictionary = runtime.create_snapshot()
|
|
var malformed := _scenes.command(fixture, &"dismiss_staff", {})
|
|
_expect(not malformed.is_success() and malformed.code == CommandResult.Code.INVALID_PAYLOAD
|
|
and var_to_bytes(_without_command_record(runtime.create_snapshot())) == var_to_bytes(_without_command_record(before)), "a dismissal without a Staff id is refused (5.c)")
|
|
_expect(not bool(runtime.get_staff_dismissal_preview(&"heroine_anri")[&"can_dismiss"])
|
|
and runtime.get_staff_dismissal_preview(&"adult_contract")[&"reason"] == &"NOT_GENERAL_EMPLOYEE", "the previews refuse the same rows")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A9: another command queued for the dismissed employee is refused after the
|
|
## dismissal and changes nothing; a second queued dismissal pays nothing.
|
|
func _test_queued_commands_for_the_same_employee() -> void:
|
|
var fixture := _scenes.new_fixture(16_040)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_eri"}).is_success(), "hire staff_eri")
|
|
var next_minute: int = fixture[&"clock"].absolute_minute + 1
|
|
var assignment: CommandResult = runtime.submit_command(&"set_staff_work_assignment", {&"staff_id": &"staff_eri", &"facility_id": &"", &"template_id": &"NIGHT"},
|
|
&"player", &"staff_eri", 0, next_minute, &"p16.a9.assignment")
|
|
var second: CommandResult = runtime.submit_command(&"dismiss_staff", {&"staff_id": &"staff_eri"}, &"player", &"staff_eri", 0, next_minute, &"p16.a9.second")
|
|
_expect(assignment.is_success() and second.is_success() and (runtime.command_queue.create_snapshot()["pending"] as Array).size() == 2, "an assignment and a second dismissal wait for the next minute")
|
|
_expect(_scenes.dismiss(fixture, &"staff_eri").is_success(), "A9: the dismissal runs before the queued commands")
|
|
_expect_boundary(fixture, &"staff_eri", "A9")
|
|
fixture[&"clock"].advance_minutes(1)
|
|
var later: CommandResult = runtime.command_queue.get_processed_result(assignment.command_id)
|
|
var again: CommandResult = runtime.command_queue.get_processed_result(second.command_id)
|
|
_expect(later != null and not later.is_success() and StringName(later.details.get(&"reason", &"")) == &"STAFF_NOT_FOUND"
|
|
and runtime.staff_service.get_work_assignment(&"staff_eri").is_empty(), "A9: the queued assignment is refused as STAFF_NOT_FOUND and creates nothing")
|
|
_expect(again != null and not again.is_success() and StringName(again.details.get(&"reason", &"")) == &"NOT_FOUND"
|
|
and _scenes.count_category(runtime, FinancePolicy.SEVERANCE_CATEGORY) == 1, "A9: the queued second dismissal is NOT_FOUND and pays nothing")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## R5: after the game ends the command is refused before acceptance.
|
|
func _test_bankrupt_refusal() -> void:
|
|
var fixture := _scenes.new_fixture(16_050, true)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_eri"}).is_success(), "hire staff_eri")
|
|
fixture[&"clock"].advance_minutes(1439 - int(fixture[&"clock"].absolute_minute))
|
|
_expect(_scenes.drain_front(fixture, "r5"), "disclosed spend leaves no funds before the first close")
|
|
fixture[&"clock"].advance_minutes(4320 - int(fixture[&"clock"].absolute_minute))
|
|
_expect(runtime.operations_coordinator.is_terminal(), "three actual operating losses end the game (BANKRUPT)")
|
|
var refused := _expect_admission_refusal(fixture, &"staff_eri", &"", "R5 BANKRUPT")
|
|
_expect(StringName(refused.details.get(&"reason", &"")) == &"BANKRUPT" and runtime.staff_service.has_staff(&"staff_eri"), "R5: the existing BANKRUPT refusal keeps the employee")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## R2: an employee carrying supply logistics (an external operation) is kept until
|
|
## the operation ends; then the same command dismisses her.
|
|
func _test_external_task_refusal() -> void:
|
|
var fixture := _scenes.new_fixture(16_060)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var clock: Variant = fixture[&"clock"]
|
|
for row: Array in [[&"warehouse", Vector3i(-8, 0, 1)], [&"kitchen", Vector3i(2, 0, 1)], [&"staff_door", Vector3i(0, 0, 1)]]:
|
|
_expect(_scenes.command(fixture, &"build_facility", {&"definition_id": row[0], &"origin": row[1]}).is_success(), "build %s" % row[0])
|
|
clock.advance_minutes(180)
|
|
var source: StringName = &""
|
|
var destination: StringName = &""
|
|
for facility: FacilityInstance in runtime.facility_service.get_instances():
|
|
if facility.definition_id == &"warehouse": source = facility.instance_id
|
|
if facility.definition_id == &"kitchen": destination = facility.instance_id
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_gina"}).is_success()
|
|
and _scenes.command(fixture, &"set_staff_work_assignment", {&"staff_id": &"staff_gina", &"facility_id": source, &"template_id": &"DAY"}).is_success(),
|
|
"hire the porter and assign her to the warehouse")
|
|
for minute: int in 40:
|
|
if runtime.staff_service.get_staff(&"staff_gina").state == StaffRuntime.State.AVAILABLE: break
|
|
clock.advance_minutes(1)
|
|
_expect(_scenes.command(fixture, &"purchase_supplies", {&"warehouse_id": source, &"item_id": SupplyCatalog.RAW_FOOD, &"quantity": 8}).is_success()
|
|
and _scenes.command(fixture, &"create_logistics_request", {&"request_id": &"supply.p16_dismiss", &"source_inventory_id": runtime.facility_service.get_instance(source).local_inventory_id,
|
|
&"destination_inventory_id": runtime.facility_service.get_instance(destination).local_inventory_id, &"item_requirements": {SupplyCatalog.RAW_FOOD: 8}}).is_success(),
|
|
"purchase stock and request its delivery")
|
|
var external := false
|
|
for minute: int in 40:
|
|
clock.advance_minutes(1)
|
|
var worker: StaffRuntime = runtime.staff_service.get_staff(&"staff_gina")
|
|
if runtime.staff_service.is_externally_driven_task(worker.current_task_id):
|
|
external = true
|
|
break
|
|
_expect(external, "the porter takes the supply job, an external operation")
|
|
var refused := _expect_executor_refusal(fixture, &"staff_gina", &"EXTERNAL_TASK", "R2 external operation")
|
|
_expect(refused.message == "Finish the employee external operation before removal.", "R2: the existing removal contract's text")
|
|
for minute: int in 60:
|
|
if runtime.logistics_requests[&"supply.p16_dismiss"].state == LogisticsRequest.State.DELIVERING: break
|
|
clock.advance_minutes(1)
|
|
_expect(runtime.logistics_requests[&"supply.p16_dismiss"].state == LogisticsRequest.State.DELIVERING, "the porter carries the loaded cargo")
|
|
_expect_executor_refusal(fixture, &"staff_gina", &"EXTERNAL_TASK", "R2 loaded cargo")
|
|
for minute: int in 60:
|
|
if runtime.logistics_requests[&"supply.p16_dismiss"].state == LogisticsRequest.State.COMPLETED: break
|
|
clock.advance_minutes(1)
|
|
_expect(runtime.logistics_requests[&"supply.p16_dismiss"].state == LogisticsRequest.State.COMPLETED, "the delivery completes")
|
|
_expect(_scenes.dismiss(fixture, &"staff_gina").is_success(), "R2 is a wait: after the delivery the porter is dismissed")
|
|
_expect_boundary(fixture, &"staff_gina", "after the external operation")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A5: a working Task with a tool Reservation is reopened and its Reservation
|
|
## released; R3: a Reservation that cannot be released refuses the dismissal.
|
|
func _test_reserved_task() -> void:
|
|
var fixture := _scenes.new_fixture(16_070)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var worker_options := {&"state": StaffRuntime.State.AVAILABLE, &"current_cell": Vector3i(0, 0, WorldService.LAYER_FRONT),
|
|
&"role_tags": [&"worker"], &"permitted_task_tags": [&"work"], &"daily_wage": 100}
|
|
_expect(_scenes.command(fixture, &"register_staff", {&"staff_id": &"tool_worker", &"role_id": &"worker", &"options": worker_options}).is_success()
|
|
and _scenes.command(fixture, &"add_inventory_stack", {&"owner_inventory_id": &"staff.supplies", &"item_id": &"tool/snapshot_kit", &"quantity": 1}).is_success()
|
|
and _scenes.command(fixture, &"create_staff_task", {&"task_id": &"tool_task", &"task_type": &"inspect", &"priority": 90, &"options": {
|
|
&"target_cell": Vector3i(0, 0, WorldService.LAYER_FRONT), &"required_role_tags": [&"worker"], &"required_items": {&"tool/snapshot_kit": 1},
|
|
&"task_tags": [&"work"], &"estimated_minutes": 10}}).is_success(), "a worker, a tool and a Task that needs it")
|
|
fixture[&"clock"].advance_one_minute()
|
|
var task: StaffTask = runtime.staff_service.get_task(&"tool_task")
|
|
_expect(task.state == StaffTask.State.WORKING and task.assigned_staff_id == &"tool_worker" and task.reservation_ids.size() == 1, "the worker works the Task holding the tool Reservation")
|
|
var working: Dictionary = runtime.create_snapshot()
|
|
var preview: Dictionary = runtime.get_staff_dismissal_preview(&"tool_worker")
|
|
_expect(bool(preview[&"can_dismiss"]) and preview[&"reopened_task_ids"] == [&"tool_task"], "the preview names the Task the dismissal reopens")
|
|
var reservation_id: StringName = task.reservation_ids[0]
|
|
# Disclosed fixture: the tool is consumed while the Task still names its Reservation.
|
|
_expect(bool(runtime.inventory_service.consume_reservation(reservation_id, &"p16.fixture.consume", fixture[&"clock"].absolute_minute).get(&"ok", false)), "fixture consumes the reserved tool")
|
|
var refused := _expect_executor_refusal(fixture, &"tool_worker", &"RESERVATION_RELEASE_FAILED", "R3 unreleasable Reservation")
|
|
_expect(refused.message == "Staff removal could not release Task Reservations.", "R3: the existing removal contract's text")
|
|
_expect(runtime.restore_snapshot(working), "back to the working Task")
|
|
var result := _scenes.dismiss(fixture, &"tool_worker")
|
|
task = runtime.staff_service.get_task(&"tool_task")
|
|
_expect(result.is_success() and result.details[&"reopened_task_ids"] == [&"tool_task"] and task.state == StaffTask.State.OPEN
|
|
and task.assigned_staff_id.is_empty() and task.reservation_ids.is_empty() and task.state_reason == &"STAFF_REMOVED", "A5: the Task is reopened by the removal contract")
|
|
_expect(runtime.inventory_service.available_quantity(&"staff.supplies", &"tool/snapshot_kit") == 1, "A5: its tool Reservation is released")
|
|
var dismissed_task: Dictionary = task.create_snapshot()
|
|
var dismissed_inventory: Dictionary = runtime.inventory_service.create_snapshot()
|
|
_expect_boundary(fixture, &"tool_worker", "A5")
|
|
# The reopened Task follows the existing removal contract exactly.
|
|
_expect(runtime.restore_snapshot(working) and runtime.staff_service.remove_staff(&"tool_worker", &"DISMISSED", true, fixture[&"clock"].absolute_minute).is_success()
|
|
and runtime.staff_service.get_task(&"tool_task").create_snapshot() == dismissed_task and runtime.inventory_service.create_snapshot() == dismissed_inventory,
|
|
"A5: the Task and the inventory end as the existing removal contract leaves them")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A3 on duty and A4 mid-service at a staffed cafeteria.
|
|
func _test_facility_duty_and_service() -> void:
|
|
var fixture := _scenes.new_fixture(16_080)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var clock: Variant = fixture[&"clock"]
|
|
_expect(_scenes.command(fixture, &"build_facility", {&"definition_id": &"cafeteria", &"origin": Vector3i(-5, 0, WorldService.LAYER_FRONT)}).is_success(), "build a cafeteria")
|
|
clock.advance_minutes(180)
|
|
var facility: FacilityInstance = runtime.facility_service.get_instances()[0]
|
|
_expect(bool(load("res://tests/fixtures/required_kitchen_setup.gd").ensure(runtime, clock, facility.instance_id, true).get(&"ok", false)), "the cafeteria's paid kitchen link with its physical kitchen worker")
|
|
var start_minute: int = posmod(clock.absolute_minute, 1440)
|
|
for staff_id: StringName in [&"duty_cook", &"duty_server"]:
|
|
_expect(_scenes.command(fixture, &"register_staff", {&"staff_id": staff_id, &"role_id": &"worker", &"options": {&"state": StaffRuntime.State.OFF_DUTY,
|
|
&"current_cell": Vector3i(0, 0, WorldService.LAYER_FRONT), &"daily_wage": 100}}).is_success()
|
|
and _scenes.command(fixture, &"create_staff_shift", {&"shift_id": StringName("shift_%s" % staff_id), &"staff_id": staff_id, &"template_id": &"FLEX",
|
|
&"start_day": int(clock.absolute_minute) / 1440, &"start_minute_of_day": start_minute, &"end_minute_of_day": start_minute + 300, &"facility_id": facility.instance_id}).is_success(),
|
|
"%s works a Shift at the cafeteria" % staff_id)
|
|
clock.advance_one_minute()
|
|
_expect(facility.active_staff_ids == [&"duty_cook", &"duty_server"] and facility.state == FacilityInstance.State.OPEN, "both employees staff the open cafeteria")
|
|
var on_duty: Dictionary = runtime.create_snapshot()
|
|
_expect(_scenes.dismiss(fixture, &"duty_server").is_success(), "A3: the idle employee on duty is dismissed")
|
|
_expect(facility.active_staff_ids == [&"duty_cook"], "A3: the facility staffing loses her at the command, not at the next minute")
|
|
_expect_boundary(fixture, &"duty_server", "A3")
|
|
_expect(runtime.restore_snapshot(on_duty), "back to both on duty")
|
|
facility = runtime.facility_service.get_instance(facility.instance_id)
|
|
_expect(_scenes.command(fixture, &"add_inventory_stack", {&"owner_inventory_id": facility.local_inventory_id, &"item_id": &"ingredient/basic_meal", &"quantity": 1}).is_success()
|
|
and _scenes.command(fixture, &"register_guest_wallet", {&"guest_id": &"p16_guest", &"gold": 100}).is_success()
|
|
and _scenes.command(fixture, &"create_service_request", {&"request_id": &"p16_service", &"facility_id": facility.instance_id, &"guest_ids": [&"p16_guest"],
|
|
&"service_type": &"default", &"options": {&"quoted_price": 35}}).is_success(), "a guest requests a meal")
|
|
clock.advance_one_minute()
|
|
var active: Array = runtime.facility_service.get_active_services(facility.instance_id)
|
|
_expect(active.size() == 1 and &"duty_server" in (active[0] as ServiceInstance).staff_ids, "A4: the service runs with her")
|
|
if active.is_empty():
|
|
_scenes.free_fixture(fixture)
|
|
return
|
|
var service_id: StringName = (active[0] as ServiceInstance).service_id
|
|
_expect(_scenes.dismiss(fixture, &"duty_server").is_success(), "A4: the employee in the service is dismissed")
|
|
_expect_boundary(fixture, &"duty_server", "A4")
|
|
clock.advance_one_minute()
|
|
var service: ServiceInstance = runtime.facility_service.get_service(service_id)
|
|
_expect(service != null and service.state == ServiceInstance.State.WAITING_FOR_STAFF
|
|
and service.staff_grace_deadline == clock.absolute_minute + FacilityService.STAFF_REPLACEMENT_GRACE_MINUTES, "A4: the service waits for replacement staff (existing rule)")
|
|
clock.advance_minutes(FacilityService.STAFF_REPLACEMENT_GRACE_MINUTES)
|
|
service = runtime.facility_service.get_service(service_id)
|
|
_expect(service != null and service.state == ServiceInstance.State.FAILED and service.failure_reason == FacilityService.INTERRUPTION_STAFF_UNAVAILABLE,
|
|
"A4: without a replacement the service fails as staff unavailable")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A2 on foot: an employee walking to her workplace is dismissed.
|
|
func _test_walking_commute() -> void:
|
|
var fixture := _scenes.new_fixture(16_090)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(_scenes.command(fixture, &"build_facility", {&"definition_id": &"reception", &"origin": Vector3i(-8, 0, 0)}).is_success(), "build a reception")
|
|
fixture[&"clock"].advance_minutes(180)
|
|
var reception: StringName = runtime.facility_service.get_instances()[0].instance_id
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_akane"}).is_success()
|
|
and _scenes.command(fixture, &"set_staff_work_assignment", {&"staff_id": &"staff_akane", &"facility_id": reception, &"template_id": &"DAY"}).is_success(),
|
|
"hire staff_akane and send her to the reception")
|
|
fixture[&"clock"].advance_minutes(1)
|
|
_expect(runtime.staff_service.get_staff(&"staff_akane").state == StaffRuntime.State.COMMUTING and runtime.path_service.has_actor_projection(&"staff:staff_akane"), "she is walking to work")
|
|
_expect(_scenes.dismiss(fixture, &"staff_akane").is_success(), "A2: the commuting employee is dismissed")
|
|
_expect_boundary(fixture, &"staff_akane", "A2 walking")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A2 at the elevator, A6 the carrier and A7 the patient, through every rescue
|
|
## phase of the elevator rescue; a pair aboard is kept together until a landing.
|
|
func _test_rescue_matrix() -> void:
|
|
var fixture := _scenes.new_rescue_fixture()
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var checkpoints := {}
|
|
for tick: int in 160:
|
|
fixture[&"clock"].advance_minutes(1)
|
|
var phase := _scenes.rescue_phase(runtime)
|
|
if phase in RESCUE_PHASES and not checkpoints.has(phase):
|
|
checkpoints[phase] = runtime.create_snapshot()
|
|
_expect(checkpoints.size() == RESCUE_PHASES.size(), "the rescue passes every phase %s" % [checkpoints.keys()])
|
|
for phase: String in RESCUE_PHASES:
|
|
if not checkpoints.has(phase):
|
|
continue
|
|
for staff_id: StringName in [&"medic", &"patient"]:
|
|
_expect(runtime.restore_snapshot(checkpoints[phase]), "restore %s" % phase)
|
|
var label := "%s, dismiss the %s" % [phase, staff_id]
|
|
if phase.ends_with("BOARDED/pair"):
|
|
_expect_executor_refusal(fixture, staff_id, &"RESCUE_PAIR_ABOARD", label)
|
|
continue
|
|
var held: StringName = runtime.staff_service.get_staff(&"medic").current_task_id
|
|
var result := _scenes.dismiss(fixture, staff_id)
|
|
_expect(result.is_success(), "%s: dismissed (%s)" % [label, result.message])
|
|
_expect_boundary(fixture, staff_id, label)
|
|
var task: StaffTask = runtime.staff_service.get_task(held)
|
|
if staff_id == &"medic" and phase.begins_with("rescue_pickup"):
|
|
_expect(task.state == StaffTask.State.OPEN and task.assigned_staff_id.is_empty() and runtime.staff_service.get_staff(&"patient").state == StaffRuntime.State.INCAPACITATED,
|
|
"%s: the pickup is reopened for another medic (A6)" % label)
|
|
elif staff_id == &"medic":
|
|
_expect(task.state == StaffTask.State.CANCELLED and task.state_reason == &"RESCUE_INTERRUPTED" and result.details[&"interrupted_rescue_task_ids"] == [held]
|
|
and runtime.elevators.get_report()[&"trips"].is_empty(), "%s: the transport is interrupted with its elevator requests (A6)" % label)
|
|
fixture[&"clock"].advance_minutes(1)
|
|
var restarted: Array = runtime.staff_service.get_tasks().filter(func(t: StaffTask) -> bool: return t.task_type == &"rescue_pickup" and not t.is_terminal() and t.target_entity_id == &"patient")
|
|
_expect(restarted.size() == 1, "%s: the next minute starts a new rescue for the patient (existing rule)" % label)
|
|
else:
|
|
var medic: StaffRuntime = runtime.staff_service.get_staff(&"medic")
|
|
var aboard: bool = runtime.elevators.get_actor_trip(&"staff:medic").get(&"state", &"") == PathService.ELEVATOR_REQUEST_BOARDED
|
|
_expect(task.state == StaffTask.State.CANCELLED and task.state_reason == &"RESCUE_INTERRUPTED" and medic.current_task_id.is_empty(),
|
|
"%s: the rescue is interrupted and the medic released (A7)" % label)
|
|
_expect(aboard == (phase == "rescue_pickup/MOVING/BOARDED/single"), "%s: a medic riding alone rides on to a landing; otherwise no elevator request remains" % label)
|
|
fixture[&"clock"].advance_minutes(3)
|
|
var later: Dictionary = runtime.create_snapshot()
|
|
_expect(runtime.restore_snapshot(later) and runtime.staff_service.validate_invariants()[&"ok"], "%s: three minutes later the game still saves" % label)
|
|
_expect(runtime.restore_snapshot(checkpoints.get("rescue_transport/MOVING/BOARDED/pair", runtime.create_snapshot())), "back to the pair aboard")
|
|
_expect(_scenes.advance_to_rescue_phase(fixture, "rescue_transport/MOVING/-/single") and _scenes.dismiss(fixture, &"medic").is_success(),
|
|
"the pair refusal is a wait: after the landing the medic is dismissed")
|
|
_expect_boundary(fixture, &"medic", "after the landing")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A8: the Event's existing missing actor policy handles the dismissed actor at
|
|
## the command boundary (CANCEL; CONTINUE_WITHOUT keeps the other actor).
|
|
func _test_event_actors() -> void:
|
|
var fixture := _scenes.new_event_fixture(16_100)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var cash_before: int = runtime.economy_service.get_balance(FRONT) + 80
|
|
var result := _scenes.dismiss(fixture, &"event_actor")
|
|
_expect(result.is_success() and int(result.details[&"severance"]) == 240, "A8: the locked Event actor is dismissed (severance 240)")
|
|
var instance: EventInstance = runtime.event_service.get_instance(&"p16.event.instance")
|
|
_expect(instance != null and instance.state == EventInstance.State.CANCELLED and runtime.event_service.get_foreground_instance() == null,
|
|
"A8: the CANCEL policy cancels the Event at the command")
|
|
_expect(runtime.economy_service.get_balance(&"EVENT_ESCROW:p16.event.instance") == 0 and runtime.economy_service.get_balance(FRONT) == cash_before - 240,
|
|
"A8: the escrow is refunded once and the severance paid")
|
|
_expect_boundary(fixture, &"event_actor", "A8 CANCEL")
|
|
_scenes.free_fixture(fixture)
|
|
fixture = _scenes.new_fixture(16_101)
|
|
runtime = fixture[&"runtime"]
|
|
for staff_id: StringName in [&"event_lead", &"event_partner"]:
|
|
_expect(_scenes.command(fixture, &"register_staff", {&"staff_id": staff_id, &"role_id": &"service", &"options": {&"daily_wage": 80}}).is_success(), "register %s" % staff_id)
|
|
_expect(_scenes.command(fixture, &"register_event_definition", {&"definition": {&"event_id": &"p16.event.pair", &"category": &"RELATIONSHIP", &"priority": 70,
|
|
&"foreground": true, &"transaction_policy": &"ROLLBACK_ALL", &"missing_actor_policy": &"CONTINUE_WITHOUT", &"content_rating": &"GENERAL",
|
|
&"choices": [{&"choice_id": &"wait", &"text_key": &"event.p16.pair.wait", &"actions": []}]}}).is_success()
|
|
and _scenes.command(fixture, &"enqueue_event", {&"event_id": &"p16.event.pair", &"actor_ids": [&"event_lead", &"event_partner"],
|
|
&"options": {&"event_instance_id": &"p16.event.pair.instance"}}).is_success(), "a two-actor Event that continues without a missing actor")
|
|
fixture[&"clock"].set_paused(false)
|
|
fixture[&"clock"].advance_one_minute()
|
|
fixture[&"clock"].set_paused(true)
|
|
_expect(runtime.event_service.get_actor_locks().has(&"event_partner"), "the Event locks both employees")
|
|
_expect(_scenes.dismiss(fixture, &"event_partner").is_success(), "A8: one actor of the continuing Event is dismissed")
|
|
var pair: EventInstance = runtime.event_service.get_instance(&"p16.event.pair.instance")
|
|
_expect(pair != null and pair.actor_ids == [&"event_lead"] and runtime.event_service.get_actor_locks().has(&"event_lead")
|
|
and pair.state in [EventInstance.State.RUNNING, EventInstance.State.WAITING_CHOICE], "A8: CONTINUE_WITHOUT keeps the Event with the other actor")
|
|
_expect_boundary(fixture, &"event_partner", "A8 CONTINUE_WITHOUT")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## R9 (Root's temporary boundary): the defender of an unfinished raid is kept;
|
|
## after the raid ends the same employee is dismissed.
|
|
func _test_defense_refusal() -> void:
|
|
var fixture := _scenes.new_fixture(16_110)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(_scenes.command(fixture, &"build_facility", {&"definition_id": &"reception", &"origin": Vector3i(-8, 0, 0)}).is_success(), "build the raid objective")
|
|
fixture[&"clock"].advance_minutes(180)
|
|
var objective: StringName = runtime.facility_service.get_instances()[0].instance_id
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_klaus"}).is_success(), "hire the guard staff_klaus")
|
|
var created: CommandResult = runtime.submit_command(&"create_defense_raid", {&"raid_id": &"p16.raid", &"definition": {
|
|
&"source_id": &"runtime_test", &"entry_points": [&"gate.north"], &"objective_ids": [objective], &"round_minutes": 5,
|
|
&"max_duration_minutes": 180, &"retreat_policy": &"HOLD", &"defender_retreat_threshold": 0,
|
|
&"waves": [{&"wave_id": &"wave.one", &"threat_strength": 15, &"retreat_threshold": 0, &"max_rounds": 1, &"entry_points": [&"gate.north"]}]}}, &"defense_controller")
|
|
var defender: CommandResult = runtime.submit_command(&"register_defense_combatant", {&"raid_id": &"p16.raid", &"actor_id": &"staff_klaus",
|
|
&"side": &"DEFENDER", &"combat": 90, &"max_health": 100, &"options": {}}, &"defense_controller")
|
|
_expect(created.is_success() and defender.is_success(), "the guard defends an unfinished raid (%s %s)" % [created.message, defender.message])
|
|
_expect_executor_refusal(fixture, &"staff_klaus", &"DEFENSE_LOCKED", "R9 defender of an unfinished raid")
|
|
_expect(runtime.submit_command(&"cancel_defense_raid", {&"raid_id": &"p16.raid"}, &"defense_controller").is_success(), "the raid ends")
|
|
_expect(_scenes.dismiss(fixture, &"staff_klaus").is_success(), "after the raid the former defender is dismissed")
|
|
_expect_boundary(fixture, &"staff_klaus", "after the raid")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## SPEC 4.1 d: if the severance cannot be posted after the removal, the whole
|
|
## dismissal is rolled back (5.c). Fixture: its posting key is already used.
|
|
func _test_commit_failure_rolls_back() -> void:
|
|
var fixture := _scenes.new_fixture(16_120)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(_scenes.command(fixture, &"hire_staff_candidate", {&"candidate_id": &"staff_rika"}).is_success()
|
|
and _scenes.command(fixture, &"set_staff_work_assignment", {&"staff_id": &"staff_rika", &"facility_id": &"", &"template_id": &"DAY"}).is_success(), "hire staff_rika")
|
|
var next_id := int(runtime.create_snapshot()[&"systems"][&"runtime"][&"next_command_id"])
|
|
_expect(runtime.economy_service.transfer(Scenes.PAYER, Scenes.FRONT_SALES, 1, fixture[&"clock"].absolute_minute, &"TRANSFER", &"p16.fixture",
|
|
StringName("staff.severance.%d" % next_id)).is_success(), "fixture occupies the dismissal's posting key")
|
|
var refused := _expect_executor_refusal(fixture, &"staff_rika", &"SEVERANCE_POST_FAILED", "commit failure")
|
|
_expect(runtime.staff_service.has_staff(&"staff_rika") and refused.code == CommandResult.Code.TRANSACTION_APPLY_FAILED, "the employee, her Shift and path actor are back")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## A save from before the severance gains its empty expense account; an
|
|
## incompatible account is refused and changes nothing.
|
|
func _test_old_save_gains_the_severance_account() -> void:
|
|
var fixture := _scenes.new_fixture(16_130, true)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
fixture[&"clock"].advance_minutes(60)
|
|
var current: Dictionary = runtime.create_snapshot()
|
|
var old := current.duplicate(true)
|
|
var accounts: Array = old[&"systems"][&"runtime"][&"economy"][&"accounts"]
|
|
var kept: Array = accounts.filter(func(account: Dictionary) -> bool: return String(account[&"account_id"]) != String(FinancePolicy.SEVERANCE_EXPENSE))
|
|
_expect(kept.size() == accounts.size() - 1, "the current save holds the severance expense account")
|
|
old[&"systems"][&"runtime"][&"economy"][&"accounts"] = kept
|
|
_expect(runtime.restore_snapshot(old) and var_to_bytes(runtime.create_snapshot()) == var_to_bytes(current), "an older save gains only the empty severance account")
|
|
var wrong := current.duplicate(true)
|
|
for account: Dictionary in wrong[&"systems"][&"runtime"][&"economy"][&"accounts"]:
|
|
if String(account[&"account_id"]) == String(FinancePolicy.SEVERANCE_EXPENSE):
|
|
account[&"allow_negative"] = true
|
|
_expect(not runtime.restore_snapshot(wrong) and var_to_bytes(runtime.create_snapshot()) == var_to_bytes(current), "an incompatible severance account is refused and changes nothing")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
## F9: the game's own Runtime and Main. The staff panel shows the severance and
|
|
## the reopened Task before the press, dismisses through its buttons, refuses the
|
|
## UNIQUE and ADULT_CONTRACT rows with their reasons and sends nothing for them.
|
|
func _test_dismiss_from_main() -> void:
|
|
var runtime: Variant = root.get_node("SimulationRuntime")
|
|
var clock: Variant = root.get_node("GameClock")
|
|
var state: Variant = root.get_node("GameState")
|
|
clock.reset(1, 6, 0)
|
|
state.reset()
|
|
runtime.initialize(clock, state, 16_140)
|
|
clock.set_paused(true)
|
|
root.size = Vector2i(1280, 720)
|
|
var main: Control = load("res://scenes/main/main.tscn").instantiate()
|
|
root.add_child(main)
|
|
await process_frame
|
|
await process_frame
|
|
runtime.configure_save_policy({&"enabled": false, &"daily_checkpoint_enabled": false})
|
|
clock.set_paused(true)
|
|
var key := InputEventKey.new()
|
|
key.keycode = KEY_H
|
|
key.pressed = true
|
|
main.call("_unhandled_key_input", key)
|
|
for candidate: StringName in [&"staff_akane", &"staff_eri", &"heroine_anri"]:
|
|
var hire := (main.get("staff_candidate_buttons") as Dictionary).get(candidate) as Button
|
|
_expect(hire != null, "the hiring panel lists %s" % candidate)
|
|
if hire != null:
|
|
hire.pressed.emit()
|
|
_expect(runtime.submit_command(&"register_staff", {&"staff_id": &"adult_contract", &"role_id": &"attendant",
|
|
&"options": {&"employment_kind": &"ADULT_CONTRACT", &"daily_wage": 100}}).is_success(), "an ADULT_CONTRACT fixture row")
|
|
_expect(runtime.submit_command(&"create_staff_task", {&"task_id": &"ui_task", &"task_type": &"inspect", &"priority": 90, &"options": {
|
|
&"target_cell": runtime.staff_service.get_staff(&"staff_eri").current_cell, &"required_role_tags": [&"cleaner"], &"task_tags": [&"cleaning"], &"estimated_minutes": 120}}).is_success(),
|
|
"a Task for the cleaner")
|
|
clock.advance_minutes(1)
|
|
var eri_task: StringName = runtime.staff_service.get_staff(&"staff_eri").current_task_id
|
|
_expect(eri_task == &"ui_task", "the cleaner holds the Task (%s)" % eri_task)
|
|
(main.get("staff_management_toggle_button") as Button).pressed.emit()
|
|
var panel: StaffManagementPanel = main.get("staff_management_panel")
|
|
_expect(panel.visible and panel.roster_buttons.size() == 4, "the hired-staff panel lists four employees")
|
|
(panel.roster_buttons[&"staff_akane"] as Button).pressed.emit()
|
|
_expect(not panel.dismiss_button.disabled and panel.dismiss_button.tooltip_text.contains("退職金 G360"), "the receptionist row offers the dismissal with severance G360")
|
|
var untouched: Dictionary = runtime.create_snapshot()
|
|
panel.dismiss_button.pressed.emit()
|
|
_expect(panel.dismiss_confirm_box.visible and panel.dismiss_confirm_label.text.contains("退職金 G360（日給の3日分）") and runtime.create_snapshot() == untouched,
|
|
"pressing 解雇する… shows the severance and sends nothing (5.a)")
|
|
panel.dismiss_cancel_button.pressed.emit()
|
|
_expect(not panel.dismiss_confirm_box.visible and runtime.create_snapshot() == untouched, "やめる closes the confirmation without a command")
|
|
panel.dismiss_button.pressed.emit()
|
|
panel.dismiss_confirm_button.pressed.emit()
|
|
_expect(not runtime.staff_service.has_staff(&"staff_akane") and not panel.roster_buttons.has(&"staff_akane") and panel.selected_staff_id != &"staff_akane",
|
|
"解雇を確定 dismisses her; the roster and the selection follow")
|
|
_expect(panel.result_label.text.contains("解雇しました") and panel.result_label.text.contains("G360"), "the result shows the paid severance: %s" % panel.result_label.text)
|
|
_expect(_scenes.count_category(runtime, FinancePolicy.SEVERANCE_CATEGORY, &"staff_akane") == 1, "the panel's command paid the severance once")
|
|
(panel.roster_buttons[&"staff_eri"] as Button).pressed.emit()
|
|
panel.dismiss_button.pressed.emit()
|
|
_expect(panel.dismiss_confirm_label.text.contains("持っている作業は開き直して") and panel.dismiss_confirm_label.text.contains("G270"), "the cleaner's confirmation names the reopened Task and G270")
|
|
clock.set_paused(false)
|
|
panel.dismiss_confirm_button.pressed.emit()
|
|
_expect(runtime.staff_service.has_staff(&"staff_eri") and panel.dismiss_button.disabled and panel.result_label.text.contains("受理しました"), "with the clock running the dismissal waits for the next minute")
|
|
clock.advance_minutes(1)
|
|
clock.set_paused(true)
|
|
_expect(not runtime.staff_service.has_staff(&"staff_eri") and runtime.staff_service.get_task(&"ui_task").state == StaffTask.State.OPEN
|
|
and panel.result_label.text.contains("解雇しました"), "the queued dismissal completes and reopens her Task")
|
|
for row: Array in [[&"heroine_anri", "ユニーク：雇用・維持費無料 / 解雇・売却不可"], [&"adult_contract", "解雇不可：ギルドで雇った一般従業員だけを解雇できます。"]]:
|
|
(panel.roster_buttons[row[0]] as Button).pressed.emit()
|
|
var before: Dictionary = runtime.create_snapshot()
|
|
_expect(panel.dismiss_button.disabled and panel.staff_detail_label.text.contains(row[1]), "%s: the button is disabled and the reason shown" % row[0])
|
|
panel.dismiss_button.pressed.emit()
|
|
_expect(runtime.create_snapshot() == before and not panel.dismiss_confirm_box.visible and runtime.staff_service.has_staff(row[0]), "%s: a forced press sends nothing (5.a)" % row[0])
|
|
var cleanup: Dictionary = await FixtureCleanup.free_owner_and_wait(self, main)
|
|
_expect(bool(cleanup.get(&"passed", false)), "ordinary Main release with audio cleanup")
|