169 lines
9.2 KiB
GDScript
169 lines
9.2 KiB
GDScript
extends SceneTree
|
|
|
|
## P16-01-DISMISS F7/F8, reader phase. Runs after the writer suite
|
|
## (test_general_dismissal_restart_1_write.gd) as a separate engine process. It
|
|
## loads every ledger save, continues the day script and requires exactly the
|
|
## uninterrupted ledger: one severance and one payment of the held wages,
|
|
## whether the save was made before or right after the dismissal command or
|
|
## around the day 2 00:00 close. It loads the A6, A7 and A8 command boundary
|
|
## saves, requires the writer's state and no live reference to the dismissed
|
|
## employee, and continues them to the writer's later state. A changed package
|
|
## is refused.
|
|
|
|
const Scenes := preload("res://tests/helpers/p16_dismissal_fixture.gd")
|
|
|
|
var _checks := 0
|
|
var _failures := 0
|
|
var _scenes: Scenes
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
print("P16-01-DISMISS: restart reader")
|
|
_scenes = Scenes.new(_expect)
|
|
var handoff := _read_handoff()
|
|
if not handoff.is_empty():
|
|
_check_ledger(handoff)
|
|
_check_boundaries(handoff)
|
|
_check_tampered(handoff)
|
|
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 _read_handoff() -> Dictionary:
|
|
_expect(FileAccess.file_exists(Scenes.HANDOFF_PATH), "the writer phase left its handoff (run test_general_dismissal_restart_1_write.gd first)")
|
|
if not FileAccess.file_exists(Scenes.HANDOFF_PATH):
|
|
return {}
|
|
var parsed: Variant = JSON.parse_string(FileAccess.get_file_as_string(Scenes.HANDOFF_PATH))
|
|
_expect(parsed is Dictionary and str((parsed as Dictionary).get("schema", "")) == Scenes.HANDOFF_SCHEMA, "handoff schema")
|
|
if not parsed is Dictionary or str((parsed as Dictionary).get("schema", "")) != Scenes.HANDOFF_SCHEMA:
|
|
return {}
|
|
var handoff: Dictionary = parsed
|
|
var writer_pid := int(handoff.get("writer_pid", 0))
|
|
_expect(writer_pid > 0 and writer_pid != OS.get_process_id(), "a separate engine process wrote the saves")
|
|
_expect(str(handoff.get("writer_source_sha256", "")) == FileAccess.get_sha256(Scenes.WRITER_SOURCE), "the handoff comes from the current writer suite")
|
|
_expect(int(handoff.get("ledger_seed", -1)) == Scenes.LEDGER_SEED and int(handoff.get("last_minute", -1)) == Scenes.LAST_MINUTE, "same fixture and day script")
|
|
print("P16_RESTART_READER pid=%d writer_pid=%d handoff_sha256=%s" % [OS.get_process_id(), writer_pid, FileAccess.get_sha256(Scenes.HANDOFF_PATH)])
|
|
return handoff
|
|
|
|
|
|
func _decode(text: Variant) -> Variant:
|
|
return bytes_to_var(Marshalls.base64_to_raw(str(text)))
|
|
|
|
|
|
func _check_ledger(handoff: Dictionary) -> void:
|
|
var straight := _scenes.new_ledger_fixture()
|
|
_scenes.play_ledger(straight, 360, Scenes.LAST_MINUTE, Callable())
|
|
var straight_runtime: Variant = straight[&"runtime"]
|
|
var straight_economy := _scenes.economy_bytes(straight_runtime)
|
|
var straight_state := _scenes.state_value(straight_runtime, straight[&"clock"])
|
|
_expect(Scenes.sha256(straight_economy) == str(handoff.get("straight_economy_sha256", "")), "the uninterrupted day script gives the same ledger in both processes")
|
|
_expect(straight_state == _decode(handoff.get("straight_state_base64", "")), "the uninterrupted day script gives the same employees, Tasks and balances in both processes")
|
|
var saves: Array = handoff.get("ledger_saves", [])
|
|
var points: Array = []
|
|
for save: Variant in saves:
|
|
points.append([int((save as Dictionary).get("minute", -1)), str((save as Dictionary).get("phase", ""))] if save is Dictionary else [])
|
|
_expect(points == Scenes.SAVE_POINTS, "the writer saved before and right after the dismissal, a minute later and around the day 2 close")
|
|
for save: Variant in saves:
|
|
if not save is Dictionary:
|
|
continue
|
|
var minute := int((save as Dictionary)["minute"])
|
|
var name := str((save as Dictionary)["name"])
|
|
var path := Scenes.READER_SAVE % name
|
|
if not _materialize(path, (save as Dictionary).get("files", {}), false):
|
|
continue
|
|
var resumed := _scenes.new_ledger_fixture()
|
|
var runtime: Variant = resumed[&"runtime"]
|
|
_expect(bool(runtime.load_from_path(path).get(&"ok", false)) and int(resumed[&"clock"].absolute_minute) == minute, "%s: this process loads the save at minute %d" % [name, minute])
|
|
var dismissed_before: bool = not runtime.staff_service.has_staff(Scenes.DISMISSED)
|
|
_expect(dismissed_before == (name != "ledger-1500-before"), "%s: the save holds the employee exactly when it was made before the command" % name)
|
|
_scenes.play_ledger(resumed, minute, Scenes.LAST_MINUTE, Callable())
|
|
_expect(_scenes.economy_bytes(runtime) == straight_economy, "%s: resuming gives exactly the uninterrupted ledger" % name)
|
|
_expect(_scenes.state_value(runtime, resumed[&"clock"]) == straight_state, "%s: resuming gives the same employees, Tasks and balances" % name)
|
|
_expect(_scenes.count_category(runtime, FinancePolicy.SEVERANCE_CATEGORY) == 1 and runtime.economy_service.get_balance(FinancePolicy.SEVERANCE_EXPENSE) == 360,
|
|
"%s: the severance is paid once" % name)
|
|
_expect(runtime.staff_service.get_departed_unpaid_wages(Scenes.DISMISSED) == 0
|
|
and int(runtime.operations_coordinator.get_day_summary(2)[&"settlement"][&"input_payments"][0][&"amount"]) == 120, "%s: the held 120 is paid once, at the day 2 close" % name)
|
|
_scenes.free_fixture(resumed)
|
|
_scenes.free_fixture(straight)
|
|
|
|
|
|
func _check_boundaries(handoff: Dictionary) -> void:
|
|
var boundaries: Array = handoff.get("boundaries", [])
|
|
var labels: Array = []
|
|
for boundary: Variant in boundaries:
|
|
labels.append(str((boundary as Dictionary).get("label", "")) if boundary is Dictionary else "")
|
|
_expect(labels == ["A6", "A7", "A6-pickup", "A6-pair-aboard", "A7-pair-aboard", "A8", "A8-continue-without"], "the writer saved the A6, A7 and A8 command boundaries")
|
|
for boundary: Variant in boundaries:
|
|
if not boundary is Dictionary:
|
|
continue
|
|
var name := str((boundary as Dictionary)["name"])
|
|
var staff_id := StringName(str((boundary as Dictionary)["staff_id"]))
|
|
var path := Scenes.READER_SAVE % name
|
|
if not _materialize(path, (boundary as Dictionary).get("files", {}), false):
|
|
continue
|
|
var fixture := _scenes.new_fixture(1)
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
_expect(bool(runtime.load_from_path(path).get(&"ok", false)), "%s: this process loads the save made right after the command" % name)
|
|
var dangling: Array[String] = _scenes.dangling_references(runtime, staff_id)
|
|
_expect(dangling.is_empty(), "%s: no live reference to the dismissed employee after the load %s" % [name, dangling])
|
|
_expect(runtime.staff_service.validate_invariants()[&"ok"] and runtime.economy_service.validate_ledger()[&"ok"], "%s: ownership and the ledger are consistent after the load" % name)
|
|
_expect(_scenes.state_value(runtime, fixture[&"clock"]) == _decode((boundary as Dictionary)["at_command_base64"]), "%s: the loaded game is the writer's game at the command" % name)
|
|
var saved: Dictionary = runtime.create_snapshot()
|
|
_expect(runtime.restore_snapshot(saved) and runtime.create_snapshot() == saved, "%s: the loaded game saves and restores exactly" % name)
|
|
fixture[&"clock"].advance_minutes(int((boundary as Dictionary)["continue_minutes"]))
|
|
_expect(_scenes.state_value(runtime, fixture[&"clock"]) == _decode((boundary as Dictionary)["later_base64"]), "%s: it continues exactly as the writer's game" % name)
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
func _check_tampered(handoff: Dictionary) -> void:
|
|
var saves: Array = handoff.get("ledger_saves", [])
|
|
if saves.is_empty() or not saves[0] is Dictionary:
|
|
_expect(false, "a save package to change")
|
|
return
|
|
var path := Scenes.READER_SAVE % "tampered"
|
|
if not _materialize(path, (saves[0] as Dictionary).get("files", {}), true):
|
|
return
|
|
var fixture := _scenes.new_ledger_fixture()
|
|
var runtime: Variant = fixture[&"runtime"]
|
|
var before := _scenes.economy_bytes(runtime)
|
|
_expect(not bool(runtime.load_from_path(path).get(&"ok", true)), "a changed save package is refused")
|
|
_expect(_scenes.economy_bytes(runtime) == before and int(fixture[&"clock"].absolute_minute) == 360, "a refused load changes no Gold and no time")
|
|
_scenes.free_fixture(fixture)
|
|
|
|
|
|
# Writes the writer's exact package bytes into this process's own profile.
|
|
func _materialize(path: String, files: Variant, change_world: bool) -> bool:
|
|
var directory := ProjectSettings.globalize_path(path)
|
|
_expect(files is Dictionary and (files as Dictionary).has("manifest.json") and (files as Dictionary).has("world.bin"), "handoff package %s is complete" % path)
|
|
if not files is Dictionary:
|
|
return false
|
|
_expect(DirAccess.make_dir_recursive_absolute(directory) == OK, "package directory %s" % path)
|
|
for name: String in (files as Dictionary):
|
|
var pin: Dictionary = (files as Dictionary)[name]
|
|
var bytes := Marshalls.base64_to_raw(str(pin.get("base64", "")))
|
|
_expect(Scenes.sha256(bytes) == str(pin.get("sha256", "")) and bytes.size() == int(pin.get("bytes", -1)), "handoff bytes of %s are exact" % name)
|
|
if change_world and name == "world.bin" and not bytes.is_empty():
|
|
bytes[bytes.size() - 1] = bytes[bytes.size() - 1] ^ 0xff
|
|
var file := FileAccess.open(directory.path_join(name), FileAccess.WRITE)
|
|
_expect(file != null, "write %s into %s" % [name, path])
|
|
if file == null:
|
|
return false
|
|
file.store_buffer(bytes)
|
|
file.close()
|
|
return true
|
|
|
|
|
|
func _expect(condition: bool, message: String) -> void:
|
|
_checks += 1
|
|
if not condition:
|
|
_failures += 1
|
|
push_error(message)
|