pondsocket-client 0.0.4__tar.gz → 0.0.6__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/PKG-INFO +2 -2
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/pyproject.toml +2 -2
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/__init__.py +6 -1
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/_channel.py +14 -19
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/typed.py +34 -16
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/tests/test_pondsocket_client_channel.py +139 -18
- pondsocket_client-0.0.6/tests/test_pondsocket_client_notfound_adversarial.py +124 -0
- pondsocket_client-0.0.6/tests/test_pondsocket_client_reqresp_adversarial.py +127 -0
- pondsocket_client-0.0.6/tests/test_pondsocket_client_smoke.py +9 -0
- pondsocket_client-0.0.4/tests/test_pondsocket_client_smoke.py +0 -7
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/.gitignore +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/README.md +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/_base.py +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/_websocket.py +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/client.py +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/py.typed +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/src/pondsocket_client/types.py +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/tests/test_pondsocket_client_base.py +0 -0
- {pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/tests/test_pondsocket_client_integration.py +0 -0
|
@@ -1,11 +1,11 @@
|
|
|
1
1
|
Metadata-Version: 2.4
|
|
2
2
|
Name: pondsocket-client
|
|
3
|
-
Version: 0.0.
|
|
3
|
+
Version: 0.0.6
|
|
4
4
|
Summary: PondSocket Python client — connect to a PondSocket server from Python.
|
|
5
5
|
Author: eleven-am
|
|
6
6
|
License: GPL-3.0-or-later
|
|
7
7
|
Requires-Python: >=3.11
|
|
8
|
-
Requires-Dist: pondsocket-common<0.1.0,>=0.0.
|
|
8
|
+
Requires-Dist: pondsocket-common<0.1.0,>=0.0.6
|
|
9
9
|
Requires-Dist: websockets>=13
|
|
10
10
|
Description-Content-Type: text/markdown
|
|
11
11
|
|
|
@@ -1,13 +1,13 @@
|
|
|
1
1
|
[project]
|
|
2
2
|
name = "pondsocket-client"
|
|
3
|
-
version = "0.0.
|
|
3
|
+
version = "0.0.6"
|
|
4
4
|
description = "PondSocket Python client — connect to a PondSocket server from Python."
|
|
5
5
|
readme = "README.md"
|
|
6
6
|
requires-python = ">=3.11"
|
|
7
7
|
license = { text = "GPL-3.0-or-later" }
|
|
8
8
|
authors = [{ name = "eleven-am" }]
|
|
9
9
|
dependencies = [
|
|
10
|
-
"pondsocket-common>=0.0.
|
|
10
|
+
"pondsocket-common>=0.0.6,<0.1.0",
|
|
11
11
|
"websockets>=13",
|
|
12
12
|
]
|
|
13
13
|
|
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
from __future__ import annotations
|
|
2
2
|
|
|
3
|
+
from importlib.metadata import PackageNotFoundError, version
|
|
4
|
+
|
|
3
5
|
from ._base import BaseClient, ConnectionStateHandler, ErrorHandler
|
|
4
6
|
from ._channel import (
|
|
5
7
|
Channel,
|
|
@@ -25,7 +27,10 @@ from .types import (
|
|
|
25
27
|
Publisher,
|
|
26
28
|
)
|
|
27
29
|
|
|
28
|
-
|
|
30
|
+
try:
|
|
31
|
+
__version__ = version("pondsocket-client")
|
|
32
|
+
except PackageNotFoundError:
|
|
33
|
+
__version__ = "0.0.1"
|
|
29
34
|
|
|
30
35
|
__all__ = [
|
|
31
36
|
"DEFAULT_BASE_RECONNECT_DELAY",
|
|
@@ -173,19 +173,20 @@ class Channel:
|
|
|
173
173
|
if self.channel_state == ChannelState.JOINED:
|
|
174
174
|
self._events.publish(event)
|
|
175
175
|
return
|
|
176
|
-
if event.action == ServerActions.SYSTEM:
|
|
177
|
-
if event.event == Events.ACKNOWLEDGE.value:
|
|
178
|
-
self._acknowledge()
|
|
179
|
-
return
|
|
180
|
-
if event.event == Events.UNAUTHORIZED.value:
|
|
181
|
-
self._decline()
|
|
182
|
-
return
|
|
183
176
|
if event.request_id in self._pending_responses:
|
|
184
177
|
fut = self._pending_responses.pop(event.request_id)
|
|
185
178
|
if not fut.done():
|
|
186
179
|
payload = event.payload if isinstance(event.payload, dict) else {}
|
|
187
180
|
fut.set_result(payload)
|
|
188
181
|
return
|
|
182
|
+
if event.action == ServerActions.SYSTEM:
|
|
183
|
+
if event.event == Events.ACKNOWLEDGE.value:
|
|
184
|
+
self._acknowledge()
|
|
185
|
+
return
|
|
186
|
+
if event.event in (Events.UNAUTHORIZED.value, Events.NOT_FOUND.value):
|
|
187
|
+
if self.channel_state in (ChannelState.JOINING, ChannelState.STALLED):
|
|
188
|
+
self._decline()
|
|
189
|
+
return
|
|
189
190
|
if self.channel_state == ChannelState.JOINED:
|
|
190
191
|
self._events.publish(event)
|
|
191
192
|
|
|
@@ -222,9 +223,7 @@ class Channel:
|
|
|
222
223
|
|
|
223
224
|
return self._events.subscribe(filtered)
|
|
224
225
|
|
|
225
|
-
def on_message_event(
|
|
226
|
-
self, event_name: str, callback: MessageHandler
|
|
227
|
-
) -> Unsubscribe:
|
|
226
|
+
def on_message_event(self, event_name: str, callback: MessageHandler) -> Unsubscribe:
|
|
228
227
|
def filtered(ev: ChannelEvent) -> None:
|
|
229
228
|
if isinstance(ev, ServerMessage) and ev.event == event_name:
|
|
230
229
|
callback(ev)
|
|
@@ -251,9 +250,7 @@ class Channel:
|
|
|
251
250
|
|
|
252
251
|
return self._events.subscribe(filtered)
|
|
253
252
|
|
|
254
|
-
def _on_presence_kind(
|
|
255
|
-
self, kind: PresenceEventTypes, callback: PresenceHandler
|
|
256
|
-
) -> Unsubscribe:
|
|
253
|
+
def _on_presence_kind(self, kind: PresenceEventTypes, callback: PresenceHandler) -> Unsubscribe:
|
|
257
254
|
def filtered(ev: ChannelEvent) -> None:
|
|
258
255
|
if isinstance(ev, PresenceMessage) and ev.event == kind:
|
|
259
256
|
callback(dict(ev.payload.changed))
|
|
@@ -277,10 +274,7 @@ class Channel:
|
|
|
277
274
|
self._spawn(self._publish(msg))
|
|
278
275
|
return
|
|
279
276
|
is_join = msg.action == ClientActions.JOIN_CHANNEL
|
|
280
|
-
if
|
|
281
|
-
self._connection_state.value == ConnectionState.CONNECTED
|
|
282
|
-
and is_join
|
|
283
|
-
):
|
|
277
|
+
if self._connection_state.value == ConnectionState.CONNECTED and is_join:
|
|
284
278
|
self._spawn(self._publish(msg))
|
|
285
279
|
return
|
|
286
280
|
self._queue.append(msg)
|
|
@@ -294,8 +288,9 @@ class Channel:
|
|
|
294
288
|
self._spawn(self._publish(msg))
|
|
295
289
|
|
|
296
290
|
def _acknowledge(self) -> None:
|
|
297
|
-
if self.channel_state
|
|
298
|
-
|
|
291
|
+
if self.channel_state not in (ChannelState.JOINING, ChannelState.STALLED):
|
|
292
|
+
return
|
|
293
|
+
self._state.publish(ChannelState.JOINED)
|
|
299
294
|
self._flush_queue()
|
|
300
295
|
|
|
301
296
|
def _decline(self) -> None:
|
|
@@ -1,18 +1,21 @@
|
|
|
1
1
|
from __future__ import annotations
|
|
2
2
|
|
|
3
3
|
from collections.abc import Callable
|
|
4
|
-
from typing import
|
|
4
|
+
from typing import Generic, TypeVar, cast
|
|
5
5
|
|
|
6
6
|
from pondsocket_common import (
|
|
7
|
+
ChannelState,
|
|
7
8
|
PondEvent,
|
|
8
9
|
PondSchema,
|
|
10
|
+
PresencePayloadModel,
|
|
9
11
|
ServerMessage,
|
|
10
12
|
TypedPresencePayload,
|
|
11
13
|
Unsubscribe,
|
|
14
|
+
from_pond_object,
|
|
12
15
|
to_pond_object,
|
|
13
16
|
)
|
|
14
17
|
|
|
15
|
-
from ._channel import Channel, ResponseTimeoutError
|
|
18
|
+
from ._channel import Channel, ChannelStateHandler, MessageHandler, ResponseTimeoutError
|
|
16
19
|
|
|
17
20
|
PayloadT = TypeVar("PayloadT")
|
|
18
21
|
ResponseT = TypeVar("ResponseT")
|
|
@@ -22,10 +25,11 @@ JoinParamsT = TypeVar("JoinParamsT")
|
|
|
22
25
|
|
|
23
26
|
|
|
24
27
|
class TypedChannel(Generic[PresenceT]):
|
|
25
|
-
__slots__ = ("_raw"
|
|
28
|
+
__slots__ = ("_presence_type", "_raw")
|
|
26
29
|
|
|
27
|
-
def __init__(self, raw: Channel) -> None:
|
|
30
|
+
def __init__(self, raw: Channel, presence_type: type[PresenceT] | None = None) -> None:
|
|
28
31
|
self._raw = raw
|
|
32
|
+
self._presence_type = presence_type
|
|
29
33
|
|
|
30
34
|
@property
|
|
31
35
|
def raw(self) -> Channel:
|
|
@@ -35,9 +39,13 @@ class TypedChannel(Generic[PresenceT]):
|
|
|
35
39
|
def name(self) -> str:
|
|
36
40
|
return self._raw.name
|
|
37
41
|
|
|
42
|
+
@property
|
|
43
|
+
def channel_state(self) -> ChannelState:
|
|
44
|
+
return self._raw.channel_state
|
|
45
|
+
|
|
38
46
|
@property
|
|
39
47
|
def presence(self) -> list[PresenceT]:
|
|
40
|
-
return
|
|
48
|
+
return [self._to_presence(p) for p in self._raw.presence]
|
|
41
49
|
|
|
42
50
|
def join(self) -> None:
|
|
43
51
|
self._raw.join()
|
|
@@ -60,7 +68,7 @@ class TypedChannel(Generic[PresenceT]):
|
|
|
60
68
|
to_pond_object(payload),
|
|
61
69
|
wait=wait,
|
|
62
70
|
)
|
|
63
|
-
return cast(ResponseT, response)
|
|
71
|
+
return cast(ResponseT, from_pond_object(response, event.response_type))
|
|
64
72
|
|
|
65
73
|
def on(
|
|
66
74
|
self,
|
|
@@ -68,40 +76,50 @@ class TypedChannel(Generic[PresenceT]):
|
|
|
68
76
|
callback: Callable[[PayloadT], None],
|
|
69
77
|
) -> Unsubscribe:
|
|
70
78
|
def wrapped(message: ServerMessage) -> None:
|
|
71
|
-
callback(cast(PayloadT, message.payload))
|
|
79
|
+
callback(cast(PayloadT, from_pond_object(message.payload, event.payload_type)))
|
|
72
80
|
|
|
73
81
|
return self._raw.on_message_event(event.name, wrapped)
|
|
74
82
|
|
|
83
|
+
def on_message(self, callback: MessageHandler) -> Unsubscribe:
|
|
84
|
+
return self._raw.on_message(callback)
|
|
85
|
+
|
|
86
|
+
def on_channel_state_change(self, callback: ChannelStateHandler) -> Unsubscribe:
|
|
87
|
+
return self._raw.on_channel_state_change(callback)
|
|
88
|
+
|
|
75
89
|
def on_join(self, callback: Callable[[PresenceT], None]) -> Unsubscribe:
|
|
76
|
-
return self._raw.on_join(lambda presence: callback(
|
|
90
|
+
return self._raw.on_join(lambda presence: callback(self._to_presence(presence)))
|
|
77
91
|
|
|
78
92
|
def on_leave(self, callback: Callable[[PresenceT], None]) -> Unsubscribe:
|
|
79
|
-
return self._raw.on_leave(lambda presence: callback(
|
|
93
|
+
return self._raw.on_leave(lambda presence: callback(self._to_presence(presence)))
|
|
80
94
|
|
|
81
95
|
def on_presence_change(
|
|
82
96
|
self,
|
|
83
97
|
callback: Callable[[TypedPresencePayload[PresenceT]], None],
|
|
84
98
|
) -> Unsubscribe:
|
|
85
|
-
def wrapped(payload:
|
|
86
|
-
raw = cast(Any, payload)
|
|
99
|
+
def wrapped(payload: PresencePayloadModel) -> None:
|
|
87
100
|
callback(
|
|
88
101
|
TypedPresencePayload(
|
|
89
|
-
changed=
|
|
90
|
-
presence=
|
|
102
|
+
changed=self._to_presence(payload.changed),
|
|
103
|
+
presence=[self._to_presence(p) for p in payload.presence],
|
|
91
104
|
)
|
|
92
105
|
)
|
|
93
106
|
|
|
94
107
|
return self._raw.on_presence_change(wrapped)
|
|
95
108
|
|
|
96
109
|
def on_users_change(self, callback: Callable[[list[PresenceT]], None]) -> Unsubscribe:
|
|
97
|
-
return self._raw.on_users_change(
|
|
110
|
+
return self._raw.on_users_change(
|
|
111
|
+
lambda users: callback([self._to_presence(u) for u in users])
|
|
112
|
+
)
|
|
113
|
+
|
|
114
|
+
def _to_presence(self, value: object) -> PresenceT:
|
|
115
|
+
return cast(PresenceT, from_pond_object(value, self._presence_type))
|
|
98
116
|
|
|
99
117
|
|
|
100
118
|
def typed_channel(
|
|
101
119
|
raw: Channel,
|
|
102
|
-
|
|
120
|
+
schema: PondSchema[PresenceT, AssignsT, JoinParamsT],
|
|
103
121
|
) -> TypedChannel[PresenceT]:
|
|
104
|
-
return TypedChannel(raw)
|
|
122
|
+
return TypedChannel(raw, schema.presence_type)
|
|
105
123
|
|
|
106
124
|
|
|
107
125
|
__all__ = [
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
from __future__ import annotations
|
|
2
2
|
|
|
3
3
|
import asyncio
|
|
4
|
+
from dataclasses import dataclass
|
|
4
5
|
from typing import TypedDict
|
|
5
6
|
|
|
6
7
|
import pytest
|
|
@@ -103,6 +104,7 @@ async def test_typed_channel_wraps_existing_channel_api() -> None:
|
|
|
103
104
|
typed = typed_channel(channel, schema)
|
|
104
105
|
received: list[TypedChatPayload] = []
|
|
105
106
|
|
|
107
|
+
channel.join()
|
|
106
108
|
channel.handle_event(
|
|
107
109
|
_server_msg(
|
|
108
110
|
"/chat/1",
|
|
@@ -130,6 +132,105 @@ async def test_typed_channel_wraps_existing_channel_api() -> None:
|
|
|
130
132
|
assert typed.presence == [{"user": "alice"}]
|
|
131
133
|
|
|
132
134
|
|
|
135
|
+
@dataclass(frozen=True)
|
|
136
|
+
class ChatDataclass:
|
|
137
|
+
text: str
|
|
138
|
+
|
|
139
|
+
|
|
140
|
+
@dataclass(frozen=True)
|
|
141
|
+
class PresenceDataclass:
|
|
142
|
+
user: str
|
|
143
|
+
|
|
144
|
+
|
|
145
|
+
async def test_typed_channel_encodes_and_decodes_dataclass_payloads() -> None:
|
|
146
|
+
channel, sent, _ = _make_channel()
|
|
147
|
+
schema: PondSchema[PresenceDataclass, TypedAssigns, TypedJoinParams] = pond_schema(
|
|
148
|
+
"chat", PresenceDataclass
|
|
149
|
+
)
|
|
150
|
+
chat: PondEvent[ChatDataclass, ChatDataclass] = pond_event("chat", ChatDataclass, ChatDataclass)
|
|
151
|
+
typed = typed_channel(channel, schema)
|
|
152
|
+
received: list[ChatDataclass] = []
|
|
153
|
+
|
|
154
|
+
channel.join()
|
|
155
|
+
channel.handle_event(
|
|
156
|
+
_server_msg(
|
|
157
|
+
"/chat/1",
|
|
158
|
+
Events.ACKNOWLEDGE.value,
|
|
159
|
+
action=ServerActions.SYSTEM,
|
|
160
|
+
)
|
|
161
|
+
)
|
|
162
|
+
typed.on(chat, received.append)
|
|
163
|
+
typed.send(chat, ChatDataclass(text="hello"))
|
|
164
|
+
await asyncio.sleep(0)
|
|
165
|
+
assert sent[-1].event == "chat"
|
|
166
|
+
assert sent[-1].payload == {"text": "hello"}
|
|
167
|
+
|
|
168
|
+
channel.handle_event(_server_msg("/chat/1", "chat", payload={"text": "from server"}))
|
|
169
|
+
assert received == [ChatDataclass(text="from server")]
|
|
170
|
+
assert isinstance(received[0], ChatDataclass)
|
|
171
|
+
|
|
172
|
+
channel.handle_event(
|
|
173
|
+
_presence_msg(
|
|
174
|
+
"/chat/1",
|
|
175
|
+
PresenceEventTypes.JOIN,
|
|
176
|
+
presence=[{"user": "alice"}],
|
|
177
|
+
changed={"user": "alice"},
|
|
178
|
+
)
|
|
179
|
+
)
|
|
180
|
+
assert typed.presence == [PresenceDataclass(user="alice")]
|
|
181
|
+
assert isinstance(typed.presence[0], PresenceDataclass)
|
|
182
|
+
|
|
183
|
+
|
|
184
|
+
async def test_typed_channel_exposes_state_and_all_message_surface() -> None:
|
|
185
|
+
channel, _, _ = _make_channel()
|
|
186
|
+
schema: PondSchema[TypedPresence, TypedAssigns, TypedJoinParams] = pond_schema("chat")
|
|
187
|
+
typed = typed_channel(channel, schema)
|
|
188
|
+
|
|
189
|
+
states: list[ChannelState] = []
|
|
190
|
+
typed.on_channel_state_change(states.append)
|
|
191
|
+
assert states == [ChannelState.IDLE]
|
|
192
|
+
assert typed.channel_state == ChannelState.IDLE
|
|
193
|
+
|
|
194
|
+
typed.join()
|
|
195
|
+
assert typed.channel_state == ChannelState.JOINING
|
|
196
|
+
assert states[-1] == ChannelState.JOINING
|
|
197
|
+
|
|
198
|
+
channel.handle_event(
|
|
199
|
+
_server_msg("/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM)
|
|
200
|
+
)
|
|
201
|
+
events: list[str] = []
|
|
202
|
+
typed.on_message(lambda m: events.append(m.event))
|
|
203
|
+
channel.handle_event(_server_msg("/chat/1", "chat"))
|
|
204
|
+
channel.handle_event(_server_msg("/chat/1", "ping"))
|
|
205
|
+
assert events == ["chat", "ping"]
|
|
206
|
+
|
|
207
|
+
|
|
208
|
+
async def test_typed_channel_request_decodes_dataclass_response() -> None:
|
|
209
|
+
channel, sent, _ = _make_channel()
|
|
210
|
+
schema: PondSchema[PresenceDataclass, TypedAssigns, TypedJoinParams] = pond_schema(
|
|
211
|
+
"chat", PresenceDataclass
|
|
212
|
+
)
|
|
213
|
+
ping: PondEvent[ChatDataclass, ChatDataclass] = pond_event("ping", ChatDataclass, ChatDataclass)
|
|
214
|
+
typed = typed_channel(channel, schema)
|
|
215
|
+
channel.join()
|
|
216
|
+
channel.handle_event(
|
|
217
|
+
_server_msg("/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM)
|
|
218
|
+
)
|
|
219
|
+
|
|
220
|
+
async def respond() -> None:
|
|
221
|
+
await asyncio.sleep(0.01)
|
|
222
|
+
rid = sent[-1].request_id
|
|
223
|
+
channel.handle_event(
|
|
224
|
+
_server_msg("/chat/1", "pong", request_id=rid, payload={"text": "pong"})
|
|
225
|
+
)
|
|
226
|
+
|
|
227
|
+
task = asyncio.create_task(respond())
|
|
228
|
+
response = await typed.request(ping, ChatDataclass(text="ping"), wait=1.0)
|
|
229
|
+
await task
|
|
230
|
+
assert response == ChatDataclass(text="pong")
|
|
231
|
+
assert isinstance(response, ChatDataclass)
|
|
232
|
+
|
|
233
|
+
|
|
133
234
|
async def test_join_when_connected_transitions_to_joining_and_sends() -> None:
|
|
134
235
|
channel, sent, _ = _make_channel()
|
|
135
236
|
channel.join()
|
|
@@ -182,6 +283,38 @@ async def test_unauthorized_transitions_to_declined() -> None:
|
|
|
182
283
|
assert channel.channel_state == ChannelState.DECLINED
|
|
183
284
|
|
|
184
285
|
|
|
286
|
+
async def test_not_found_transitions_to_declined() -> None:
|
|
287
|
+
channel, _, _ = _make_channel()
|
|
288
|
+
channel.join()
|
|
289
|
+
channel.handle_event(
|
|
290
|
+
_server_msg(
|
|
291
|
+
"/chat/1",
|
|
292
|
+
Events.NOT_FOUND.value,
|
|
293
|
+
action=ServerActions.SYSTEM,
|
|
294
|
+
)
|
|
295
|
+
)
|
|
296
|
+
assert channel.channel_state == ChannelState.DECLINED
|
|
297
|
+
|
|
298
|
+
|
|
299
|
+
async def test_not_found_clears_queue_and_cancels_pending() -> None:
|
|
300
|
+
channel, _, _ = _make_channel(initial_state=ConnectionState.DISCONNECTED)
|
|
301
|
+
channel.join()
|
|
302
|
+
channel.send_message("queued", {"n": 1})
|
|
303
|
+
task = asyncio.create_task(channel.send_for_response("ping", {}, wait=1.0))
|
|
304
|
+
await asyncio.sleep(0)
|
|
305
|
+
channel.handle_event(
|
|
306
|
+
_server_msg(
|
|
307
|
+
"/chat/1",
|
|
308
|
+
Events.NOT_FOUND.value,
|
|
309
|
+
action=ServerActions.SYSTEM,
|
|
310
|
+
)
|
|
311
|
+
)
|
|
312
|
+
assert channel.channel_state == ChannelState.DECLINED
|
|
313
|
+
assert len(channel._queue) == 0 # type: ignore[attr-defined]
|
|
314
|
+
with pytest.raises((asyncio.CancelledError, ResponseTimeoutError)):
|
|
315
|
+
await task
|
|
316
|
+
|
|
317
|
+
|
|
185
318
|
async def test_send_message_before_joined_is_queued() -> None:
|
|
186
319
|
channel, sent, _ = _make_channel()
|
|
187
320
|
channel.join()
|
|
@@ -191,9 +324,7 @@ async def test_send_message_before_joined_is_queued() -> None:
|
|
|
191
324
|
await asyncio.sleep(0)
|
|
192
325
|
assert sent == []
|
|
193
326
|
channel.handle_event(
|
|
194
|
-
_server_msg(
|
|
195
|
-
"/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM
|
|
196
|
-
)
|
|
327
|
+
_server_msg("/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM)
|
|
197
328
|
)
|
|
198
329
|
await asyncio.sleep(0)
|
|
199
330
|
assert len(sent) == 1
|
|
@@ -204,9 +335,7 @@ async def test_on_message_fires_for_broadcasts() -> None:
|
|
|
204
335
|
channel, _, _ = _make_channel()
|
|
205
336
|
channel.join()
|
|
206
337
|
channel.handle_event(
|
|
207
|
-
_server_msg(
|
|
208
|
-
"/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM
|
|
209
|
-
)
|
|
338
|
+
_server_msg("/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM)
|
|
210
339
|
)
|
|
211
340
|
received: list[str] = []
|
|
212
341
|
|
|
@@ -223,9 +352,7 @@ async def test_on_message_event_filters_by_event_name() -> None:
|
|
|
223
352
|
channel, _, _ = _make_channel()
|
|
224
353
|
channel.join()
|
|
225
354
|
channel.handle_event(
|
|
226
|
-
_server_msg(
|
|
227
|
-
"/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM
|
|
228
|
-
)
|
|
355
|
+
_server_msg("/chat/1", Events.ACKNOWLEDGE.value, action=ServerActions.SYSTEM)
|
|
229
356
|
)
|
|
230
357
|
received: list[str] = []
|
|
231
358
|
channel.on_message_event("chat", lambda m: received.append(m.event))
|
|
@@ -284,9 +411,7 @@ async def test_on_users_change_fires_for_every_presence_kind() -> None:
|
|
|
284
411
|
PresenceEventTypes.LEAVE,
|
|
285
412
|
):
|
|
286
413
|
channel.handle_event(
|
|
287
|
-
_presence_msg(
|
|
288
|
-
"/chat/1", kind, presence=[{"id": "alice"}], changed={"id": "alice"}
|
|
289
|
-
)
|
|
414
|
+
_presence_msg("/chat/1", kind, presence=[{"id": "alice"}], changed={"id": "alice"})
|
|
290
415
|
)
|
|
291
416
|
assert len(snapshots) == 3
|
|
292
417
|
|
|
@@ -301,9 +426,7 @@ async def test_send_for_response_correlates_by_request_id() -> None:
|
|
|
301
426
|
async def respond() -> None:
|
|
302
427
|
await asyncio.sleep(0.01)
|
|
303
428
|
rid = sent[-1].request_id
|
|
304
|
-
channel.handle_event(
|
|
305
|
-
_server_msg("/chat/1", "pong", request_id=rid, payload={"echo": "hi"})
|
|
306
|
-
)
|
|
429
|
+
channel.handle_event(_server_msg("/chat/1", "pong", request_id=rid, payload={"echo": "hi"}))
|
|
307
430
|
|
|
308
431
|
task = asyncio.create_task(respond())
|
|
309
432
|
result = await channel.send_for_response("ping", {"text": "hi"}, wait=1.0)
|
|
@@ -369,9 +492,7 @@ async def test_reconnect_after_stalled_resends_join() -> None:
|
|
|
369
492
|
|
|
370
493
|
|
|
371
494
|
async def test_outbound_queue_is_bounded() -> None:
|
|
372
|
-
channel, _sent, _ = _make_channel(
|
|
373
|
-
initial_state=ConnectionState.DISCONNECTED, queue_size=3
|
|
374
|
-
)
|
|
495
|
+
channel, _sent, _ = _make_channel(initial_state=ConnectionState.DISCONNECTED, queue_size=3)
|
|
375
496
|
channel.join()
|
|
376
497
|
for i in range(10):
|
|
377
498
|
channel.send_message(f"e{i}", {"i": i})
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import asyncio
|
|
4
|
+
|
|
5
|
+
import pytest
|
|
6
|
+
from pondsocket_client import Channel, ConnectionState, ResponseTimeoutError
|
|
7
|
+
|
|
8
|
+
from pondsocket_common import (
|
|
9
|
+
BehaviorSubject,
|
|
10
|
+
ChannelState,
|
|
11
|
+
ClientMessage,
|
|
12
|
+
Events,
|
|
13
|
+
ServerActions,
|
|
14
|
+
ServerMessage,
|
|
15
|
+
uuid,
|
|
16
|
+
)
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def _make_channel(
|
|
20
|
+
*,
|
|
21
|
+
initial_state: ConnectionState = ConnectionState.CONNECTED,
|
|
22
|
+
) -> tuple[Channel, list[ClientMessage], BehaviorSubject[ConnectionState]]:
|
|
23
|
+
sent: list[ClientMessage] = []
|
|
24
|
+
state: BehaviorSubject[ConnectionState] = BehaviorSubject(initial_state)
|
|
25
|
+
|
|
26
|
+
async def publisher(msg: ClientMessage) -> None:
|
|
27
|
+
sent.append(msg)
|
|
28
|
+
|
|
29
|
+
channel = Channel(
|
|
30
|
+
name="/chat/1",
|
|
31
|
+
params={"user": "alice"},
|
|
32
|
+
publisher=publisher,
|
|
33
|
+
connection_state=state,
|
|
34
|
+
)
|
|
35
|
+
return channel, sent, state
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def _system(event: str, channel: str = "/chat/1", payload: dict | None = None) -> ServerMessage:
|
|
39
|
+
return ServerMessage(
|
|
40
|
+
action=ServerActions.SYSTEM,
|
|
41
|
+
channelName=channel,
|
|
42
|
+
event=event,
|
|
43
|
+
requestId=uuid(),
|
|
44
|
+
payload=payload if payload is not None else {},
|
|
45
|
+
)
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
async def test_late_not_found_on_joined_channel_is_ignored() -> None:
|
|
49
|
+
nf, _, _ = _make_channel()
|
|
50
|
+
nf.join()
|
|
51
|
+
nf.handle_event(_system(Events.ACKNOWLEDGE.value))
|
|
52
|
+
assert nf.channel_state == ChannelState.JOINED
|
|
53
|
+
nf.handle_event(_system(Events.NOT_FOUND.value))
|
|
54
|
+
assert nf.channel_state == ChannelState.JOINED
|
|
55
|
+
|
|
56
|
+
ua, _, _ = _make_channel()
|
|
57
|
+
ua.join()
|
|
58
|
+
ua.handle_event(_system(Events.ACKNOWLEDGE.value))
|
|
59
|
+
ua.handle_event(_system(Events.UNAUTHORIZED.value))
|
|
60
|
+
assert ua.channel_state == ChannelState.JOINED
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
async def test_ack_then_not_found_is_ignored_and_stays_joined() -> None:
|
|
64
|
+
channel, _, _ = _make_channel()
|
|
65
|
+
channel.join()
|
|
66
|
+
channel.handle_event(_system(Events.ACKNOWLEDGE.value))
|
|
67
|
+
channel.send_message("queued", {"n": 1})
|
|
68
|
+
channel.handle_event(_system(Events.NOT_FOUND.value))
|
|
69
|
+
assert channel.channel_state == ChannelState.JOINED
|
|
70
|
+
assert len(channel._queue) == 0 # type: ignore[attr-defined]
|
|
71
|
+
|
|
72
|
+
|
|
73
|
+
async def test_duplicate_not_found_is_idempotent_no_crash() -> None:
|
|
74
|
+
channel, _, _ = _make_channel()
|
|
75
|
+
channel.join()
|
|
76
|
+
channel.handle_event(_system(Events.NOT_FOUND.value))
|
|
77
|
+
channel.handle_event(_system(Events.NOT_FOUND.value))
|
|
78
|
+
channel.handle_event(_system(Events.NOT_FOUND.value))
|
|
79
|
+
assert channel.channel_state == ChannelState.DECLINED
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
async def test_not_found_with_empty_payload_does_not_crash() -> None:
|
|
83
|
+
channel, _, _ = _make_channel()
|
|
84
|
+
channel.join()
|
|
85
|
+
channel.handle_event(_system(Events.NOT_FOUND.value, payload={}))
|
|
86
|
+
assert channel.channel_state == ChannelState.DECLINED
|
|
87
|
+
|
|
88
|
+
|
|
89
|
+
async def test_not_found_cancels_pending_response() -> None:
|
|
90
|
+
channel, _, _ = _make_channel(initial_state=ConnectionState.DISCONNECTED)
|
|
91
|
+
channel.join()
|
|
92
|
+
task = asyncio.create_task(channel.send_for_response("ping", {}, wait=1.0))
|
|
93
|
+
await asyncio.sleep(0)
|
|
94
|
+
channel.handle_event(_system(Events.NOT_FOUND.value))
|
|
95
|
+
with pytest.raises((asyncio.CancelledError, ResponseTimeoutError)):
|
|
96
|
+
await task
|
|
97
|
+
|
|
98
|
+
|
|
99
|
+
async def test_declined_channel_cannot_rejoin_via_join_guard() -> None:
|
|
100
|
+
channel, sent, _ = _make_channel()
|
|
101
|
+
channel.join()
|
|
102
|
+
await asyncio.sleep(0)
|
|
103
|
+
channel.handle_event(_system(Events.NOT_FOUND.value))
|
|
104
|
+
assert channel.channel_state == ChannelState.DECLINED
|
|
105
|
+
sent.clear()
|
|
106
|
+
channel.join()
|
|
107
|
+
await asyncio.sleep(0)
|
|
108
|
+
assert channel.channel_state == ChannelState.DECLINED
|
|
109
|
+
assert sent == []
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
async def test_declined_then_stray_acknowledge_does_not_resurrect() -> None:
|
|
113
|
+
nf, _, _ = _make_channel()
|
|
114
|
+
nf.join()
|
|
115
|
+
nf.handle_event(_system(Events.NOT_FOUND.value))
|
|
116
|
+
assert nf.channel_state == ChannelState.DECLINED
|
|
117
|
+
nf.handle_event(_system(Events.ACKNOWLEDGE.value))
|
|
118
|
+
assert nf.channel_state == ChannelState.DECLINED
|
|
119
|
+
|
|
120
|
+
ua, _, _ = _make_channel()
|
|
121
|
+
ua.join()
|
|
122
|
+
ua.handle_event(_system(Events.UNAUTHORIZED.value))
|
|
123
|
+
ua.handle_event(_system(Events.ACKNOWLEDGE.value))
|
|
124
|
+
assert ua.channel_state == ChannelState.DECLINED
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import asyncio
|
|
4
|
+
|
|
5
|
+
import pytest
|
|
6
|
+
from pondsocket_client import Channel, ConnectionState, ResponseTimeoutError
|
|
7
|
+
|
|
8
|
+
from pondsocket_common import (
|
|
9
|
+
BehaviorSubject,
|
|
10
|
+
ChannelState,
|
|
11
|
+
ClientMessage,
|
|
12
|
+
Events,
|
|
13
|
+
PresenceEventTypes,
|
|
14
|
+
PresenceMessage,
|
|
15
|
+
ServerActions,
|
|
16
|
+
ServerMessage,
|
|
17
|
+
uuid,
|
|
18
|
+
)
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
def _make_channel() -> tuple[Channel, list[ClientMessage], BehaviorSubject[ConnectionState]]:
|
|
22
|
+
sent: list[ClientMessage] = []
|
|
23
|
+
state: BehaviorSubject[ConnectionState] = BehaviorSubject(ConnectionState.CONNECTED)
|
|
24
|
+
|
|
25
|
+
async def publisher(msg: ClientMessage) -> None:
|
|
26
|
+
sent.append(msg)
|
|
27
|
+
|
|
28
|
+
channel = Channel(name="/chat/1", params={}, publisher=publisher, connection_state=state)
|
|
29
|
+
return channel, sent, state
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
def _system(event: str, request_id: str, payload: dict | None = None) -> ServerMessage:
|
|
33
|
+
return ServerMessage(
|
|
34
|
+
action=ServerActions.SYSTEM,
|
|
35
|
+
channelName="/chat/1",
|
|
36
|
+
event=event,
|
|
37
|
+
requestId=request_id,
|
|
38
|
+
payload=payload if payload is not None else {},
|
|
39
|
+
)
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def _broadcast(event: str, request_id: str, payload: dict | None = None) -> ServerMessage:
|
|
43
|
+
return ServerMessage(
|
|
44
|
+
action=ServerActions.BROADCAST,
|
|
45
|
+
channelName="/chat/1",
|
|
46
|
+
event=event,
|
|
47
|
+
requestId=request_id,
|
|
48
|
+
payload=payload if payload is not None else {},
|
|
49
|
+
)
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
async def _join(channel: Channel) -> None:
|
|
53
|
+
channel.join()
|
|
54
|
+
await asyncio.sleep(0)
|
|
55
|
+
channel.handle_event(_system(Events.ACKNOWLEDGE.value, uuid()))
|
|
56
|
+
assert channel.channel_state == ChannelState.JOINED
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
async def _wait_request_id(sent: list[ClientMessage], event: str) -> str:
|
|
60
|
+
for _ in range(100):
|
|
61
|
+
for msg in reversed(sent):
|
|
62
|
+
if msg.event == event:
|
|
63
|
+
return msg.request_id
|
|
64
|
+
await asyncio.sleep(0.001)
|
|
65
|
+
raise AssertionError(f"no sent message for event {event!r}")
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
@pytest.mark.parametrize("reserved", ["ACKNOWLEDGE", "UNAUTHORIZED", "NOT_FOUND"])
|
|
69
|
+
async def test_reply_with_reserved_event_name_resolves_request(reserved: str) -> None:
|
|
70
|
+
channel, sent, _ = _make_channel()
|
|
71
|
+
await _join(channel)
|
|
72
|
+
task = asyncio.create_task(channel.send_for_response("lookup", {}, wait=0.2))
|
|
73
|
+
await asyncio.sleep(0)
|
|
74
|
+
rid = await _wait_request_id(sent, "lookup")
|
|
75
|
+
channel.handle_event(_system(reserved, rid, payload={"result": "here"}))
|
|
76
|
+
result = await task
|
|
77
|
+
assert result == {"result": "here"}
|
|
78
|
+
|
|
79
|
+
|
|
80
|
+
async def test_reply_with_reserved_name_resolves_and_keeps_channel_joined() -> None:
|
|
81
|
+
channel, sent, _ = _make_channel()
|
|
82
|
+
await _join(channel)
|
|
83
|
+
task = asyncio.create_task(channel.send_for_response("lookup", {}, wait=0.2))
|
|
84
|
+
await asyncio.sleep(0)
|
|
85
|
+
rid = await _wait_request_id(sent, "lookup")
|
|
86
|
+
channel.handle_event(_system("NOT_FOUND", rid, payload={"result": "here"}))
|
|
87
|
+
result = await task
|
|
88
|
+
assert result == {"result": "here"}
|
|
89
|
+
assert channel.channel_state == ChannelState.JOINED
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
async def test_late_response_after_timeout_leaks_into_on_message() -> None:
|
|
93
|
+
channel, sent, _ = _make_channel()
|
|
94
|
+
await _join(channel)
|
|
95
|
+
received: list[tuple[str, dict]] = []
|
|
96
|
+
channel.on_message(lambda m: received.append((m.event, dict(m.payload))))
|
|
97
|
+
with pytest.raises(ResponseTimeoutError):
|
|
98
|
+
await channel.send_for_response("ping", {}, wait=0.05)
|
|
99
|
+
rid = await _wait_request_id(sent, "ping")
|
|
100
|
+
channel.handle_event(_broadcast("ping", rid, payload={"late": True}))
|
|
101
|
+
await asyncio.sleep(0)
|
|
102
|
+
assert received == [("ping", {"late": True})]
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
async def test_presence_before_acknowledge_updates_snapshot_but_drops_callbacks() -> None:
|
|
106
|
+
channel, _, _ = _make_channel()
|
|
107
|
+
channel.join()
|
|
108
|
+
await asyncio.sleep(0)
|
|
109
|
+
joins: list[dict] = []
|
|
110
|
+
users: list[list[dict]] = []
|
|
111
|
+
channel.on_join(joins.append)
|
|
112
|
+
channel.on_users_change(users.append)
|
|
113
|
+
channel.handle_event(
|
|
114
|
+
PresenceMessage(
|
|
115
|
+
action=ServerActions.PRESENCE,
|
|
116
|
+
channelName="/chat/1",
|
|
117
|
+
event=PresenceEventTypes.JOIN,
|
|
118
|
+
requestId=uuid(),
|
|
119
|
+
payload={"presence": [{"id": "x"}], "changed": {"id": "x"}},
|
|
120
|
+
)
|
|
121
|
+
)
|
|
122
|
+
assert channel.presence == [{"id": "x"}]
|
|
123
|
+
assert joins == []
|
|
124
|
+
assert users == []
|
|
125
|
+
channel.handle_event(_system(Events.ACKNOWLEDGE.value, uuid()))
|
|
126
|
+
assert joins == []
|
|
127
|
+
assert users == []
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
{pondsocket_client-0.0.4 → pondsocket_client-0.0.6}/tests/test_pondsocket_client_integration.py
RENAMED
|
File without changes
|