Rijad Zuzo
407 lines
15 KiB
GDScript
407 lines
15 KiB
GDScript
extends GutTest
|
|
|
|
const WORLD_ID := &"regional_world"
|
|
const ORIGIN_LOCATION_ID := &"location_origin"
|
|
const DESTINATION_LOCATION_ID := &"location_destination"
|
|
const ORIGIN_SETTLEMENT_ID := &"settlement_origin"
|
|
const DESTINATION_SETTLEMENT_ID := &"settlement_destination"
|
|
const GROUP_ID := &"group_caravan"
|
|
const ROUTE_ID := &"route_trade"
|
|
const DEPARTURE_TICK := 10
|
|
|
|
var _test_directory := ""
|
|
|
|
|
|
func before_each() -> void:
|
|
var test_parent := (
|
|
ProjectSettings.globalize_path("user://regional_chunked_file_store_tests").simplify_path()
|
|
)
|
|
_remove_tree(test_parent)
|
|
_test_directory = (
|
|
"user://regional_chunked_file_store_tests/run_%d_%d"
|
|
% [Time.get_ticks_usec(), get_instance_id()]
|
|
)
|
|
|
|
|
|
func after_each() -> void:
|
|
var absolute_path := ProjectSettings.globalize_path(_test_directory).simplify_path()
|
|
var expected_parent := (
|
|
ProjectSettings.globalize_path("user://regional_chunked_file_store_tests").simplify_path()
|
|
)
|
|
if absolute_path.begins_with(expected_parent + "/"):
|
|
_remove_tree(absolute_path)
|
|
|
|
|
|
func test_atomic_generations_round_trip_exact_archive_and_report_telemetry() -> void:
|
|
var explicit_absolute_base := ProjectSettings.globalize_path(_test_directory)
|
|
var store := RegionalChunkedFileStore.new(explicit_absolute_base)
|
|
var first := _fixture_archive(false)
|
|
var second := _fixture_archive(true)
|
|
|
|
assert_eq(store.get_base_directory(), explicit_absolute_base)
|
|
assert_true(store.save(first))
|
|
var first_generation := store.get_generation_ids()[0]
|
|
assert_true(store.save(second))
|
|
var generation_ids := store.get_generation_ids()
|
|
assert_eq(generation_ids.size(), 2)
|
|
assert_eq(generation_ids[0], first_generation)
|
|
assert_true(
|
|
(
|
|
DirAccess.open(
|
|
ProjectSettings.globalize_path(store.get_generation_directory(first_generation))
|
|
)
|
|
!= null
|
|
)
|
|
)
|
|
var save_telemetry := store.get_last_telemetry()
|
|
assert_true(save_telemetry["succeeded"])
|
|
assert_gt(save_telemetry["serialized_bytes"], 0)
|
|
assert_gt(save_telemetry["bytes_written"], 0)
|
|
assert_gte(save_telemetry["write_usec"], 0)
|
|
assert_gte(save_telemetry["validation_usec"], 0)
|
|
|
|
var latest_generation := generation_ids[-1]
|
|
var generation_path := store.get_generation_directory(latest_generation)
|
|
var generation_files := DirAccess.get_files_at(generation_path)
|
|
assert_eq(generation_files.size(), second.get_chunk_ids().size() + 1)
|
|
assert_true(RegionalChunkedFileStore.MANIFEST_FILE_NAME in generation_files)
|
|
for file_name: String in generation_files:
|
|
assert_false("/" in file_name)
|
|
assert_false("\\" in file_name)
|
|
assert_lte(file_name.length(), 64)
|
|
var decoded: Variant = _read_variant(generation_path.path_join(file_name))
|
|
assert_true(_contains_only_primitive_values(decoded))
|
|
|
|
var restored := store.load_archive()
|
|
assert_not_null(restored)
|
|
assert_eq(restored.checksum(), second.checksum())
|
|
assert_eq(restored.restore_service().checksum(), second.restore_service().checksum())
|
|
var load_telemetry := store.get_last_telemetry()
|
|
assert_true(load_telemetry["succeeded"])
|
|
assert_eq(load_telemetry["generation_id"], latest_generation)
|
|
assert_false(load_telemetry["recovered_generation"])
|
|
assert_gt(load_telemetry["bytes_read"], 0)
|
|
assert_gte(load_telemetry["read_usec"], 0)
|
|
assert_gte(load_telemetry["validation_usec"], 0)
|
|
|
|
|
|
func test_interrupted_pointer_and_corrupt_latest_generation_recover_last_valid() -> void:
|
|
var store := RegionalChunkedFileStore.new(_test_directory)
|
|
var first := _fixture_archive(false)
|
|
var second := _fixture_archive(true)
|
|
assert_true(store.save(first))
|
|
var first_generation := store.get_generation_ids()[0]
|
|
|
|
var current_pointer := ProjectSettings.globalize_path(store.get_current_pointer_path())
|
|
var previous_pointer := ProjectSettings.globalize_path(
|
|
_test_directory.path_join(RegionalChunkedFileStore.PREVIOUS_POINTER_FILE_NAME)
|
|
)
|
|
assert_eq(DirAccess.rename_absolute(current_pointer, previous_pointer), OK)
|
|
var recovered_missing_pointer := store.load_archive()
|
|
assert_not_null(recovered_missing_pointer)
|
|
assert_eq(recovered_missing_pointer.checksum(), first.checksum())
|
|
assert_true(store.get_last_telemetry()["recovered_generation"])
|
|
|
|
assert_true(store.save(second))
|
|
var latest_generation := store.get_generation_ids()[-1]
|
|
var latest_path := store.get_generation_directory(latest_generation)
|
|
var manifest: Dictionary = _read_variant(
|
|
latest_path.path_join(RegionalChunkedFileStore.MANIFEST_FILE_NAME)
|
|
)
|
|
var first_chunk_file := String(manifest["chunk_files"][0]["file_name"])
|
|
_write_variant(latest_path.path_join(first_chunk_file), {"corrupt": true})
|
|
var interrupted_path := ProjectSettings.globalize_path(
|
|
store.get_generations_directory().path_join(
|
|
"temporary_generation_00000000000000000003_interrupted"
|
|
)
|
|
)
|
|
assert_eq(DirAccess.make_dir_recursive_absolute(interrupted_path), OK)
|
|
_write_variant(interrupted_path.path_join("partial.bin"), {"partial": true})
|
|
|
|
var recovered := store.load_archive()
|
|
assert_not_null(recovered)
|
|
assert_eq(recovered.checksum(), first.checksum())
|
|
assert_eq(store.get_last_telemetry()["generation_id"], first_generation)
|
|
assert_true(store.get_last_telemetry()["recovered_generation"])
|
|
assert_gte(store.get_last_telemetry()["candidates_validated"], 2)
|
|
assert_true(FileAccess.file_exists(latest_path.path_join(first_chunk_file)))
|
|
|
|
|
|
func test_partial_location_load_reads_only_selected_chunks_and_keeps_unloaded_authority() -> void:
|
|
var store := RegionalChunkedFileStore.new(_test_directory)
|
|
var archive := _fixture_archive(false)
|
|
assert_true(store.save(archive))
|
|
var saved_telemetry := store.get_last_telemetry()
|
|
var generation_id := store.get_generation_ids()[0]
|
|
var generation_path := store.get_generation_directory(generation_id)
|
|
var manifest: Dictionary = _read_variant(
|
|
generation_path.path_join(RegionalChunkedFileStore.MANIFEST_FILE_NAME)
|
|
)
|
|
var scheduler_entry := _find_chunk_file_entry(
|
|
manifest, RegionalChunkedPersistence.SCHEDULER_CHUNK_ID
|
|
)
|
|
var scheduler_path := generation_path.path_join(String(scheduler_entry["file_name"]))
|
|
_write_variant(scheduler_path, {"corrupt_unloaded_scheduler": true})
|
|
|
|
var partial := store.load_active_location_metadata(ORIGIN_LOCATION_ID)
|
|
assert_false(partial.is_empty())
|
|
assert_eq(partial["generation_id"], generation_id)
|
|
assert_eq(
|
|
partial["loaded_chunk_ids"],
|
|
[
|
|
RegionalChunkedPersistence.GLOBAL_CHUNK_ID,
|
|
"location:%s" % ORIGIN_LOCATION_ID,
|
|
]
|
|
)
|
|
assert_true(RegionalChunkedPersistence.SCHEDULER_CHUNK_ID in partial["unloaded_chunk_ids"])
|
|
assert_eq(partial["mobile_group_refs"].size(), 1)
|
|
assert_false(partial["full_generation_validated"])
|
|
assert_true(FileAccess.file_exists(scheduler_path))
|
|
var partial_telemetry := store.get_last_telemetry()
|
|
assert_true(partial_telemetry["partial_load"])
|
|
assert_eq(partial_telemetry["files_read"], 4)
|
|
assert_lt(partial_telemetry["bytes_read"], saved_telemetry["bytes_written"])
|
|
assert_null(store.load_archive())
|
|
|
|
|
|
func test_unsafe_base_and_traversal_pointer_cannot_escape_generation_root() -> void:
|
|
var archive := _fixture_archive(false)
|
|
var unsafe_relative := RegionalChunkedFileStore.new("../regional_escape")
|
|
assert_false(unsafe_relative.save(archive))
|
|
assert_true("unsafe" in unsafe_relative.get_last_error())
|
|
assert_false(RegionalChunkedFileStore.new("user://").save(archive))
|
|
assert_false(RegionalChunkedFileStore.new("res://").save(archive))
|
|
|
|
var store := RegionalChunkedFileStore.new(_test_directory)
|
|
assert_true(store.save(archive))
|
|
assert_eq(store.get_generation_directory("../outside"), "")
|
|
var malicious_pointer := {
|
|
"schema_version": RegionalChunkedFileStore.SCHEMA_VERSION,
|
|
"format_id": RegionalChunkedFileStore.FORMAT_ID,
|
|
"generation_id": "../outside",
|
|
"manifest_checksum": "0".repeat(64),
|
|
"archive_checksum": "0".repeat(64),
|
|
}
|
|
_write_variant(store.get_current_pointer_path(), malicious_pointer)
|
|
var recovered := store.load_archive()
|
|
assert_not_null(recovered)
|
|
assert_eq(recovered.checksum(), archive.checksum())
|
|
assert_true(store.get_last_telemetry()["recovered_generation"])
|
|
|
|
|
|
func test_explicit_conservative_prune_keeps_current_and_two_newest_valid_generations() -> void:
|
|
var store := RegionalChunkedFileStore.new(_test_directory)
|
|
var first := _fixture_archive(false)
|
|
var latest := _fixture_archive(true)
|
|
assert_true(store.save(first))
|
|
assert_true(store.save(latest))
|
|
assert_true(store.save(latest))
|
|
var before := store.get_generation_ids()
|
|
assert_eq(before.size(), 3)
|
|
|
|
assert_eq(store.prune_old_generations(2), 1)
|
|
assert_eq(store.get_generation_ids(), [before[1], before[2]])
|
|
assert_eq(store.get_last_telemetry()["operation"], "prune_old_generations")
|
|
assert_eq(store.get_last_telemetry()["generations_pruned"], 1)
|
|
assert_true(store.get_last_telemetry()["succeeded"])
|
|
assert_gt(store.get_last_telemetry()["files_deleted"], 0)
|
|
assert_eq(store.load_archive().checksum(), latest.checksum())
|
|
|
|
var retained := store.get_generation_ids()
|
|
assert_eq(store.prune_old_generations(1), 0)
|
|
assert_eq(store.get_generation_ids(), retained)
|
|
assert_true("at least two" in store.get_last_error())
|
|
|
|
|
|
func test_partial_load_does_not_resurrect_a_location_removed_by_newer_authority() -> void:
|
|
var store := RegionalChunkedFileStore.new(_test_directory)
|
|
var older_with_destination := _fixture_archive(false)
|
|
var latest_without_destination := _single_location_archive()
|
|
assert_true(store.save(older_with_destination))
|
|
assert_true(store.save(latest_without_destination))
|
|
|
|
assert_true(store.load_active_location_metadata(DESTINATION_LOCATION_ID).is_empty())
|
|
assert_true("does not contain" in store.get_last_error())
|
|
assert_eq(store.load_archive().checksum(), latest_without_destination.checksum())
|
|
|
|
|
|
func _fixture_archive(departed: bool) -> RegionalChunkedPersistence:
|
|
var origin_location := LocationStateRecord.create(
|
|
ORIGIN_LOCATION_ID, WORLD_ID, &"settlement", "Origin", _address(ORIGIN_LOCATION_ID)
|
|
)
|
|
var destination_location := LocationStateRecord.create(
|
|
DESTINATION_LOCATION_ID,
|
|
WORLD_ID,
|
|
&"settlement",
|
|
"Destination",
|
|
_address(DESTINATION_LOCATION_ID)
|
|
)
|
|
var origin := SettlementStateRecord.create(
|
|
ORIGIN_SETTLEMENT_ID,
|
|
ORIGIN_LOCATION_ID,
|
|
"Origin",
|
|
&"polity_origin",
|
|
1,
|
|
&"founders_origin",
|
|
0,
|
|
{&"food": 20.0}
|
|
)
|
|
var destination := SettlementStateRecord.create(
|
|
DESTINATION_SETTLEMENT_ID,
|
|
DESTINATION_LOCATION_ID,
|
|
"Destination",
|
|
&"polity_destination",
|
|
1,
|
|
&"founders_destination",
|
|
0,
|
|
{&"food": 4.0}
|
|
)
|
|
var route := RouteStateRecord.create(ROUTE_ID, ORIGIN_LOCATION_ID, DESTINATION_LOCATION_ID, 5)
|
|
var group := MobileGroupStateRecord.create_at_location(
|
|
GROUP_ID,
|
|
&"caravan",
|
|
"Caravan",
|
|
&"polity_origin",
|
|
_address(ORIGIN_LOCATION_ID),
|
|
[],
|
|
{},
|
|
{},
|
|
10.0
|
|
)
|
|
var origin_polity := PolityStateRecord.create(
|
|
&"polity_origin", "Origin polity", ORIGIN_LOCATION_ID, [ORIGIN_SETTLEMENT_ID]
|
|
)
|
|
var destination_polity := PolityStateRecord.create(
|
|
&"polity_destination",
|
|
"Destination polity",
|
|
DESTINATION_LOCATION_ID,
|
|
[DESTINATION_SETTLEMENT_ID]
|
|
)
|
|
var locations: Array[LocationStateRecord] = [destination_location, origin_location]
|
|
var settlements: Array[SettlementStateRecord] = [destination, origin]
|
|
var routes: Array[RouteStateRecord] = [route]
|
|
var groups: Array[MobileGroupStateRecord] = [group]
|
|
var persons: Array[PersonStateRecord] = []
|
|
var cohorts: Array[PopulationCohortRecord] = []
|
|
var polities: Array[PolityStateRecord] = [destination_polity, origin_polity]
|
|
var relations: Array[DiplomaticRelationRecord] = []
|
|
var world_state := RegionalWorldState.create(
|
|
WORLD_ID, locations, settlements, routes, groups, persons, cohorts, polities, relations
|
|
)
|
|
var service := RegionalCaravanService.create(
|
|
world_state, RegionalJobScheduler.new(), WorldEventStore.new()
|
|
)
|
|
if departed:
|
|
assert_true(
|
|
service.depart(
|
|
GROUP_ID,
|
|
ORIGIN_SETTLEMENT_ID,
|
|
DESTINATION_SETTLEMENT_ID,
|
|
ROUTE_ID,
|
|
{&"food": 6.0},
|
|
DEPARTURE_TICK
|
|
)
|
|
)
|
|
return RegionalChunkedPersistence.capture(service, 2)
|
|
|
|
|
|
func _single_location_archive() -> RegionalChunkedPersistence:
|
|
var location := LocationStateRecord.create(
|
|
ORIGIN_LOCATION_ID, WORLD_ID, &"settlement", "Origin", _address(ORIGIN_LOCATION_ID)
|
|
)
|
|
var settlement := SettlementStateRecord.create(
|
|
ORIGIN_SETTLEMENT_ID,
|
|
ORIGIN_LOCATION_ID,
|
|
"Origin",
|
|
&"polity_origin",
|
|
1,
|
|
&"founders_origin",
|
|
0,
|
|
{&"food": 20.0}
|
|
)
|
|
var polity := PolityStateRecord.create(
|
|
&"polity_origin", "Origin polity", ORIGIN_LOCATION_ID, [ORIGIN_SETTLEMENT_ID]
|
|
)
|
|
var locations: Array[LocationStateRecord] = [location]
|
|
var settlements: Array[SettlementStateRecord] = [settlement]
|
|
var routes: Array[RouteStateRecord] = []
|
|
var groups: Array[MobileGroupStateRecord] = []
|
|
var persons: Array[PersonStateRecord] = []
|
|
var cohorts: Array[PopulationCohortRecord] = []
|
|
var polities: Array[PolityStateRecord] = [polity]
|
|
var relations: Array[DiplomaticRelationRecord] = []
|
|
var world_state := RegionalWorldState.create(
|
|
WORLD_ID, locations, settlements, routes, groups, persons, cohorts, polities, relations
|
|
)
|
|
var service := RegionalCaravanService.create(
|
|
world_state, RegionalJobScheduler.new(), WorldEventStore.new()
|
|
)
|
|
return RegionalChunkedPersistence.capture(service, 2)
|
|
|
|
|
|
func _address(location_id: StringName) -> SpatialAddress:
|
|
return SpatialAddress.create(WORLD_ID, location_id, Vector3.ZERO)
|
|
|
|
|
|
func _find_chunk_file_entry(manifest: Dictionary, chunk_id: String) -> Dictionary:
|
|
for raw_entry: Variant in manifest["chunk_files"]:
|
|
if raw_entry is Dictionary and String(raw_entry.get("chunk_id", "")) == chunk_id:
|
|
return raw_entry
|
|
return {}
|
|
|
|
|
|
func _read_variant(path: String) -> Variant:
|
|
var file := FileAccess.open(path, FileAccess.READ)
|
|
if file == null:
|
|
return null
|
|
var bytes := file.get_buffer(file.get_length())
|
|
file.close()
|
|
return bytes_to_var(bytes) if not bytes.is_empty() else null
|
|
|
|
|
|
func _write_variant(path: String, value: Variant) -> void:
|
|
var file := FileAccess.open(path, FileAccess.WRITE)
|
|
assert_not_null(file)
|
|
if file == null:
|
|
return
|
|
file.store_buffer(var_to_bytes(value))
|
|
file.flush()
|
|
file.close()
|
|
|
|
|
|
func _contains_only_primitive_values(value: Variant) -> bool:
|
|
match typeof(value):
|
|
TYPE_NIL, TYPE_BOOL, TYPE_INT, TYPE_STRING:
|
|
return true
|
|
TYPE_FLOAT:
|
|
return is_finite(float(value))
|
|
TYPE_ARRAY:
|
|
for item: Variant in value:
|
|
if not _contains_only_primitive_values(item):
|
|
return false
|
|
return true
|
|
TYPE_DICTIONARY:
|
|
for key: Variant in value:
|
|
if not key is String or not _contains_only_primitive_values(value[key]):
|
|
return false
|
|
return true
|
|
return false
|
|
|
|
|
|
func _remove_tree(absolute_path: String) -> void:
|
|
var directory := DirAccess.open(absolute_path)
|
|
if directory == null:
|
|
return
|
|
directory.include_hidden = true
|
|
directory.list_dir_begin()
|
|
var entry_name := directory.get_next()
|
|
while not entry_name.is_empty():
|
|
var entry_path := absolute_path.path_join(entry_name)
|
|
if directory.current_is_dir():
|
|
_remove_tree(entry_path)
|
|
else:
|
|
DirAccess.remove_absolute(entry_path)
|
|
entry_name = directory.get_next()
|
|
directory.list_dir_end()
|
|
DirAccess.remove_absolute(absolute_path)
|