ENet over UDP, used directly through ENetConnection, with a handshake before a connection counts as a player. - NetProtocol: HELLO, WELCOME and REJECT layouts, the protocol version, name cleaning, the reasons a connection ends and a sentence for the player about each. Decoders return nothing for malformed input and never raise an error. - NetServer: listens, takes each guest through the handshake, and reports joined, left and refused. It refuses a different protocol version, a full server, a malformed HELLO and a guest that stays silent, each with its own reason. Handles are never reused; duplicate names get a number. - NetClient: connects, introduces itself, and ends up joined or closed with a reason. Leaving says goodbye so the server knows at once; a client that vanishes is dropped by ENet's timeout. - Tests run a real server and clients over loopback UDP, with bare ENet peers sending malformed and random packets. The headless server doesn't listen yet; N2 connects this to the match. Closes #32 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
297 lines
12 KiB
GDScript
297 lines
12 KiB
GDScript
extends TestCase
|
|
|
|
## Issue N1: a real NetServer and NetClients over loopback UDP. Handshake, refusals,
|
|
## clean leaves, timeouts, and hostile or broken peers.
|
|
|
|
const HOST: String = "127.0.0.1"
|
|
|
|
var server: NetServer
|
|
var clients: Array[NetClient] = []
|
|
## Every server event since the test began.
|
|
var seen: Array[Dictionary] = []
|
|
var raw_hosts: Array[ENetConnection] = []
|
|
|
|
|
|
func before_each() -> void:
|
|
server = NetServer.new()
|
|
server.match_seed = 4242
|
|
clients.clear()
|
|
seen.clear()
|
|
raw_hosts.clear()
|
|
assert_eq(server.listen(0, HOST), OK)
|
|
assert_true(server.port() > 0)
|
|
|
|
|
|
func after_each() -> void:
|
|
for client: NetClient in clients:
|
|
client.leave()
|
|
for host: ENetConnection in raw_hosts:
|
|
host.destroy()
|
|
server.close()
|
|
|
|
|
|
func _client(wanted: String) -> NetClient:
|
|
var client: NetClient = NetClient.new()
|
|
clients.append(client)
|
|
assert_eq(client.connect_to(HOST, server.port(), wanted), OK)
|
|
return client
|
|
|
|
|
|
## Polls everything until `done` is true or `limit_msec` passes. Returns `done`'s answer.
|
|
func _pump(done: Callable, limit_msec: int = 4000) -> bool:
|
|
var started: int = Time.get_ticks_msec()
|
|
while Time.get_ticks_msec() - started < limit_msec:
|
|
server.poll()
|
|
seen.append_array(server.events)
|
|
for client: NetClient in clients:
|
|
client.poll()
|
|
for host: ENetConnection in raw_hosts:
|
|
_service_raw(host)
|
|
if done.call():
|
|
return true
|
|
OS.delay_msec(2)
|
|
return bool(done.call())
|
|
|
|
|
|
func _events(type: String) -> Array[Dictionary]:
|
|
var found: Array[Dictionary] = []
|
|
for event: Dictionary in seen:
|
|
if event["type"] == type:
|
|
found.append(event)
|
|
return found
|
|
|
|
|
|
# A bare ENet peer, for sending what a real client never would.
|
|
|
|
var _raw_state: Dictionary = {}
|
|
|
|
|
|
func _raw() -> ENetPacketPeer:
|
|
var host: ENetConnection = ENetConnection.new()
|
|
assert_eq(host.create_host(1, NetProtocol.CHANNEL_COUNT), OK)
|
|
var peer: ENetPacketPeer = host.connect_to_host(HOST, server.port(), NetProtocol.CHANNEL_COUNT)
|
|
raw_hosts.append(host)
|
|
_raw_state[host] = {"connected": false, "disconnect_data": -1, "packets": []}
|
|
assert_true(_pump(func() -> bool: return _raw_state[host]["connected"]), "the raw peer connected")
|
|
return peer
|
|
|
|
|
|
func _service_raw(host: ENetConnection) -> void:
|
|
while true:
|
|
var event: Array = host.service(0)
|
|
if event[0] == ENetConnection.EVENT_NONE or event[0] == ENetConnection.EVENT_ERROR:
|
|
return
|
|
var state: Dictionary = _raw_state[host]
|
|
if event[0] == ENetConnection.EVENT_CONNECT:
|
|
state["connected"] = true
|
|
elif event[0] == ENetConnection.EVENT_DISCONNECT:
|
|
state["disconnect_data"] = int(event[2])
|
|
elif event[0] == ENetConnection.EVENT_RECEIVE:
|
|
state["packets"].append((event[1] as ENetPacketPeer).get_packet())
|
|
|
|
|
|
func test_a_client_joins() -> void:
|
|
var client: NetClient = _client(" Mara\tof the Reef ")
|
|
assert_eq(client.state, NetClient.CONNECTING)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED), client.status_text())
|
|
assert_eq(client.handle, 1)
|
|
assert_eq(client.player_name, "Mara of the Reef")
|
|
assert_eq(client.match_seed, 4242)
|
|
assert_eq(client.max_players, Tuning.SOLO_PLAYERS)
|
|
assert_eq(client.tick_rate, Tuning.TICK_RATE_HZ)
|
|
assert_eq(client.server_version, NetProtocol.VERSION)
|
|
assert_eq(_events("joined"), [{"type": "joined", "handle": 1, "name": "Mara of the Reef"}] as Array[Dictionary])
|
|
assert_eq(server.player_count(), 1)
|
|
assert_eq(server.guest_count(), 0)
|
|
assert_eq(server.name_of(1), "Mara of the Reef")
|
|
assert_eq(client.status_text(), "Joined as Mara of the Reef.")
|
|
|
|
|
|
func test_a_version_mismatch_is_refused_clearly() -> void:
|
|
var client: NetClient = NetClient.new()
|
|
client.protocol_version = NetProtocol.VERSION + 1
|
|
clients.append(client)
|
|
assert_eq(client.connect_to(HOST, server.port(), "Mara"), OK)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED), client.state_name())
|
|
assert_eq(client.close_reason, NetProtocol.REASON_VERSION)
|
|
assert_eq(client.server_version, NetProtocol.VERSION)
|
|
var text: String = client.status_text()
|
|
assert_true(text.contains("older version") and text.contains("protocol %d" % NetProtocol.VERSION), text)
|
|
assert_eq(server.player_count(), 0)
|
|
assert_eq(_events("refused"), [{"type": "refused", "reason": NetProtocol.REASON_VERSION}] as Array[Dictionary])
|
|
assert_true(_events("joined").is_empty())
|
|
|
|
|
|
func test_a_full_server_says_so() -> void:
|
|
server.max_players = 2
|
|
var first: NetClient = _client("One")
|
|
var second: NetClient = _client("Two")
|
|
assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED and second.state == NetClient.JOINED))
|
|
var third: NetClient = _client("Three")
|
|
assert_true(_pump(func() -> bool: return third.state == NetClient.CLOSED))
|
|
assert_eq(third.close_reason, NetProtocol.REASON_FULL)
|
|
assert_eq(third.status_text(), "The server is full.")
|
|
assert_eq(server.player_count(), 2)
|
|
# A place opens when someone leaves.
|
|
first.leave()
|
|
assert_true(_pump(func() -> bool: return server.player_count() == 1))
|
|
var fourth: NetClient = _client("Four")
|
|
assert_true(_pump(func() -> bool: return fourth.state == NetClient.JOINED))
|
|
assert_eq(fourth.handle, 3, "handles are never reused")
|
|
|
|
|
|
func test_duplicate_names_get_a_number() -> void:
|
|
var first: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return first.state == NetClient.JOINED))
|
|
var second: NetClient = _client("mara")
|
|
var third: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return second.state == NetClient.JOINED and third.state == NetClient.JOINED))
|
|
var names: Array[String] = [first.player_name, second.player_name, third.player_name]
|
|
names.sort()
|
|
assert_eq(names.size(), 3)
|
|
assert_true(names.has("Mara") and (names.has("mara 2") or names.has("Mara 2")), "names %s" % [names])
|
|
assert_ne(second.player_name.to_lower(), third.player_name.to_lower())
|
|
|
|
|
|
func test_a_clean_leave_is_seen_at_once() -> void:
|
|
server.peer_timeout_min_msec = 60000
|
|
server.peer_timeout_max_msec = 60000
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
client.leave()
|
|
assert_eq(client.state, NetClient.CLOSED)
|
|
assert_eq(client.close_reason, NetProtocol.REASON_LEFT)
|
|
assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 2000), "the server heard the goodbye, not a timeout")
|
|
assert_eq(_events("left"), [{"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_LEFT}] as Array[Dictionary])
|
|
assert_eq(server.player_count(), 0)
|
|
|
|
|
|
func test_a_client_that_vanishes_times_out() -> void:
|
|
server.close()
|
|
server.peer_timeout_min_msec = 300
|
|
server.peer_timeout_max_msec = 600
|
|
assert_eq(server.listen(0, HOST), OK)
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
# Pull the plug: no goodbye.
|
|
client._drop()
|
|
clients.clear()
|
|
assert_true(_pump(func() -> bool: return not _events("left").is_empty(), 8000), "the server noticed")
|
|
assert_eq(_events("left")[0]["reason"], NetProtocol.REASON_LOST)
|
|
assert_eq(server.player_count(), 0)
|
|
|
|
|
|
func test_a_silent_guest_is_dropped() -> void:
|
|
server.handshake_timeout_msec = 200
|
|
_raw()
|
|
var host: ENetConnection = raw_hosts[0]
|
|
assert_true(_pump(func() -> bool: return server.guest_count() == 1 or _raw_state[host]["disconnect_data"] >= 0))
|
|
assert_true(_pump(func() -> bool: return _raw_state[host]["disconnect_data"] >= 0), "the guest was disconnected")
|
|
assert_eq(_raw_state[host]["disconnect_data"], NetProtocol.REASON_HANDSHAKE_TIMEOUT)
|
|
assert_eq(NetProtocol.decode_reject(_raw_state[host]["packets"][0])["reason"], NetProtocol.REASON_HANDSHAKE_TIMEOUT)
|
|
assert_eq(server.guest_count(), 0)
|
|
assert_eq(server.player_count(), 0)
|
|
|
|
|
|
func test_malformed_handshakes_are_refused_and_the_server_carries_on() -> void:
|
|
var good: PackedByteArray = NetProtocol.encode_hello("Mara")
|
|
var huge: PackedByteArray = PackedByteArray()
|
|
huge.resize(60000)
|
|
huge.fill(0x41)
|
|
var wrong_magic: PackedByteArray = good.duplicate()
|
|
wrong_magic[1] = 0x00
|
|
var bad_name: PackedByteArray = good.slice(0, 7)
|
|
bad_name.append_array(PackedByteArray([2, 0xC3, 0x28]))
|
|
var packets: Array[PackedByteArray] = [
|
|
PackedByteArray([0]), PackedByteArray([NetProtocol.MSG_HELLO]), good.slice(0, 6), wrong_magic, huge, bad_name,
|
|
NetProtocol.encode_welcome(1, 1, 24, "Mara"), NetProtocol.encode_reject(NetProtocol.REASON_FULL),
|
|
]
|
|
for bytes: PackedByteArray in packets:
|
|
var peer: ENetPacketPeer = _raw()
|
|
peer.send(NetProtocol.CHANNEL_CONTROL, bytes, ENetPacketPeer.FLAG_RELIABLE)
|
|
# A good HELLO on the wrong channel is no handshake either.
|
|
var stray: ENetPacketPeer = _raw()
|
|
stray.send(NetProtocol.CHANNEL_STATE, good, ENetPacketPeer.FLAG_RELIABLE)
|
|
var expected: int = packets.size() + 1
|
|
assert_true(_pump(func() -> bool: return _events("refused").size() >= expected), "refused %d of %d" % [_events("refused").size(), expected])
|
|
for event: Dictionary in _events("refused"):
|
|
assert_eq(event["reason"], NetProtocol.REASON_BAD_HELLO)
|
|
assert_eq(server.bad_packets, expected)
|
|
assert_true(_pump(func() -> bool:
|
|
for host: ENetConnection in raw_hosts:
|
|
if _raw_state[host]["disconnect_data"] < 0:
|
|
return false
|
|
return true), "every bad peer was disconnected")
|
|
assert_eq(server.guest_count(), 0)
|
|
assert_eq(server.player_count(), 0)
|
|
# Still serving.
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
|
|
|
|
func test_random_packets_from_guests_and_players_never_crash_the_server() -> void:
|
|
var rng: RandomNumberGenerator = RandomNumberGenerator.new()
|
|
rng.seed = 77
|
|
var member: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return member.state == NetClient.JOINED))
|
|
for _round: int in 12:
|
|
var peer: ENetPacketPeer = _raw()
|
|
for _packet: int in 6:
|
|
var bytes: PackedByteArray = PackedByteArray()
|
|
bytes.resize(rng.randi_range(0, 300))
|
|
for index: int in bytes.size():
|
|
bytes[index] = rng.randi_range(0, 255)
|
|
peer.send(rng.randi_range(0, 1), bytes, ENetPacketPeer.FLAG_RELIABLE)
|
|
# A player who keeps sending HELLOs and junk stays a player and changes nothing.
|
|
for _packet: int in 20:
|
|
member._peer.send(NetProtocol.CHANNEL_CONTROL, NetProtocol.encode_hello("Someone Else"), ENetPacketPeer.FLAG_RELIABLE)
|
|
member._peer.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1, 2, 3]), ENetPacketPeer.FLAG_RELIABLE)
|
|
assert_true(_pump(func() -> bool: return _events("refused").size() >= 12 and server.bad_packets >= 52), "refused %d, dropped %d" % [_events("refused").size(), server.bad_packets])
|
|
assert_eq(server.player_count(), 1)
|
|
assert_eq(server.name_of(1), "Mara")
|
|
assert_eq(_events("joined").size(), 1)
|
|
assert_eq(member.state, NetClient.JOINED)
|
|
|
|
|
|
func test_no_server_means_no_answer() -> void:
|
|
var port: int = server.port()
|
|
server.close()
|
|
var client: NetClient = NetClient.new()
|
|
client.connect_timeout_msec = 300
|
|
clients.append(client)
|
|
assert_eq(client.connect_to(HOST, port, "Mara"), OK)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED, 3000))
|
|
assert_eq(client.close_reason, NetProtocol.REASON_NO_ANSWER)
|
|
assert_true(client.status_text().contains("No answer"))
|
|
|
|
|
|
func test_a_server_shutting_down_tells_its_players() -> void:
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
server.close()
|
|
assert_false(server.is_listening())
|
|
assert_eq(server.port(), 0)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED))
|
|
assert_eq(client.close_reason, NetProtocol.REASON_SHUTDOWN)
|
|
assert_eq(client.status_text(), "The server shut down.")
|
|
|
|
|
|
func test_a_kicked_player_is_told_and_removed() -> void:
|
|
var client: NetClient = _client("Mara")
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.JOINED))
|
|
assert_true(server.kick(1))
|
|
assert_eq(server.events[-1], {"type": "left", "handle": 1, "name": "Mara", "reason": NetProtocol.REASON_KICKED})
|
|
assert_false(server.kick(1))
|
|
assert_eq(server.player_count(), 0)
|
|
assert_true(_pump(func() -> bool: return client.state == NetClient.CLOSED))
|
|
assert_eq(client.close_reason, NetProtocol.REASON_KICKED)
|
|
assert_false(client.send(NetProtocol.CHANNEL_STATE, PackedByteArray([1]), false))
|
|
|
|
|
|
func test_two_servers_cannot_share_a_port() -> void:
|
|
var other: NetServer = NetServer.new()
|
|
expect_error("Couldn't create an ENet host")
|
|
assert_ne(other.listen(server.port(), HOST), OK)
|
|
assert_false(other.is_listening())
|
|
assert_true(server.is_listening())
|