449 lines
16 KiB
GDScript
449 lines
16 KiB
GDScript
extends GdUnitTestSuite
|
|
|
|
## NEO-24: GdUnit4 suite for `TargetSelectionClient`. Mirrors
|
|
## `position_authority_client_test.gd` — mock HTTP transport enqueues JSON responses and
|
|
## (optionally) tracks request count so the movement-triggered refresh cooldown is testable.
|
|
|
|
const TargetSelectionTestDouble := preload("res://test/target_selection_test_double.gd")
|
|
|
|
const ALPHA_ID := "prototype_target_alpha"
|
|
const BETA_ID := "prototype_target_beta"
|
|
|
|
|
|
# In-process transport: not an HTTPRequest subclass (Godot 4 will not call script `request()`
|
|
# on those). Counts requests so "no lock → no GET" and "cooldown collapses snaps" are testable.
|
|
class MockHttpTransport:
|
|
extends Node
|
|
signal request_completed(
|
|
result: int, response_code: int, headers: PackedStringArray, body: PackedByteArray
|
|
)
|
|
var request_count: int = 0
|
|
var last_url: String = ""
|
|
var last_body: String = ""
|
|
var last_method: HTTPClient.Method = HTTPClient.METHOD_GET
|
|
var _queue: Array[Dictionary] = []
|
|
|
|
func enqueue(result: int, code: int, body: String) -> void:
|
|
_queue.append({"result": result, "code": code, "body": body})
|
|
|
|
func request(
|
|
url: String,
|
|
_custom_headers: PackedStringArray = PackedStringArray(),
|
|
method: HTTPClient.Method = HTTPClient.METHOD_GET,
|
|
request_data: String = ""
|
|
) -> Error:
|
|
request_count += 1
|
|
last_url = url
|
|
last_method = method
|
|
last_body = request_data
|
|
if _queue.is_empty():
|
|
return ERR_UNAVAILABLE
|
|
var r: Dictionary = _queue.pop_front()
|
|
var body_bytes: PackedByteArray = str(r["body"]).to_utf8_buffer()
|
|
request_completed.emit(r["result"], r["code"], PackedStringArray(), body_bytes)
|
|
return OK
|
|
|
|
|
|
func _make_client(http_transport: Node) -> Node:
|
|
var c: Node = TargetSelectionTestDouble.new()
|
|
c.set("injected_http", http_transport)
|
|
auto_free(http_transport)
|
|
auto_free(c)
|
|
add_child(c)
|
|
return c
|
|
|
|
|
|
func _target_state_json(locked_id_or_null: Variant, validity: String, sequence: int = 0) -> String:
|
|
var locked := "null"
|
|
if locked_id_or_null is String and not (locked_id_or_null as String).is_empty():
|
|
locked = '"%s"' % (locked_id_or_null as String)
|
|
return (
|
|
'{"schemaVersion":1,"playerId":"dev-local-1","lockedTargetId":%s,' % locked
|
|
+ '"validity":"%s","sequence":%d}' % [validity, sequence]
|
|
)
|
|
|
|
|
|
func _select_response_json(
|
|
applied: bool,
|
|
locked_id_or_null: Variant,
|
|
validity: String,
|
|
sequence: int = 0,
|
|
reason: String = ""
|
|
) -> String:
|
|
var target_state := _target_state_json(locked_id_or_null, validity, sequence)
|
|
if applied:
|
|
return '{"schemaVersion":1,"selectionApplied":true,"targetState":%s}' % target_state
|
|
var reason_segment := ""
|
|
if not reason.is_empty():
|
|
reason_segment = ',"reasonCode":"%s"' % reason
|
|
return (
|
|
'{"schemaVersion":1,"selectionApplied":false%s,"targetState":%s}'
|
|
% [reason_segment, target_state]
|
|
)
|
|
|
|
|
|
func test_sync_get_200_emits_state() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(HTTPRequest.RESULT_SUCCESS, 200, _target_state_json(null, "none"))
|
|
var c := _make_client(transport)
|
|
monitor_signals(c)
|
|
# Act
|
|
c.request_sync_from_server()
|
|
# Assert
|
|
await assert_signal(c).is_emitted("target_state_changed", any())
|
|
var state: Dictionary = c.cached_state()
|
|
assert_that(state.get("validity", "")).is_equal("none")
|
|
assert_that(state.get("lockedTargetId", "non-null-sentinel")).is_null()
|
|
|
|
|
|
func test_tab_from_no_lock_selects_first_id() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
monitor_signals(c)
|
|
# Act
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_url).contains("/target/select")
|
|
assert_that(transport.last_method).is_equal(HTTPClient.METHOD_POST)
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % ALPHA_ID)
|
|
await assert_signal(c).is_emitted("target_state_changed", any())
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(ALPHA_ID)
|
|
|
|
|
|
func test_tab_from_alpha_requests_beta() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, BETA_ID, "ok", 2)
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_tab_next()
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % BETA_ID)
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(BETA_ID)
|
|
|
|
|
|
func test_tab_wraps_from_beta_to_alpha() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, BETA_ID, "ok", 2)
|
|
)
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 3)
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_tab_next()
|
|
c.request_tab_next()
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % ALPHA_ID)
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(ALPHA_ID)
|
|
|
|
|
|
func test_denial_reflects_authoritative_target_state() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
# Server denies: selectionApplied=false, lockedTargetId=null, reasonCode=out_of_range.
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS,
|
|
200,
|
|
_select_response_json(false, null, "none", 0, "out_of_range")
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_select_target_id(ALPHA_ID)
|
|
# Assert
|
|
var state: Dictionary = c.cached_state()
|
|
assert_that(bool(state.get("selectionApplied", true))).is_false()
|
|
assert_that(state.get("reasonCode", "")).is_equal("out_of_range")
|
|
assert_that(state.get("lockedTargetId", "sentinel")).is_null()
|
|
|
|
|
|
func test_clear_issues_post_without_target_id() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, null, "none", 4))
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_clear_target()
|
|
# Assert
|
|
assert_that(transport.last_url).contains("/target/select")
|
|
assert_that(transport.last_method).is_equal(HTTPClient.METHOD_POST)
|
|
assert_that(transport.last_body).not_contains("targetId")
|
|
|
|
|
|
func test_authoritative_ack_while_locked_fires_refresh_get() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
# Step 1: lock alpha via POST.
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
# Step 2: movement-triggered GET shows out_of_range (soft lock).
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _target_state_json(ALPHA_ID, "out_of_range", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_select_target_id(ALPHA_ID)
|
|
var count_before_ack: int = transport.request_count
|
|
c.on_authoritative_ack(Vector3.ZERO)
|
|
# Assert
|
|
assert_that(transport.request_count).is_equal(count_before_ack + 1)
|
|
assert_that(c.cached_state().get("validity")).is_equal("out_of_range")
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(ALPHA_ID)
|
|
|
|
|
|
func test_authoritative_ack_without_lock_fires_nothing() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.on_authoritative_ack(Vector3.ZERO)
|
|
# Assert
|
|
assert_that(transport.request_count).is_equal(0)
|
|
|
|
|
|
func test_two_acks_within_cooldown_collapse_to_one_get() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _target_state_json(ALPHA_ID, "out_of_range", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_select_target_id(ALPHA_ID)
|
|
var count_before: int = transport.request_count
|
|
c.on_authoritative_ack(Vector3.ZERO)
|
|
c.on_authoritative_ack(Vector3.ZERO)
|
|
# Assert
|
|
assert_that(transport.request_count).is_equal(count_before + 1)
|
|
|
|
|
|
# Authority stub that captures the last `submit_stream_targets` batch so we can verify
|
|
# `TargetSelectionClient._post_select` kicks a freshness stream before POSTing.
|
|
class FreshnessAuthorityStub:
|
|
extends Node
|
|
var last_batch: Array = []
|
|
var submit_count: int = 0
|
|
|
|
func submit_stream_targets(targets: Array) -> void:
|
|
submit_count += 1
|
|
last_batch = targets.duplicate()
|
|
|
|
|
|
func _make_player(pos: Vector3) -> Node3D:
|
|
var n := Node3D.new()
|
|
n.global_position = pos
|
|
auto_free(n)
|
|
add_child(n)
|
|
return n
|
|
|
|
|
|
func test_select_post_kicks_freshness_stream_before_posting() -> void:
|
|
# Arrange
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
var authority := FreshnessAuthorityStub.new()
|
|
auto_free(authority)
|
|
add_child(authority)
|
|
var player := _make_player(Vector3(1.5, 0.5, -2.25))
|
|
c.set_freshness_kick(authority, player)
|
|
# Act
|
|
c.request_select_target_id(ALPHA_ID)
|
|
# Assert
|
|
# Exactly one freshness submit, matching the pre-POST capsule position.
|
|
assert_that(authority.submit_count).is_equal(1)
|
|
assert_that(authority.last_batch.size()).is_equal(1)
|
|
assert_that(authority.last_batch[0]).is_equal(Vector3(1.5, 0.5, -2.25))
|
|
# And the select POST still went out as usual.
|
|
assert_that(transport.last_url).contains("/target/select")
|
|
|
|
|
|
func test_select_post_includes_position_hint_when_player_wired() -> void:
|
|
# Arrange
|
|
# NEO-24 follow-up #5: the select POST body must carry the live capsule position as
|
|
# `positionHint` so the server's range check can bypass any stale stored snap.
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, BETA_ID, "ok", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
var authority := FreshnessAuthorityStub.new()
|
|
auto_free(authority)
|
|
add_child(authority)
|
|
# Values chosen so `JSON.stringify` emits exact decimal representations (no float precision
|
|
# drift): 3.0 → "3", 0.5 → "0.5", 5.0 → "5". Re-parse the JSON for precise assertions.
|
|
var player := _make_player(Vector3(3.0, 0.5, 5.0))
|
|
c.set_freshness_kick(authority, player)
|
|
# Act
|
|
c.request_select_target_id(BETA_ID)
|
|
# Assert
|
|
var parsed: Variant = JSON.parse_string(transport.last_body)
|
|
assert_that(parsed is Dictionary).is_true()
|
|
var body: Dictionary = parsed
|
|
assert_that(body.get("targetId")).is_equal(BETA_ID)
|
|
assert_that(body.has("positionHint")).is_true()
|
|
var hint: Dictionary = body["positionHint"]
|
|
assert_float(hint.get("x")).is_equal_approx(3.0, 0.0001)
|
|
assert_float(hint.get("y")).is_equal_approx(0.5, 0.0001)
|
|
assert_float(hint.get("z")).is_equal_approx(5.0, 0.0001)
|
|
|
|
|
|
func test_select_post_without_freshness_wiring_is_a_noop() -> void:
|
|
# Arrange
|
|
# Regression: tests that construct the client without `set_freshness_kick(...)` must
|
|
# still POST normally, *without* a `positionHint` (hint is opt-in per wiring).
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_select_target_id(ALPHA_ID)
|
|
# Assert
|
|
assert_that(transport.last_url).contains("/target/select")
|
|
# No `positionHint` key in the body when no player is wired — re-parse so the assertion
|
|
# is robust against JSON whitespace / key ordering.
|
|
var parsed: Variant = JSON.parse_string(transport.last_body)
|
|
assert_that(parsed is Dictionary).is_true()
|
|
assert_that((parsed as Dictionary).has("positionHint")).is_false()
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(ALPHA_ID)
|
|
|
|
|
|
func test_tab_from_no_lock_skips_out_of_range_and_picks_beta() -> void:
|
|
# Arrange
|
|
# Player stands next to beta (well outside alpha's ring). Without the range-aware
|
|
# tab cycle the server denies with `out_of_range` on alpha — see NEO-24 follow-up #3.
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, BETA_ID, "ok", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
var authority := FreshnessAuthorityStub.new()
|
|
auto_free(authority)
|
|
add_child(authority)
|
|
# Near beta anchor (3, 3), ~1.4 m horizontal — inside 6 m. Far from alpha at (-3, -3).
|
|
var player := _make_player(Vector3(4.0, 0.5, 4.0))
|
|
c.set_freshness_kick(authority, player)
|
|
# Act
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % BETA_ID)
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(BETA_ID)
|
|
|
|
|
|
func test_tab_from_no_lock_with_nothing_in_range_falls_back_to_first_id() -> void:
|
|
# Arrange
|
|
# No anchors are in range → cycle-order fallback. Server owns the denial reason.
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS,
|
|
200,
|
|
_select_response_json(false, null, "none", 0, "out_of_range")
|
|
)
|
|
var c := _make_client(transport)
|
|
var authority := FreshnessAuthorityStub.new()
|
|
auto_free(authority)
|
|
add_child(authority)
|
|
var player := _make_player(Vector3(20.0, 0.5, 20.0))
|
|
c.set_freshness_kick(authority, player)
|
|
# Act
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % ALPHA_ID)
|
|
assert_that(c.cached_state().get("reasonCode", "")).is_equal("out_of_range")
|
|
|
|
|
|
func test_tab_from_locked_alpha_at_origin_swaps_to_beta_when_both_in_range() -> void:
|
|
# Arrange
|
|
# With alpha (-3,-3) and beta (3,3) sharing r=6, origin is in both rings. Locked to
|
|
# alpha, Tab should request beta (normal cycle behavior; range-aware skip-current
|
|
# does not interfere when the next id is also in range).
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, BETA_ID, "ok", 2)
|
|
)
|
|
var c := _make_client(transport)
|
|
var authority := FreshnessAuthorityStub.new()
|
|
auto_free(authority)
|
|
add_child(authority)
|
|
var player := _make_player(Vector3(0.0, 0.5, 0.0))
|
|
c.set_freshness_kick(authority, player)
|
|
# Act
|
|
c.request_tab_next()
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % BETA_ID)
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(BETA_ID)
|
|
|
|
|
|
func test_tab_when_only_current_lock_is_in_range_falls_back_to_cycle_for_denial() -> void:
|
|
# Arrange
|
|
# Locked to alpha, only alpha is in range — Tab should express a *swap* intent and
|
|
# fall through to the plain cycle so the server denies with `out_of_range` (NEO-23
|
|
# soft-lock rule). If the picker returned alpha instead, the user would see no
|
|
# visible reaction to Tab.
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS,
|
|
200,
|
|
_select_response_json(false, ALPHA_ID, "ok", 1, "out_of_range")
|
|
)
|
|
var c := _make_client(transport)
|
|
var authority := FreshnessAuthorityStub.new()
|
|
auto_free(authority)
|
|
add_child(authority)
|
|
# Near alpha (-3, -3), ~1.4 m in — beta (3, 3) is ~8.5 m out.
|
|
var player := _make_player(Vector3(-2.0, 0.5, -2.0))
|
|
c.set_freshness_kick(authority, player)
|
|
# Act
|
|
c.request_select_target_id(ALPHA_ID)
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % BETA_ID)
|
|
assert_that(c.cached_state().get("reasonCode", "")).is_equal("out_of_range")
|
|
assert_that(c.cached_state().get("lockedTargetId")).is_equal(ALPHA_ID)
|
|
|
|
|
|
func test_tab_without_player_ref_still_uses_plain_cycle_order() -> void:
|
|
# Arrange
|
|
# Regression: headless unit tests and any client that skips `set_freshness_kick(...)`
|
|
# must keep the pre-existing cycle-order semantics. Alpha is requested from no-lock.
|
|
var transport := MockHttpTransport.new()
|
|
transport.enqueue(
|
|
HTTPRequest.RESULT_SUCCESS, 200, _select_response_json(true, ALPHA_ID, "ok", 1)
|
|
)
|
|
var c := _make_client(transport)
|
|
# Act
|
|
c.request_tab_next()
|
|
# Assert
|
|
assert_that(transport.last_body).contains('"targetId":"%s"' % ALPHA_ID)
|