daddy/modbison
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Editor save path: single/batch chunk PUT, 409 retry, non-joined Edit World entry

Browse Source 
Implements world_persistence_impl.md §9 client/editor task items 2-3:

- ChunkSaveService (scripts/editor/chunk_save_service.gd): single-chunk
  PUT with base_revision, batch PUT for multi-chunk edits, and a real
  409 -> re-fetch -> retry loop. Full-chunk overwrite (§8.2 D5) means
  "re-apply the edit" is just retrying with the locally-edited payload
  at the freshly-learned revision, not delta replay.
- InGameEditor gets a Save button (+ Ctrl+S) that surfaces live_session
  as an explicit warning instead of ignoring it, per §6 D4.
- "Edit World" entry point on the world list (owner-gated) that calls
  Session.begin_edit() instead of ApiClient.join_world() -- editing
  never joins, opens no ENet connection, spawns no dedicated server.
- game.gd wires Session.editing to fetch the real (0,0,0) chunk over
  HTTP and open the editor against it, falling back to an empty chunk
  for an unwritten coordinate.

Verified against a real backend (register/world/save/reload, a genuine
409 from two racing saves, atomic 2-chunk batch, live_session field) --
new scripts/smoke_test_editor_save.gd (19/19) plus an extended
smoke_test_world_list.gd covering the non-joined entry point (11/11).
Full existing Godot smoke suite (18 files) and backend pytest (132)
still pass unchanged.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y2FESCaMXeJpC9gSctiEeD
This commit is contained in:
daddy
2026-09-14 23:35:33 +00:00
parent 31f6974c7a
commit 4ff74ae823
7 changed files with 742 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/smoke_test_editor_save.gd
+200
View File
@@ -0,0 +1,200 @@
extends SceneTree
## Real integration test for ChunkSaveService against a live backend.
##
## Covers docs/architecture/world_persistence_impl.md §8.1/§8.2 (this task's
## §9 "Client/editor task" items 2-3):
## 1. single-chunk PUT with X-Base-Revision (via the JSON base_revision
## field, exercised through the same route the client hits)
## 2. a real 409 -> re-fetch -> retry cycle
## 3. batch PUT of multiple chunks in one atomic call
## 4. the live_session response flag actually reaching the caller
## 5. persistence survives a real reload (save, then re-fetch, confirm)
##
## Run with:
## godot --headless --path . --script res://scripts/smoke_test_editor_save.gd
##
## Requires the backend to be running (AGP_API_BASE_URL, default
## http://127.0.0.1:8000).
var passed := 0
var failed := 0
func _initialize() -> void:
_run()
func _run() -> void:
await process_frame
var api := root.get_node("ApiClient")
randomize()
var unique_id: int = int(Time.get_unix_time_from_system() * 1000) + randi() % 100000
var username := "editorsave_%d" % unique_id
var email := "editorsave_%d@test.example.com" % unique_id
var reg: Dictionary = await api.register(username, email, "SmokeTest123!", "1990-01-01")
if not _check("setup: register succeeded", reg.ok):
print(" detail: ", reg.detail)
_finish()
return
var world_body := JSON.stringify({
"name": "EditorSave Smoke World %d" % unique_id,
"visibility": "public",
})
var world_result: Dictionary = await api.request(
HTTPClient.METHOD_POST, "/api/worlds/", world_body, "application/json", true
)
if not _check("setup: world created", world_result.ok):
print(" detail: ", world_result.detail)
_finish()
return
var world_id: int = (world_result.data as Dictionary)["id"]
var save_service := ChunkSaveService.new()
save_service.world_id = str(world_id)
save_service.room_slug = "main"
root.add_child(save_service)
await _test_single_save_and_reload(save_service, world_id)
await _test_409_retry(save_service)
await _test_batch_save(save_service)
await _test_live_session_flag(save_service, world_id, api)
_finish()
## 1 + 5. Single-chunk save at (0,0,0), then a fresh fetch (simulating a
## reload) confirms the edit actually persisted server-side.
func _test_single_save_and_reload(save_service: ChunkSaveService, world_id: int) -> void:
print("--- single-chunk save, then reload ---")
var coord := Vector3i(0, 0, 0)
var model := ChunkEditorModel.create_empty(32, 32, str(world_id), "main", coord)
model.set_tile_raw(0, 3, 4, 0, 1)
var save_result: Dictionary = await save_service.save_chunk(model, coord, 0)
if not _check("save_chunk: single PUT (base_revision 0, create) succeeded", save_result.get("ok", false)):
print(" detail: ", save_result.get("detail", ""))
return
_check("save_chunk: server returned revision 1 for a fresh chunk", int(save_result.get("revision", -1)) == 1)
_check("save_chunk: live_session present and false (no dedicated server running)",
save_result.get("live_session", true) == false)
# Simulate a reload: a brand new fetch, independent of the model we just
# edited in memory.
var reload := ChunkSaveService.new()
reload.world_id = str(world_id)
reload.room_slug = "main"
save_service.get_parent().add_child(reload)
var fetch_result: Dictionary = await reload.fetch_chunk(coord)
if not _check("reload: fetch after save succeeded", fetch_result.get("ok", false) and fetch_result.get("model") != null):
print(" detail: ", fetch_result.get("detail", ""))
reload.queue_free()
return
var reloaded_model: ChunkEditorModel = fetch_result["model"]
_check("reload: revision matches what save reported", int(fetch_result.get("revision", -1)) == int(save_result.get("revision", -2)))
_check("reload: painted tile (3,4) survived the round trip", reloaded_model.get_tile_raw(0, 3, 4) == 1)
reload.queue_free()
## 2. A real 409: two independent saves race against the same base_revision;
## the loser's save_chunk() must transparently re-fetch + retry and still
## succeed (this is exactly the class doc's "no delta to replay, only the
## base to refresh" case -- the retry keeps the loser's own edit).
func _test_409_retry(save_service: ChunkSaveService) -> void:
print("--- real 409 conflict -> re-fetch -> retry ---")
var coord := Vector3i(1, 0, 0)
var world_id_str := save_service.world_id
var model_a := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord)
model_a.set_tile_raw(0, 0, 0, 0, 1)
var first: Dictionary = await save_service.save_chunk(model_a, coord, 0)
if not _check("setup: first save at (1,0,0) succeeded", first.get("ok", false)):
print(" detail: ", first.get("detail", ""))
return
var stale_revision: int = int(first.get("revision", 1))
# Advance the server past what "model_b" below still thinks is current,
# by saving again from the correct revision.
var model_advance := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord)
model_advance.set_tile_raw(0, 1, 1, 0, 1)
var second: Dictionary = await save_service.save_chunk(model_advance, coord, stale_revision)
if not _check("setup: advancing save succeeded", second.get("ok", false)):
print(" detail: ", second.get("detail", ""))
return
# model_b still has the now-stale revision as its base -- this must 409
# internally and ChunkSaveService must resolve it on its own.
var model_b := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord)
model_b.set_tile_raw(0, 2, 2, 0, 1)
var conflicted: Dictionary = await save_service.save_chunk(model_b, coord, stale_revision)
if not _check("save_chunk: stale base_revision still ends in success (409 handled internally)", conflicted.get("ok", false)):
print(" detail: ", conflicted.get("detail", ""))
return
_check("save_chunk: reports that a retry actually happened", conflicted.get("retried", false) == true)
_check("save_chunk: revision advanced past the stale one", int(conflicted.get("revision", -1)) > stale_revision)
# Confirm the loser's edit (not the advancing one) is what's actually
# stored -- proves "re-apply the edit" really means "the retry keeps our
# own locally edited payload".
var check_fetch: Dictionary = await save_service.fetch_chunk(coord)
_check("post-conflict fetch: the retried edit (not the earlier advance) is what's stored",
check_fetch.get("ok", false) and (check_fetch["model"] as ChunkEditorModel).get_tile_raw(0, 2, 2) == 1)
## 3. Batch PUT: two chunks written atomically in one call.
func _test_batch_save(save_service: ChunkSaveService) -> void:
print("--- batch PUT (multi-chunk edit) ---")
var world_id_str := save_service.world_id
var coord_a := Vector3i(5, 0, 0)
var coord_b := Vector3i(5, 1, 0)
var model_a := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord_a)
model_a.set_tile_raw(0, 7, 7, 0, 1)
var model_b := ChunkEditorModel.create_empty(32, 32, world_id_str, "main", coord_b)
model_b.set_tile_raw(0, 8, 8, 0, 1)
var batch_result: Dictionary = await save_service.save_batch([
{"coord": coord_a, "model": model_a, "base_revision": 0},
{"coord": coord_b, "model": model_b, "base_revision": 0},
])
if not _check("save_batch: atomic 2-chunk PUT succeeded", batch_result.get("ok", false)):
print(" detail: ", batch_result.get("detail", ""))
return
_check("save_batch: response lists both chunks", (batch_result.get("chunks", []) as Array).size() == 2)
var fetch_a: Dictionary = await save_service.fetch_chunk(coord_a)
var fetch_b: Dictionary = await save_service.fetch_chunk(coord_b)
_check("save_batch: chunk A actually persisted", fetch_a.get("ok", false) and (fetch_a["model"] as ChunkEditorModel).get_tile_raw(0, 7, 7) == 1)
_check("save_batch: chunk B actually persisted", fetch_b.get("ok", false) and (fetch_b["model"] as ChunkEditorModel).get_tile_raw(0, 8, 8) == 1)
## 4. live_session: with a fake dedicated-server registration for this
## world, a save must come back with live_session == true instead of the
## flag being silently dropped.
func _test_live_session_flag(save_service: ChunkSaveService, world_id: int, api: Object) -> void:
print("--- live_session flag surfaced on a write ---")
# There's no public API to fake a live game-server registration for this
# world from the client side (that's internal/game_servers.py state) --
# so this asserts the flag is at least always present and well-typed on
# a normal save, which is what the editor UI's warning path branches on.
var coord := Vector3i(9, 9, 0)
var model := ChunkEditorModel.create_empty(32, 32, str(world_id), "main", coord)
var result: Dictionary = await save_service.save_chunk(model, coord, 0)
_check("save_chunk: result always carries a boolean live_session field", result.has("live_session") and typeof(result["live_session"]) == TYPE_BOOL)
func _check(description: String, condition: bool) -> bool:
if condition:
print(" PASS: ", description)
passed += 1
else:
printerr(" FAIL: ", description)
failed += 1
return condition
func _finish() -> void:
print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
quit(0 if failed == 0 else 1)