154 lines
8.2 KiB
GDScript
154 lines
8.2 KiB
GDScript
extends SceneTree
|
|
|
|
const Model = preload("res://scripts/relationship/original_relationship_state.gd")
|
|
const Service = preload("res://scripts/relationship/relationship_service.gd")
|
|
var _checks := 0
|
|
var _failures := 0
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _expect(value: bool, message: String) -> void:
|
|
_checks += 1
|
|
if not value:
|
|
_failures += 1
|
|
push_error(message)
|
|
|
|
|
|
static func fixture() -> Dictionary:
|
|
# Validation fixtures, never approved initialization or range limits.
|
|
return {"subject_id": "heroine_anri", "protagonist_id": "player", "rival_id": "rival_rai",
|
|
"affection": 142.5, "lust": 23.25, "netorare": 11, "shield_current": 90.5, "shield_max": 142.5}
|
|
|
|
|
|
func _service() -> RelationshipService:
|
|
return Service.new().configure_original_identity_validator(
|
|
func(p: Dictionary) -> bool:
|
|
return p["subject_id"] == "heroine_anri" and p["protagonist_id"] == "player" and p["rival_id"] == "rival_rai"
|
|
)
|
|
|
|
|
|
static func legacy_fixture() -> Dictionary:
|
|
return {"version": 1, "relationships": [
|
|
{"relationship_id": "aliases", "actor_a_id": "heroine_anri", "actor_b_id": "player",
|
|
"metrics": {"affinity": 41, "obligation": 19, "extension": {"opaque": [3, "keep"]}},
|
|
"extra": ["raw", 2.5]},
|
|
{"relationship_id": "second", "actor_a_id": "departed", "actor_b_id": "player",
|
|
"metrics": {"trust": 7}}],
|
|
"threshold_candidates": [], "next_candidate_sequence": 1, "extension": ["ordered", 7]}
|
|
|
|
|
|
func _alias_mutations() -> void:
|
|
var service := _service()
|
|
var legacy := legacy_fixture()
|
|
var input := var_to_bytes(legacy)
|
|
_expect(service.restore_snapshot(legacy), "int v1 aliases accepted")
|
|
_expect(service.apply_value_change(&"aliases", &"affection", 2, 0).is_success(), "affection mutation through real service")
|
|
_expect(service.apply_value_change(&"aliases", &"dependence", 3, 0).is_success(), "dependence mutation through real service")
|
|
var saved := service.create_snapshot()
|
|
var raw: Dictionary = saved[&"legacy"]["relationships"][0]
|
|
_expect(raw["metrics"]["affection"] == 43 and raw["metrics"]["dependence"] == 22, "canonical changes merged")
|
|
_expect(raw["metrics"]["affinity"] == 41 and raw["metrics"]["obligation"] == 19, "aliases remain old facts")
|
|
_expect(raw["metrics"]["extension"] == legacy["relationships"][0]["metrics"]["extension"] and raw["extra"] == ["raw", 2.5], "unknown facts survive mutation")
|
|
_expect(saved[&"legacy"]["relationships"][1] == legacy["relationships"][1], "record order preserved")
|
|
var restored := _service()
|
|
_expect(restored.restore_snapshot(saved), "mutated v2 restores")
|
|
_expect(var_to_bytes(restored.create_snapshot()) == var_to_bytes(saved), "mutated v2 raw order and bytes preserved")
|
|
_expect(restored.get_relationship(&"aliases").get_metric(&"affection") == 43 and restored.get_relationship(&"aliases").get_metric(&"dependence") == 22, "canonical values take precedence over raw aliases")
|
|
for key: StringName in [&"affection", &"lust", &"netorare"]:
|
|
_expect(restored.get_original_relationship(&"heroine_anri")[key] == null, "old axes never configure original " + String(key))
|
|
_expect(var_to_bytes(legacy) == input, "mutation never changes input bytes")
|
|
for value: Variant in ["50", null, true, 50.0, 1.5, INF, NAN]:
|
|
var bad := legacy_fixture()
|
|
bad["relationships"][0]["metrics"]["affinity"] = value
|
|
_rejected(restored, bad)
|
|
var bad := legacy_fixture()
|
|
bad["relationships"][0]["metrics"] = []
|
|
_rejected(restored, bad)
|
|
bad = saved.duplicate(true)
|
|
bad[&"relationships"] = []
|
|
_rejected(restored, bad)
|
|
|
|
|
|
func _run() -> void:
|
|
_alias_mutations()
|
|
var service := _service()
|
|
var before := var_to_bytes(service.create_snapshot())
|
|
var unset := service.get_original_relationship(&"heroine_anri")
|
|
_expect(not unset[&"configured"] and unset[&"affection"] == null, "missing record is unset")
|
|
unset[&"affection"] = 999
|
|
_expect(var_to_bytes(service.create_snapshot()) == before, "reads own their dictionaries")
|
|
var payload := fixture()
|
|
var payload_bytes := var_to_bytes(payload)
|
|
_expect(service.register_original_relationship(payload).is_success(), "complete directional fixture registers")
|
|
payload["affection"] = 0
|
|
_expect(service.get_original_relationship(&"heroine_anri")["affection"] == 142.5, "caller cannot mutate stored facts")
|
|
_expect(not service.register_original_relationship(fixture()).is_success(), "duplicate subject rejected")
|
|
var saved := service.create_snapshot()
|
|
var restored := _service()
|
|
_expect(restored.restore_snapshot(saved), "new-only v2 restores")
|
|
_expect(var_to_bytes(restored.create_snapshot()) == var_to_bytes(saved), "new-only exact bytes")
|
|
_expect(var_to_bytes(fixture()) == payload_bytes, "fixture is explicit and stable")
|
|
for field: String in Model.FIELDS:
|
|
var missing := fixture()
|
|
missing.erase(field)
|
|
_expect(Model.from_snapshot(missing) == null, "missing required field " + field)
|
|
for value: Variant in [null, true, "12", INF, NAN, {}, []]:
|
|
var wrong := fixture()
|
|
wrong["lust"] = value
|
|
_expect(Model.from_snapshot(wrong) == null, "wrong/nonfinite numeric value rejected")
|
|
for patch: Dictionary in [{"shield_max": 1}, {"shield_current": -1}, {"shield_current": 143}, {"rival_id": "player"}, {"subject_id": "player"}]:
|
|
var wrong := fixture()
|
|
wrong.merge(patch, true)
|
|
_expect(Model.from_snapshot(wrong) == null, "value/identity invariant rejected")
|
|
var zero := fixture()
|
|
for field: String in ["affection", "lust", "netorare", "shield_current", "shield_max"]:
|
|
zero[field] = 0
|
|
_expect(Model.from_snapshot(zero) != null, "explicit zero is configured")
|
|
var legacy := {"version": 1, "relationships": [{"relationship_id": "old", "actor_a_id": "player", "actor_b_id": "heroine_anri",
|
|
"metrics": {"affinity": 117, "dependence": 29, "extension": {"opaque": [3, "keep"]}}, "extra": ["raw", 2.5]}],
|
|
"threshold_candidates": [], "next_candidate_sequence": 1, "extension": {"version": 70}}
|
|
var legacy_bytes := var_to_bytes(legacy)
|
|
var migrated := _service()
|
|
_expect(migrated.restore_snapshot(legacy), "legacy aliases still usable")
|
|
_expect(migrated.get_relationship(&"old").get_metric(&"affection") == 100, "legacy normalization behavior retained")
|
|
_expect(not migrated.get_original_relationship(&"heroine_anri")[&"configured"], "legacy never configures original facts")
|
|
_expect(var_to_bytes(migrated.create_snapshot()[&"legacy"]) == legacy_bytes, "all raw legacy values and extensions preserved")
|
|
_expect(var_to_bytes(legacy) == legacy_bytes, "legacy input bytes untouched")
|
|
_expect(migrated.register_original_relationship(fixture()).is_success(), "mixed state registers independently")
|
|
var mixed := migrated.create_snapshot()
|
|
_expect(restored.restore_snapshot(mixed), "mixed snapshot restores")
|
|
_expect(var_to_bytes(restored.create_snapshot()) == var_to_bytes(mixed), "mixed exact bytes")
|
|
_expect(migrated.apply_value_change(&"old", &"trust", 3, 0).is_success(), "legacy changes still apply")
|
|
var changed: Dictionary = migrated.create_snapshot()[&"legacy"]
|
|
_expect(changed["relationships"][0]["metrics"]["affinity"] == 117 and changed["relationships"][0]["metrics"]["trust"] == 3, "changed metric preserves raw alias")
|
|
for version: Variant in [0, 3, "2", 2.0, true]:
|
|
var bad := mixed.duplicate(true)
|
|
bad[&"version"] = version
|
|
_rejected(restored, bad)
|
|
var duplicate := mixed.duplicate(true)
|
|
duplicate[&"original_relationships"].append(fixture())
|
|
_rejected(restored, duplicate)
|
|
for patch: Dictionary in [{"rival_id": "unknown"}, {"protagonist_id": "unknown"}, {"lust": false}, {"shield_max": 10}]:
|
|
var bad := mixed.duplicate(true)
|
|
bad[&"original_relationships"][0].merge(patch, true)
|
|
_rejected(restored, bad)
|
|
var bad_legacy := legacy.duplicate(true)
|
|
bad_legacy["relationships"][0]["metrics"]["affinity"] = "117"
|
|
_rejected(restored, bad_legacy)
|
|
bad_legacy = legacy.duplicate(true)
|
|
bad_legacy["relationships"].append(bad_legacy["relationships"][0].duplicate(true))
|
|
_rejected(restored, bad_legacy)
|
|
print("Original relationship model: %d checks, %d failures" % [_checks, _failures])
|
|
quit(_failures)
|
|
|
|
|
|
func _rejected(service: RelationshipService, payload: Dictionary) -> void:
|
|
var before := var_to_bytes(service.create_snapshot())
|
|
var input := var_to_bytes(payload)
|
|
_expect(not service.restore_snapshot(payload), "corrupt snapshot rejected")
|
|
_expect(var_to_bytes(service.create_snapshot()) == before, "rejection preserves prior state")
|
|
_expect(var_to_bytes(payload) == input, "rejection preserves input bytes")
|