69 lines
4.3 KiB
GDScript
69 lines
4.3 KiB
GDScript
extends SceneTree
|
|
|
|
var received_invites: Array = []
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
var nakama = root.get_node("Nakama")
|
|
var host := OS.get_environment("VOID_BASTION_TEST_HOST")
|
|
var scheme := OS.get_environment("VOID_BASTION_TEST_SCHEME")
|
|
var port_text := OS.get_environment("VOID_BASTION_TEST_PORT")
|
|
if host.is_empty():
|
|
host = "192.168.178.20"
|
|
if scheme.is_empty():
|
|
scheme = "http"
|
|
var port := int(port_text) if not port_text.is_empty() else 7350
|
|
var client_a: NakamaClient = nakama.create_client("voidbastion-public-v1", host, port, scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
|
|
var client_b: NakamaClient = nakama.create_client("voidbastion-public-v1", host, port, scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
|
|
var suffix := str(Time.get_ticks_usec())
|
|
var session_a: NakamaSession = await client_a.authenticate_device_async("social_test_a_" + suffix, "social_a_" + suffix, true)
|
|
var session_b: NakamaSession = await client_b.authenticate_device_async("social_test_b_" + suffix, "social_b_" + suffix, true)
|
|
assert(not session_a.is_exception() and not session_b.is_exception(), "Beide Testkonten müssen sich anmelden können.")
|
|
var socket_a: NakamaSocket = nakama.create_socket_from(client_a)
|
|
var socket_b: NakamaSocket = nakama.create_socket_from(client_b)
|
|
assert(not (await socket_a.connect_async(session_a, true, 5)).is_exception())
|
|
assert(not (await socket_b.connect_async(session_b, true, 5)).is_exception())
|
|
socket_b.received_notification.connect(func(note):
|
|
if int(note.code) == 101:
|
|
received_invites.append(JSON.parse_string(note.content)))
|
|
var requested = await client_a.add_friends_async(session_a, null, PackedStringArray([session_b.username]))
|
|
assert(not requested.is_exception(), "Eine Freundschaftsanfrage muss gesendet werden können.")
|
|
var accepted = await client_b.add_friends_async(session_b, PackedStringArray([session_a.user_id]))
|
|
assert(not accepted.is_exception(), "Die Anfrage muss angenommen werden können.")
|
|
var friend_list = await client_a.list_friends_async(session_a, 0, 100)
|
|
assert(not friend_list.is_exception() and friend_list.friends.size() == 1 and friend_list.friends[0].user.id == session_b.user_id,
|
|
"Die gegenseitige Freundschaft muss auf dem Server gespeichert sein.")
|
|
var followed = await socket_a.follow_users_async(PackedStringArray([session_b.user_id]), PackedStringArray())
|
|
assert(not followed.is_exception(), "Der Freundesstatus muss abonnierbar sein.")
|
|
assert(not (await socket_b.update_status_async("playing")).is_exception(), "Der Im-Spiel-Status muss gesetzt werden können.")
|
|
var created = await client_a.rpc_async(session_a, "create_private_room", JSON.stringify({"difficulty": 1}))
|
|
assert(not created.is_exception(), "Ein privater Raum muss erstellbar sein.")
|
|
var room: Dictionary = JSON.parse_string(created.payload)
|
|
var code := String(room.get("room_code", ""))
|
|
assert(code.length() == 6)
|
|
var joined = await socket_a.join_match_async(String(room.get("match_id", "")))
|
|
assert(not joined.is_exception(), "Der Gastgeber muss den privaten Raum betreten können.")
|
|
var invited = await client_a.rpc_async(session_a, "invite_friend", JSON.stringify({"friend_id": session_b.user_id, "room_code": code}))
|
|
assert(not invited.is_exception() and bool(JSON.parse_string(invited.payload).get("accepted", false)),
|
|
"Der Gastgeber muss einen bestätigten Freund einladen können.")
|
|
for attempt in 40:
|
|
if not received_invites.is_empty():
|
|
break
|
|
await create_timer(0.05).timeout
|
|
assert(not received_invites.is_empty() and received_invites[0] is Dictionary and String(received_invites[0].get("room_code", "")) == code,
|
|
"Die Echtzeit-Einladung muss den Raumcode enthalten.")
|
|
var unauthorized = await client_b.rpc_async(session_b, "invite_friend", JSON.stringify({"friend_id": session_a.user_id, "room_code": code}))
|
|
assert(not unauthorized.is_exception() and not bool(JSON.parse_string(unauthorized.payload).get("accepted", true)),
|
|
"Ein Mitspieler ohne Gastgeberrolle darf keine Einladung versenden.")
|
|
socket_a.close()
|
|
socket_b.close()
|
|
var deleted_a = await client_a.rpc_async(session_a, "delete_account", "{}")
|
|
var deleted_b = await client_b.rpc_async(session_b, "delete_account", "{}")
|
|
assert(not deleted_a.is_exception() and not deleted_b.is_exception(), "Die Testkonten müssen entfernt werden können.")
|
|
print("VOID_BASTION_SOCIAL_INTEGRATION_OK")
|
|
quit()
|