1###############################################################################
2#
3# The MIT License (MIT)
4#
5# Copyright (c) Crossbar.io Technologies GmbH
6#
7# Permission is hereby granted, free of charge, to any person obtaining a copy
8# of this software and associated documentation files (the "Software"), to deal
9# in the Software without restriction, including without limitation the rights
10# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11# copies of the Software, and to permit persons to whom the Software is
12# furnished to do so, subject to the following conditions:
13#
14# The above copyright notice and this permission notice shall be included in
15# all copies or substantial portions of the Software.
16#
17# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23# THE SOFTWARE.
24#
25###############################################################################
26
27from __future__ import absolute_import
28
29from autobahn.wamp import role
30from autobahn.wamp import message
31from autobahn.wamp.exception import ProtocolError
32
33import unittest
34
35
36class Foo(object):
37    pass
38
39
40class TestIds(unittest.TestCase):
41
42    def test_valid_ids(self):
43        for val in [0, 1, 23, 100000, 9007199254740992]:
44            self.assertEqual(val, message.check_or_raise_id(val))
45
46    def test_invalid_ids(self):
47        for val in [-1, -9007199254740992, None, b"", b"abc", u"", u"abc", 0.9, Foo(), False, True, [], {}]:
48            self.assertRaises(ProtocolError, message.check_or_raise_id, val)
49
50
51class TestUris(unittest.TestCase):
52
53    def test_valid_uris_loose_nonempty(self):
54        for u in [u"com.myapp.topic1",
55                  u"com.myapp.product.123",
56                  u"com.myapp.product.1.delete",
57                  u"Com-star.MyApp.**+$for",
58                  u"\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5",
59                  u"hello\x24world",
60                  u"hello\xC2\xA2world",
61                  u"hello\xE2\x82\xACworld",
62                  u"hello\xF0\xA4\xAD\xA2world",
63                  ]:
64            self.assertEqual(u, message.check_or_raise_uri(u))
65
66    def test_invalid_uris_loose_nonempty(self):
67        for u in [0,
68                  None,
69                  True,
70                  False,
71                  0.8,
72                  b"abc",
73                  Foo(),
74                  u"",
75                  u".",
76                  u"com.",
77                  u"com..product",
78                  u"com.my app.product",
79                  u"com.my\tapp.product",
80                  u"com.my\napp.product",
81                  u"com.myapp.product#",
82                  u"com.#.product",
83                  ]:
84            self.assertRaises(ProtocolError, message.check_or_raise_uri, u)
85
86    def test_valid_uris_loose_empty(self):
87        for u in [u"com.myapp.topic1",
88                  u"com.myapp..123",
89                  u"com.myapp.product.1.",
90                  u"com.",
91                  u".",
92                  u"",
93                  u"Com-star.MyApp.**+$for..foo",
94                  u"\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5..foo",
95                  u"hello\x24world..foo",
96                  u"hello\xC2\xA2world..foo",
97                  u"hello\xE2\x82\xACworld..foo",
98                  u"hello\xF0\xA4\xAD\xA2world..foo",
99                  ]:
100            self.assertEqual(u, message.check_or_raise_uri(u, allow_empty_components=True))
101
102    def test_invalid_uris_loose_empty(self):
103        for u in [0,
104                  None,
105                  True,
106                  False,
107                  0.8,
108                  b"abc",
109                  Foo(),
110                  u"com.my app.product",
111                  u"com.my\tapp.product",
112                  u"com.my\napp.product",
113                  u"com.myapp.product#",
114                  u"com.#.product",
115                  ]:
116            self.assertRaises(ProtocolError, message.check_or_raise_uri, u, allow_empty_components=True)
117
118    def test_valid_uris_strict_nonempty(self):
119        for u in [u"com.myapp.topic1",
120                  u"com.myapp.product.123",
121                  u"com.myapp.product.1.delete",
122                  ]:
123            self.assertEqual(u, message.check_or_raise_uri(u, strict=True))
124
125    def test_invalid_uris_strict_nonempty(self):
126        for u in [0,
127                  None,
128                  True,
129                  False,
130                  0.8,
131                  b"abc",
132                  Foo(),
133                  u"",
134                  u".",
135                  u"com.",
136                  u"com..product",
137                  u"com.my app.product",
138                  u"com.my\tapp.product",
139                  u"com.my\napp.product",
140                  u"com.myapp.product#",
141                  u"com.#.product",
142                  u"Com-star.MyApp.**+$for",
143                  u"\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5",
144                  u"hello\x24world",
145                  u"hello\xC2\xA2world",
146                  u"hello\xE2\x82\xACworld",
147                  u"hello\xF0\xA4\xAD\xA2world",
148                  ]:
149            self.assertRaises(ProtocolError, message.check_or_raise_uri, u, strict=True)
150
151    def test_valid_uris_strict_empty(self):
152        for u in [u"com.myapp.topic1",
153                  u"com.myapp..123",
154                  u"com.myapp.product.1.",
155                  u"com.",
156                  u".",
157                  u"",
158                  ]:
159            self.assertEqual(u, message.check_or_raise_uri(u, strict=True, allow_empty_components=True))
160
161    def test_invalid_uris_strict_empty(self):
162        for u in [0,
163                  None,
164                  True,
165                  False,
166                  0.8,
167                  b"abc",
168                  Foo(),
169                  u"com.my app.product",
170                  u"com.my\tapp.product",
171                  u"com.my\napp.product",
172                  u"com.myapp.product#",
173                  u"com.#.product",
174                  u"Com-star.MyApp.**+$for..foo",
175                  u"\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5..foo",
176                  u"hello\x24world..foo",
177                  u"hello\xC2\xA2world..foo",
178                  u"hello\xE2\x82\xACworld..foo",
179                  u"hello\xF0\xA4\xAD\xA2world..foo",
180                  ]:
181            self.assertRaises(ProtocolError, message.check_or_raise_uri, u, strict=True, allow_empty_components=True)
182
183
184class TestErrorMessage(unittest.TestCase):
185
186    def test_ctor(self):
187        e = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1')
188        msg = e.marshal()
189        self.assertEqual(len(msg), 5)
190        self.assertEqual(msg[0], message.Error.MESSAGE_TYPE)
191        self.assertEqual(msg[1], message.Call.MESSAGE_TYPE)
192        self.assertEqual(msg[2], 123456)
193        self.assertEqual(msg[3], {})
194        self.assertEqual(msg[4], u'com.myapp.error1')
195
196        e = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1', args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
197        msg = e.marshal()
198        self.assertEqual(len(msg), 7)
199        self.assertEqual(msg[0], message.Error.MESSAGE_TYPE)
200        self.assertEqual(msg[1], message.Call.MESSAGE_TYPE)
201        self.assertEqual(msg[2], 123456)
202        self.assertEqual(msg[3], {})
203        self.assertEqual(msg[4], u'com.myapp.error1')
204        self.assertEqual(msg[5], [1, 2, 3])
205        self.assertEqual(msg[6], {u'foo': 23, u'bar': u'hello'})
206
207    def test_parse_and_marshal(self):
208        wmsg = [message.Error.MESSAGE_TYPE, message.Call.MESSAGE_TYPE, 123456, {}, u'com.myapp.error1']
209        msg = message.Error.parse(wmsg)
210        self.assertIsInstance(msg, message.Error)
211        self.assertEqual(msg.request_type, message.Call.MESSAGE_TYPE)
212        self.assertEqual(msg.request, 123456)
213        self.assertEqual(msg.error, u'com.myapp.error1')
214        self.assertEqual(msg.args, None)
215        self.assertEqual(msg.kwargs, None)
216        self.assertEqual(msg.marshal(), wmsg)
217
218        wmsg = [message.Error.MESSAGE_TYPE, message.Call.MESSAGE_TYPE, 123456, {}, u'com.myapp.error1', [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
219        msg = message.Error.parse(wmsg)
220        self.assertIsInstance(msg, message.Error)
221        self.assertEqual(msg.request_type, message.Call.MESSAGE_TYPE)
222        self.assertEqual(msg.request, 123456)
223        self.assertEqual(msg.error, u'com.myapp.error1')
224        self.assertEqual(msg.args, [1, 2, 3])
225        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
226        self.assertEqual(msg.marshal(), wmsg)
227
228
229class TestSubscribeMessage(unittest.TestCase):
230
231    def test_ctor(self):
232        e = message.Subscribe(123456, u'com.myapp.topic1')
233        msg = e.marshal()
234        self.assertEqual(len(msg), 4)
235        self.assertEqual(msg[0], message.Subscribe.MESSAGE_TYPE)
236        self.assertEqual(msg[1], 123456)
237        self.assertEqual(msg[2], {})
238        self.assertEqual(msg[3], u'com.myapp.topic1')
239
240        e = message.Subscribe(123456, u'com.myapp.topic1', match=message.Subscribe.MATCH_PREFIX)
241        msg = e.marshal()
242        self.assertEqual(len(msg), 4)
243        self.assertEqual(msg[0], message.Subscribe.MESSAGE_TYPE)
244        self.assertEqual(msg[1], 123456)
245        self.assertEqual(msg[2], {u'match': u'prefix'})
246        self.assertEqual(msg[3], u'com.myapp.topic1')
247
248    def test_parse_and_marshal(self):
249        wmsg = [message.Subscribe.MESSAGE_TYPE, 123456, {}, u'com.myapp.topic1']
250        msg = message.Subscribe.parse(wmsg)
251        self.assertIsInstance(msg, message.Subscribe)
252        self.assertEqual(msg.request, 123456)
253        self.assertEqual(msg.topic, u'com.myapp.topic1')
254        self.assertEqual(msg.match, message.Subscribe.MATCH_EXACT)
255        self.assertEqual(msg.marshal(), wmsg)
256
257        wmsg = [message.Subscribe.MESSAGE_TYPE, 123456, {u'match': u'prefix'}, u'com.myapp.topic1']
258        msg = message.Subscribe.parse(wmsg)
259        self.assertIsInstance(msg, message.Subscribe)
260        self.assertEqual(msg.request, 123456)
261        self.assertEqual(msg.topic, u'com.myapp.topic1')
262        self.assertEqual(msg.match, message.Subscribe.MATCH_PREFIX)
263        self.assertEqual(msg.marshal(), wmsg)
264
265    def test_get_retained_default_false(self):
266        wmsg = [message.Subscribe.MESSAGE_TYPE, 123456, {u'match': u'prefix'}, u'com.myapp.topic1']
267        msg = message.Subscribe.parse(wmsg)
268        self.assertIsInstance(msg, message.Subscribe)
269        self.assertEqual(msg.request, 123456)
270        self.assertEqual(msg.topic, u'com.myapp.topic1')
271        self.assertEqual(msg.get_retained, None)
272        self.assertNotEqual(msg.get_retained, True)
273        self.assertEqual(msg.match, message.Subscribe.MATCH_PREFIX)
274        self.assertEqual(msg.marshal(), wmsg)
275
276    def test_get_retained_explicit_false(self):
277        wmsg = [message.Subscribe.MESSAGE_TYPE, 123456, {u'match': u'prefix', u'get_retained': False}, u'com.myapp.topic1']
278        msg = message.Subscribe.parse(wmsg)
279        self.assertIsInstance(msg, message.Subscribe)
280        self.assertEqual(msg.request, 123456)
281        self.assertEqual(msg.topic, u'com.myapp.topic1')
282        self.assertEqual(msg.get_retained, False)
283        self.assertNotEqual(msg.get_retained, True)
284        self.assertEqual(msg.match, message.Subscribe.MATCH_PREFIX)
285        self.assertEqual(msg.marshal(), wmsg)
286
287    def test_get_retained_explicit_true(self):
288        wmsg = [message.Subscribe.MESSAGE_TYPE, 123456, {u'match': u'prefix', u'get_retained': True}, u'com.myapp.topic1']
289        msg = message.Subscribe.parse(wmsg)
290        self.assertIsInstance(msg, message.Subscribe)
291        self.assertEqual(msg.request, 123456)
292        self.assertEqual(msg.topic, u'com.myapp.topic1')
293        self.assertEqual(msg.get_retained, True)
294        self.assertEqual(msg.match, message.Subscribe.MATCH_PREFIX)
295        self.assertEqual(msg.marshal(), wmsg)
296
297
298class TestSubscribedMessage(unittest.TestCase):
299
300    def test_ctor(self):
301        e = message.Subscribed(123456, 789123)
302        msg = e.marshal()
303        self.assertEqual(len(msg), 3)
304        self.assertEqual(msg[0], message.Subscribed.MESSAGE_TYPE)
305        self.assertEqual(msg[1], 123456)
306        self.assertEqual(msg[2], 789123)
307
308    def test_parse_and_marshal(self):
309        wmsg = [message.Subscribed.MESSAGE_TYPE, 123456, 789123]
310        msg = message.Subscribed.parse(wmsg)
311        self.assertIsInstance(msg, message.Subscribed)
312        self.assertEqual(msg.request, 123456)
313        self.assertEqual(msg.subscription, 789123)
314        self.assertEqual(msg.marshal(), wmsg)
315
316
317class TestUnsubscribeMessage(unittest.TestCase):
318
319    def test_ctor(self):
320        e = message.Unsubscribe(123456, 789123)
321        msg = e.marshal()
322        self.assertEqual(len(msg), 3)
323        self.assertEqual(msg[0], message.Unsubscribe.MESSAGE_TYPE)
324        self.assertEqual(msg[1], 123456)
325        self.assertEqual(msg[2], 789123)
326
327    def test_parse_and_marshal(self):
328        wmsg = [message.Unsubscribe.MESSAGE_TYPE, 123456, 789123]
329        msg = message.Unsubscribe.parse(wmsg)
330        self.assertIsInstance(msg, message.Unsubscribe)
331        self.assertEqual(msg.request, 123456)
332        self.assertEqual(msg.subscription, 789123)
333        self.assertEqual(msg.marshal(), wmsg)
334
335
336class TestUnsubscribedMessage(unittest.TestCase):
337
338    def test_ctor(self):
339        e = message.Unsubscribed(123456)
340        msg = e.marshal()
341        self.assertEqual(len(msg), 2)
342        self.assertEqual(msg[0], message.Unsubscribed.MESSAGE_TYPE)
343        self.assertEqual(msg[1], 123456)
344
345        e = message.Unsubscribed(0, subscription=123456)
346        msg = e.marshal()
347        self.assertEqual(len(msg), 3)
348        self.assertEqual(msg[0], message.Unsubscribed.MESSAGE_TYPE)
349        self.assertEqual(msg[1], 0)
350        self.assertEqual(msg[2], {u'subscription': 123456})
351
352        e = message.Unsubscribed(0, subscription=123456, reason=u"wamp.subscription.revoked")
353        msg = e.marshal()
354        self.assertEqual(len(msg), 3)
355        self.assertEqual(msg[0], message.Unsubscribed.MESSAGE_TYPE)
356        self.assertEqual(msg[1], 0)
357        self.assertEqual(msg[2], {u'subscription': 123456, u'reason': u"wamp.subscription.revoked"})
358
359    def test_parse_and_marshal(self):
360        wmsg = [message.Unsubscribed.MESSAGE_TYPE, 123456]
361        msg = message.Unsubscribed.parse(wmsg)
362        self.assertIsInstance(msg, message.Unsubscribed)
363        self.assertEqual(msg.request, 123456)
364        self.assertEqual(msg.subscription, None)
365        self.assertEqual(msg.reason, None)
366        self.assertEqual(msg.marshal(), wmsg)
367
368        wmsg = [message.Unsubscribed.MESSAGE_TYPE, 0, {u'subscription': 123456}]
369        msg = message.Unsubscribed.parse(wmsg)
370        self.assertIsInstance(msg, message.Unsubscribed)
371        self.assertEqual(msg.request, 0)
372        self.assertEqual(msg.subscription, 123456)
373        self.assertEqual(msg.reason, None)
374        self.assertEqual(msg.marshal(), wmsg)
375
376        wmsg = [message.Unsubscribed.MESSAGE_TYPE, 0, {u'subscription': 123456, u'reason': u"wamp.subscription.revoked"}]
377        msg = message.Unsubscribed.parse(wmsg)
378        self.assertIsInstance(msg, message.Unsubscribed)
379        self.assertEqual(msg.request, 0)
380        self.assertEqual(msg.subscription, 123456)
381        self.assertEqual(msg.reason, u"wamp.subscription.revoked")
382        self.assertEqual(msg.marshal(), wmsg)
383
384
385class TestPublishMessage(unittest.TestCase):
386
387    def test_ctor(self):
388        e = message.Publish(123456, u'com.myapp.topic1')
389        msg = e.marshal()
390        self.assertEqual(len(msg), 4)
391        self.assertEqual(msg[0], message.Publish.MESSAGE_TYPE)
392        self.assertEqual(msg[1], 123456)
393        self.assertEqual(msg[2], {})
394        self.assertEqual(msg[3], u'com.myapp.topic1')
395
396        e = message.Publish(123456, u'com.myapp.topic1', args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
397        msg = e.marshal()
398        self.assertEqual(len(msg), 6)
399        self.assertEqual(msg[0], message.Publish.MESSAGE_TYPE)
400        self.assertEqual(msg[1], 123456)
401        self.assertEqual(msg[2], {})
402        self.assertEqual(msg[3], u'com.myapp.topic1')
403        self.assertEqual(msg[4], [1, 2, 3])
404        self.assertEqual(msg[5], {u'foo': 23, u'bar': u'hello'})
405
406        e = message.Publish(123456, u'com.myapp.topic1', exclude_me=False, exclude=[300], eligible=[100, 200, 300])
407        msg = e.marshal()
408        self.assertEqual(len(msg), 4)
409        self.assertEqual(msg[0], message.Publish.MESSAGE_TYPE)
410        self.assertEqual(msg[1], 123456)
411        self.assertEqual(msg[2], {u'exclude_me': False, u'exclude': [300], u'eligible': [100, 200, 300]})
412        self.assertEqual(msg[3], u'com.myapp.topic1')
413
414    def test_parse_and_marshal(self):
415        wmsg = [message.Publish.MESSAGE_TYPE, 123456, {}, u'com.myapp.topic1']
416        msg = message.Publish.parse(wmsg)
417        self.assertIsInstance(msg, message.Publish)
418        self.assertEqual(msg.request, 123456)
419        self.assertEqual(msg.topic, u'com.myapp.topic1')
420        self.assertEqual(msg.args, None)
421        self.assertEqual(msg.kwargs, None)
422        self.assertEqual(msg.exclude_me, None)
423        self.assertEqual(msg.exclude, None)
424        self.assertEqual(msg.eligible, None)
425        self.assertEqual(msg.marshal(), wmsg)
426
427        wmsg = [message.Publish.MESSAGE_TYPE, 123456, {}, u'com.myapp.topic1', [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
428        msg = message.Publish.parse(wmsg)
429        self.assertIsInstance(msg, message.Publish)
430        self.assertEqual(msg.request, 123456)
431        self.assertEqual(msg.topic, u'com.myapp.topic1')
432        self.assertEqual(msg.args, [1, 2, 3])
433        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
434        self.assertEqual(msg.exclude_me, None)
435        self.assertEqual(msg.exclude, None)
436        self.assertEqual(msg.eligible, None)
437        self.assertEqual(msg.marshal(), wmsg)
438
439        wmsg = [message.Publish.MESSAGE_TYPE, 123456, {u'exclude_me': False, u'exclude': [300], u'eligible': [100, 200, 300]}, u'com.myapp.topic1']
440        msg = message.Publish.parse(wmsg)
441        self.assertIsInstance(msg, message.Publish)
442        self.assertEqual(msg.request, 123456)
443        self.assertEqual(msg.topic, u'com.myapp.topic1')
444        self.assertEqual(msg.args, None)
445        self.assertEqual(msg.kwargs, None)
446        self.assertEqual(msg.exclude_me, False)
447        self.assertEqual(msg.exclude, [300])
448        self.assertEqual(msg.eligible, [100, 200, 300])
449        self.assertEqual(msg.marshal(), wmsg)
450
451    def test_retain_default_false(self):
452        """
453        Retain, when not specified, is False-y by default.
454        """
455        wmsg = [message.Publish.MESSAGE_TYPE, 123456, {u'exclude_me': False, u'exclude': [300], u'eligible': [100, 200, 300]}, u'com.myapp.topic1']
456        msg = message.Publish.parse(wmsg)
457        self.assertIsInstance(msg, message.Publish)
458        self.assertEqual(msg.retain, None)
459        self.assertIsNot(msg.retain, True)
460        self.assertEqual(msg.marshal(), wmsg)
461
462    def test_retain_explicit_false(self):
463        """
464        Retain, when specified as False, shows up in the message.
465        """
466        wmsg = [message.Publish.MESSAGE_TYPE, 123456, {u'exclude_me': False, u'retain': False, u'exclude': [300], u'eligible': [100, 200, 300]}, u'com.myapp.topic1']
467        msg = message.Publish.parse(wmsg)
468        self.assertIsInstance(msg, message.Publish)
469        self.assertEqual(msg.retain, False)
470        self.assertIsNot(msg.retain, True)
471        self.assertEqual(msg.marshal(), wmsg)
472
473    def test_retain_explicit_true(self):
474        """
475        Retain, when specified as True, shows up in the message.
476        """
477        wmsg = [message.Publish.MESSAGE_TYPE, 123456, {u'exclude_me': False, u'retain': True, u'exclude': [300], u'eligible': [100, 200, 300]}, u'com.myapp.topic1']
478        msg = message.Publish.parse(wmsg)
479        self.assertIsInstance(msg, message.Publish)
480        self.assertEqual(msg.retain, True)
481        self.assertIs(msg.retain, True)
482        self.assertEqual(msg.marshal(), wmsg)
483
484
485class TestPublishedMessage(unittest.TestCase):
486
487    def test_ctor(self):
488        e = message.Published(123456, 789123)
489        msg = e.marshal()
490        self.assertEqual(len(msg), 3)
491        self.assertEqual(msg[0], message.Published.MESSAGE_TYPE)
492        self.assertEqual(msg[1], 123456)
493        self.assertEqual(msg[2], 789123)
494
495    def test_parse_and_marshal(self):
496        wmsg = [message.Published.MESSAGE_TYPE, 123456, 789123]
497        msg = message.Published.parse(wmsg)
498        self.assertIsInstance(msg, message.Published)
499        self.assertEqual(msg.request, 123456)
500        self.assertEqual(msg.publication, 789123)
501        self.assertEqual(msg.marshal(), wmsg)
502
503
504class TestEventMessage(unittest.TestCase):
505
506    def test_ctor(self):
507        e = message.Event(123456, 789123)
508        msg = e.marshal()
509        self.assertEqual(len(msg), 4)
510        self.assertEqual(msg[0], message.Event.MESSAGE_TYPE)
511        self.assertEqual(msg[1], 123456)
512        self.assertEqual(msg[2], 789123)
513        self.assertEqual(msg[3], {})
514
515        e = message.Event(123456, 789123, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
516        msg = e.marshal()
517        self.assertEqual(len(msg), 6)
518        self.assertEqual(msg[0], message.Event.MESSAGE_TYPE)
519        self.assertEqual(msg[1], 123456)
520        self.assertEqual(msg[2], 789123)
521        self.assertEqual(msg[3], {})
522        self.assertEqual(msg[4], [1, 2, 3])
523        self.assertEqual(msg[5], {u'foo': 23, u'bar': u'hello'})
524
525        e = message.Event(123456, 789123, publisher=300)
526        msg = e.marshal()
527        self.assertEqual(len(msg), 4)
528        self.assertEqual(msg[0], message.Event.MESSAGE_TYPE)
529        self.assertEqual(msg[1], 123456)
530        self.assertEqual(msg[2], 789123)
531        self.assertEqual(msg[3], {u'publisher': 300})
532
533    def test_parse_and_marshal(self):
534        wmsg = [message.Event.MESSAGE_TYPE, 123456, 789123, {}]
535        msg = message.Event.parse(wmsg)
536        self.assertIsInstance(msg, message.Event)
537        self.assertEqual(msg.subscription, 123456)
538        self.assertEqual(msg.publication, 789123)
539        self.assertEqual(msg.args, None)
540        self.assertEqual(msg.kwargs, None)
541        self.assertEqual(msg.publisher, None)
542        self.assertEqual(msg.marshal(), wmsg)
543
544        wmsg = [message.Event.MESSAGE_TYPE, 123456, 789123, {}, [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
545        msg = message.Event.parse(wmsg)
546        self.assertIsInstance(msg, message.Event)
547        self.assertEqual(msg.subscription, 123456)
548        self.assertEqual(msg.publication, 789123)
549        self.assertEqual(msg.args, [1, 2, 3])
550        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
551        self.assertEqual(msg.publisher, None)
552        self.assertEqual(msg.marshal(), wmsg)
553
554        wmsg = [message.Event.MESSAGE_TYPE, 123456, 789123, {u'publisher': 300}]
555        msg = message.Event.parse(wmsg)
556        self.assertIsInstance(msg, message.Event)
557        self.assertEqual(msg.subscription, 123456)
558        self.assertEqual(msg.publication, 789123)
559        self.assertEqual(msg.args, None)
560        self.assertEqual(msg.kwargs, None)
561        self.assertEqual(msg.publisher, 300)
562        self.assertEqual(msg.marshal(), wmsg)
563
564    def test_retained_default_false(self):
565        wmsg = [message.Event.MESSAGE_TYPE, 123456, 789123, {}]
566        msg = message.Event.parse(wmsg)
567        self.assertIsInstance(msg, message.Event)
568        self.assertEqual(msg.retained, None)
569        self.assertNotEqual(msg.retained, True)
570        self.assertEqual(msg.marshal(), wmsg)
571
572    def test_retained_explicit_false(self):
573        wmsg = [message.Event.MESSAGE_TYPE, 123456, 789123, {u'retained': False}]
574        msg = message.Event.parse(wmsg)
575        self.assertIsInstance(msg, message.Event)
576        self.assertEqual(msg.retained, False)
577        self.assertNotEqual(msg.retained, True)
578        self.assertEqual(msg.marshal(), wmsg)
579
580    def test_retained_explicit_true(self):
581        wmsg = [message.Event.MESSAGE_TYPE, 123456, 789123, {u'retained': True}]
582        msg = message.Event.parse(wmsg)
583        self.assertIsInstance(msg, message.Event)
584        self.assertEqual(msg.retained, True)
585        self.assertEqual(msg.marshal(), wmsg)
586
587
588class TestRegisterMessage(unittest.TestCase):
589
590    def test_ctor(self):
591        e = message.Register(123456, u'com.myapp.procedure1')
592        msg = e.marshal()
593        self.assertEqual(len(msg), 4)
594        self.assertEqual(msg[0], message.Register.MESSAGE_TYPE)
595        self.assertEqual(msg[1], 123456)
596        self.assertEqual(msg[2], {})
597        self.assertEqual(msg[3], u'com.myapp.procedure1')
598
599        e = message.Register(123456, u'com.myapp.procedure1', match=u'wildcard')
600        msg = e.marshal()
601        self.assertEqual(len(msg), 4)
602        self.assertEqual(msg[0], message.Register.MESSAGE_TYPE)
603        self.assertEqual(msg[1], 123456)
604        self.assertEqual(msg[2], {u'match': u'wildcard'})
605        self.assertEqual(msg[3], u'com.myapp.procedure1')
606
607    def test_ctor_reregister(self):
608        e = message.Register(123456, u'com.myapp.procedure1', force_reregister=True)
609        msg = e.marshal()
610        self.assertEqual(len(msg), 4)
611        self.assertEqual(msg[0], message.Register.MESSAGE_TYPE)
612        self.assertEqual(msg[1], 123456)
613        self.assertEqual(msg[2], {u'force_reregister': True})
614        self.assertEqual(msg[3], u'com.myapp.procedure1')
615
616        e2 = message.Register.parse(msg)
617        str(e2)
618
619    def test_parse_reregister_illegal_force(self):
620        msg = [
621            message.Register.MESSAGE_TYPE,
622            123456,
623            {u'force_reregister': 'truthy'},
624            u'com.myapp.procedure1',
625        ]
626
627        with self.assertRaises(ProtocolError) as ctx:
628            message.Register.parse(msg)
629        self.assertIn("invalid type", str(ctx.exception))
630
631    def test_parse_and_marshal(self):
632        wmsg = [message.Register.MESSAGE_TYPE, 123456, {}, u'com.myapp.procedure1']
633        msg = message.Register.parse(wmsg)
634        self.assertIsInstance(msg, message.Register)
635        self.assertEqual(msg.request, 123456)
636        self.assertEqual(msg.procedure, u'com.myapp.procedure1')
637        self.assertEqual(msg.match, u'exact')
638        self.assertEqual(msg.marshal(), wmsg)
639
640        wmsg = [message.Register.MESSAGE_TYPE, 123456, {u'match': u'wildcard'}, u'com.myapp.procedure1']
641        msg = message.Register.parse(wmsg)
642        self.assertIsInstance(msg, message.Register)
643        self.assertEqual(msg.request, 123456)
644        self.assertEqual(msg.procedure, u'com.myapp.procedure1')
645        self.assertEqual(msg.match, u'wildcard')
646        self.assertEqual(msg.marshal(), wmsg)
647
648
649class TestRegisteredMessage(unittest.TestCase):
650
651    def test_ctor(self):
652        e = message.Registered(123456, 789123)
653        msg = e.marshal()
654        self.assertEqual(len(msg), 3)
655        self.assertEqual(msg[0], message.Registered.MESSAGE_TYPE)
656        self.assertEqual(msg[1], 123456)
657        self.assertEqual(msg[2], 789123)
658
659    def test_parse_and_marshal(self):
660        wmsg = [message.Registered.MESSAGE_TYPE, 123456, 789123]
661        msg = message.Registered.parse(wmsg)
662        self.assertIsInstance(msg, message.Registered)
663        self.assertEqual(msg.request, 123456)
664        self.assertEqual(msg.registration, 789123)
665        self.assertEqual(msg.marshal(), wmsg)
666
667
668class TestUnregisterMessage(unittest.TestCase):
669
670    def test_ctor(self):
671        e = message.Unregister(123456, 789123)
672        msg = e.marshal()
673        self.assertEqual(len(msg), 3)
674        self.assertEqual(msg[0], message.Unregister.MESSAGE_TYPE)
675        self.assertEqual(msg[1], 123456)
676        self.assertEqual(msg[2], 789123)
677
678    def test_parse_and_marshal(self):
679        wmsg = [message.Unregister.MESSAGE_TYPE, 123456, 789123]
680        msg = message.Unregister.parse(wmsg)
681        self.assertIsInstance(msg, message.Unregister)
682        self.assertEqual(msg.request, 123456)
683        self.assertEqual(msg.registration, 789123)
684        self.assertEqual(msg.marshal(), wmsg)
685
686
687class TestUnregisteredMessage(unittest.TestCase):
688
689    def test_ctor(self):
690        e = message.Unregistered(123456)
691        msg = e.marshal()
692        self.assertEqual(len(msg), 2)
693        self.assertEqual(msg[0], message.Unregistered.MESSAGE_TYPE)
694        self.assertEqual(msg[1], 123456)
695
696        e = message.Unregistered(0, registration=123456)
697        msg = e.marshal()
698        self.assertEqual(len(msg), 3)
699        self.assertEqual(msg[0], message.Unregistered.MESSAGE_TYPE)
700        self.assertEqual(msg[1], 0)
701        self.assertEqual(msg[2], {u'registration': 123456})
702
703        e = message.Unregistered(0, registration=123456, reason=u"wamp.registration.revoked")
704        msg = e.marshal()
705        self.assertEqual(len(msg), 3)
706        self.assertEqual(msg[0], message.Unregistered.MESSAGE_TYPE)
707        self.assertEqual(msg[1], 0)
708        self.assertEqual(msg[2], {u'registration': 123456, u'reason': u"wamp.registration.revoked"})
709
710    def test_parse_and_marshal(self):
711        wmsg = [message.Unregistered.MESSAGE_TYPE, 123456]
712        msg = message.Unregistered.parse(wmsg)
713        self.assertIsInstance(msg, message.Unregistered)
714        self.assertEqual(msg.request, 123456)
715        self.assertEqual(msg.registration, None)
716        self.assertEqual(msg.reason, None)
717        self.assertEqual(msg.marshal(), wmsg)
718
719        wmsg = [message.Unregistered.MESSAGE_TYPE, 0, {u'registration': 123456}]
720        msg = message.Unregistered.parse(wmsg)
721        self.assertIsInstance(msg, message.Unregistered)
722        self.assertEqual(msg.request, 0)
723        self.assertEqual(msg.registration, 123456)
724        self.assertEqual(msg.reason, None)
725        self.assertEqual(msg.marshal(), wmsg)
726
727        wmsg = [message.Unregistered.MESSAGE_TYPE, 0, {u'registration': 123456, u'reason': u"wamp.registration.revoked"}]
728        msg = message.Unregistered.parse(wmsg)
729        self.assertIsInstance(msg, message.Unregistered)
730        self.assertEqual(msg.request, 0)
731        self.assertEqual(msg.registration, 123456)
732        self.assertEqual(msg.reason, u"wamp.registration.revoked")
733        self.assertEqual(msg.marshal(), wmsg)
734
735
736class TestCallMessage(unittest.TestCase):
737
738    def test_ctor(self):
739        e = message.Call(123456, u'com.myapp.procedure1')
740        msg = e.marshal()
741        self.assertEqual(len(msg), 4)
742        self.assertEqual(msg[0], message.Call.MESSAGE_TYPE)
743        self.assertEqual(msg[1], 123456)
744        self.assertEqual(msg[2], {})
745        self.assertEqual(msg[3], u'com.myapp.procedure1')
746
747        e = message.Call(123456, u'com.myapp.procedure1', args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
748        msg = e.marshal()
749        self.assertEqual(len(msg), 6)
750        self.assertEqual(msg[0], message.Call.MESSAGE_TYPE)
751        self.assertEqual(msg[1], 123456)
752        self.assertEqual(msg[2], {})
753        self.assertEqual(msg[3], u'com.myapp.procedure1')
754        self.assertEqual(msg[4], [1, 2, 3])
755        self.assertEqual(msg[5], {u'foo': 23, u'bar': u'hello'})
756
757        e = message.Call(123456, u'com.myapp.procedure1', timeout=10000)
758        msg = e.marshal()
759        self.assertEqual(len(msg), 4)
760        self.assertEqual(msg[0], message.Call.MESSAGE_TYPE)
761        self.assertEqual(msg[1], 123456)
762        self.assertEqual(msg[2], {u'timeout': 10000})
763        self.assertEqual(msg[3], u'com.myapp.procedure1')
764
765    def test_parse_and_marshal(self):
766        wmsg = [message.Call.MESSAGE_TYPE, 123456, {}, u'com.myapp.procedure1']
767        msg = message.Call.parse(wmsg)
768        self.assertIsInstance(msg, message.Call)
769        self.assertEqual(msg.request, 123456)
770        self.assertEqual(msg.procedure, u'com.myapp.procedure1')
771        self.assertEqual(msg.args, None)
772        self.assertEqual(msg.kwargs, None)
773        self.assertEqual(msg.timeout, None)
774        self.assertEqual(msg.marshal(), wmsg)
775
776        wmsg = [message.Call.MESSAGE_TYPE, 123456, {}, u'com.myapp.procedure1', [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
777        msg = message.Call.parse(wmsg)
778        self.assertIsInstance(msg, message.Call)
779        self.assertEqual(msg.request, 123456)
780        self.assertEqual(msg.procedure, u'com.myapp.procedure1')
781        self.assertEqual(msg.args, [1, 2, 3])
782        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
783        self.assertEqual(msg.timeout, None)
784        self.assertEqual(msg.marshal(), wmsg)
785
786        wmsg = [message.Call.MESSAGE_TYPE, 123456, {u'timeout': 10000}, u'com.myapp.procedure1']
787        msg = message.Call.parse(wmsg)
788        self.assertIsInstance(msg, message.Call)
789        self.assertEqual(msg.request, 123456)
790        self.assertEqual(msg.procedure, u'com.myapp.procedure1')
791        self.assertEqual(msg.args, None)
792        self.assertEqual(msg.kwargs, None)
793        self.assertEqual(msg.timeout, 10000)
794        self.assertEqual(msg.marshal(), wmsg)
795
796
797class TestCancelMessage(unittest.TestCase):
798
799    def test_ctor(self):
800        e = message.Cancel(123456)
801        msg = e.marshal()
802        self.assertEqual(len(msg), 3)
803        self.assertEqual(msg[0], message.Cancel.MESSAGE_TYPE)
804        self.assertEqual(msg[1], 123456)
805        self.assertEqual(msg[2], {})
806
807        e = message.Cancel(123456, mode=message.Cancel.KILL)
808        msg = e.marshal()
809        self.assertEqual(len(msg), 3)
810        self.assertEqual(msg[0], message.Cancel.MESSAGE_TYPE)
811        self.assertEqual(msg[1], 123456)
812        self.assertEqual(msg[2], {u'mode': message.Cancel.KILL})
813
814    def test_parse_and_marshal(self):
815        wmsg = [message.Cancel.MESSAGE_TYPE, 123456, {}]
816        msg = message.Cancel.parse(wmsg)
817        self.assertIsInstance(msg, message.Cancel)
818        self.assertEqual(msg.request, 123456)
819        self.assertEqual(msg.mode, None)
820        self.assertEqual(msg.marshal(), wmsg)
821
822        wmsg = [message.Cancel.MESSAGE_TYPE, 123456, {u'mode': message.Cancel.KILL}]
823        msg = message.Cancel.parse(wmsg)
824        self.assertIsInstance(msg, message.Cancel)
825        self.assertEqual(msg.request, 123456)
826        self.assertEqual(msg.mode, message.Cancel.KILL)
827        self.assertEqual(msg.marshal(), wmsg)
828
829
830class TestResultMessage(unittest.TestCase):
831
832    def test_ctor(self):
833        e = message.Result(123456)
834        msg = e.marshal()
835        self.assertEqual(len(msg), 3)
836        self.assertEqual(msg[0], message.Result.MESSAGE_TYPE)
837        self.assertEqual(msg[1], 123456)
838        self.assertEqual(msg[2], {})
839
840        e = message.Result(123456, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
841        msg = e.marshal()
842        self.assertEqual(len(msg), 5)
843        self.assertEqual(msg[0], message.Result.MESSAGE_TYPE)
844        self.assertEqual(msg[1], 123456)
845        self.assertEqual(msg[2], {})
846        self.assertEqual(msg[3], [1, 2, 3])
847        self.assertEqual(msg[4], {u'foo': 23, u'bar': u'hello'})
848
849        e = message.Result(123456, progress=True)
850        msg = e.marshal()
851        self.assertEqual(len(msg), 3)
852        self.assertEqual(msg[0], message.Result.MESSAGE_TYPE)
853        self.assertEqual(msg[1], 123456)
854        self.assertEqual(msg[2], {u'progress': True})
855
856    def test_parse_and_marshal(self):
857        wmsg = [message.Result.MESSAGE_TYPE, 123456, {}]
858        msg = message.Result.parse(wmsg)
859        self.assertIsInstance(msg, message.Result)
860        self.assertEqual(msg.request, 123456)
861        self.assertEqual(msg.args, None)
862        self.assertEqual(msg.kwargs, None)
863        self.assertEqual(msg.progress, None)
864        self.assertEqual(msg.marshal(), wmsg)
865
866        wmsg = [message.Result.MESSAGE_TYPE, 123456, {}, [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
867        msg = message.Result.parse(wmsg)
868        self.assertIsInstance(msg, message.Result)
869        self.assertEqual(msg.request, 123456)
870        self.assertEqual(msg.args, [1, 2, 3])
871        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
872        self.assertEqual(msg.progress, None)
873        self.assertEqual(msg.marshal(), wmsg)
874
875        wmsg = [message.Result.MESSAGE_TYPE, 123456, {u'progress': True}]
876        msg = message.Result.parse(wmsg)
877        self.assertIsInstance(msg, message.Result)
878        self.assertEqual(msg.request, 123456)
879        self.assertEqual(msg.args, None)
880        self.assertEqual(msg.kwargs, None)
881        self.assertEqual(msg.progress, True)
882        self.assertEqual(msg.marshal(), wmsg)
883
884
885class TestInvocationMessage(unittest.TestCase):
886
887    def test_ctor(self):
888        e = message.Invocation(123456, 789123)
889        msg = e.marshal()
890        self.assertEqual(len(msg), 4)
891        self.assertEqual(msg[0], message.Invocation.MESSAGE_TYPE)
892        self.assertEqual(msg[1], 123456)
893        self.assertEqual(msg[2], 789123)
894        self.assertEqual(msg[3], {})
895
896        e = message.Invocation(123456, 789123, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
897        msg = e.marshal()
898        self.assertEqual(len(msg), 6)
899        self.assertEqual(msg[0], message.Invocation.MESSAGE_TYPE)
900        self.assertEqual(msg[1], 123456)
901        self.assertEqual(msg[2], 789123)
902        self.assertEqual(msg[3], {})
903        self.assertEqual(msg[4], [1, 2, 3])
904        self.assertEqual(msg[5], {u'foo': 23, u'bar': u'hello'})
905
906        e = message.Invocation(123456, 789123, timeout=10000)
907        msg = e.marshal()
908        self.assertEqual(len(msg), 4)
909        self.assertEqual(msg[0], message.Invocation.MESSAGE_TYPE)
910        self.assertEqual(msg[1], 123456)
911        self.assertEqual(msg[2], 789123)
912        self.assertEqual(msg[3], {u'timeout': 10000})
913
914    def test_parse_and_marshal(self):
915        wmsg = [message.Invocation.MESSAGE_TYPE, 123456, 789123, {}]
916        msg = message.Invocation.parse(wmsg)
917        self.assertIsInstance(msg, message.Invocation)
918        self.assertEqual(msg.request, 123456)
919        self.assertEqual(msg.registration, 789123)
920        self.assertEqual(msg.args, None)
921        self.assertEqual(msg.kwargs, None)
922        self.assertEqual(msg.timeout, None)
923        self.assertEqual(msg.marshal(), wmsg)
924
925        wmsg = [message.Invocation.MESSAGE_TYPE, 123456, 789123, {}, [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
926        msg = message.Invocation.parse(wmsg)
927        self.assertIsInstance(msg, message.Invocation)
928        self.assertEqual(msg.request, 123456)
929        self.assertEqual(msg.registration, 789123)
930        self.assertEqual(msg.args, [1, 2, 3])
931        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
932        self.assertEqual(msg.timeout, None)
933        self.assertEqual(msg.marshal(), wmsg)
934
935        wmsg = [message.Invocation.MESSAGE_TYPE, 123456, 789123, {u'timeout': 10000}]
936        msg = message.Invocation.parse(wmsg)
937        self.assertIsInstance(msg, message.Invocation)
938        self.assertEqual(msg.request, 123456)
939        self.assertEqual(msg.registration, 789123)
940        self.assertEqual(msg.args, None)
941        self.assertEqual(msg.kwargs, None)
942        self.assertEqual(msg.timeout, 10000)
943        self.assertEqual(msg.marshal(), wmsg)
944
945
946class TestInterruptMessage(unittest.TestCase):
947
948    def test_ctor(self):
949        e = message.Interrupt(123456)
950        msg = e.marshal()
951        self.assertEqual(len(msg), 3)
952        self.assertEqual(msg[0], message.Interrupt.MESSAGE_TYPE)
953        self.assertEqual(msg[1], 123456)
954        self.assertEqual(msg[2], {})
955
956        e = message.Interrupt(123456, mode=message.Interrupt.KILL)
957        msg = e.marshal()
958        self.assertEqual(len(msg), 3)
959        self.assertEqual(msg[0], message.Interrupt.MESSAGE_TYPE)
960        self.assertEqual(msg[1], 123456)
961        self.assertEqual(msg[2], {u'mode': message.Interrupt.KILL})
962
963    def test_parse_and_marshal(self):
964        wmsg = [message.Interrupt.MESSAGE_TYPE, 123456, {}]
965        msg = message.Interrupt.parse(wmsg)
966        self.assertIsInstance(msg, message.Interrupt)
967        self.assertEqual(msg.request, 123456)
968        self.assertEqual(msg.mode, None)
969        self.assertEqual(msg.marshal(), wmsg)
970
971        wmsg = [message.Interrupt.MESSAGE_TYPE, 123456, {u'mode': message.Interrupt.KILL}]
972        msg = message.Interrupt.parse(wmsg)
973        self.assertIsInstance(msg, message.Interrupt)
974        self.assertEqual(msg.request, 123456)
975        self.assertEqual(msg.mode, message.Interrupt.KILL)
976        self.assertEqual(msg.marshal(), wmsg)
977
978
979class TestYieldMessage(unittest.TestCase):
980
981    def test_ctor(self):
982        e = message.Yield(123456)
983        msg = e.marshal()
984        self.assertEqual(len(msg), 3)
985        self.assertEqual(msg[0], message.Yield.MESSAGE_TYPE)
986        self.assertEqual(msg[1], 123456)
987        self.assertEqual(msg[2], {})
988
989        e = message.Yield(123456, args=[1, 2, 3], kwargs={u'foo': 23, u'bar': u'hello'})
990        msg = e.marshal()
991        self.assertEqual(len(msg), 5)
992        self.assertEqual(msg[0], message.Yield.MESSAGE_TYPE)
993        self.assertEqual(msg[1], 123456)
994        self.assertEqual(msg[2], {})
995        self.assertEqual(msg[3], [1, 2, 3])
996        self.assertEqual(msg[4], {u'foo': 23, u'bar': u'hello'})
997
998        e = message.Yield(123456, progress=True)
999        msg = e.marshal()
1000        self.assertEqual(len(msg), 3)
1001        self.assertEqual(msg[0], message.Yield.MESSAGE_TYPE)
1002        self.assertEqual(msg[1], 123456)
1003        self.assertEqual(msg[2], {u'progress': True})
1004
1005    def test_parse_and_marshal(self):
1006        wmsg = [message.Yield.MESSAGE_TYPE, 123456, {}]
1007        msg = message.Yield.parse(wmsg)
1008        self.assertIsInstance(msg, message.Yield)
1009        self.assertEqual(msg.request, 123456)
1010        self.assertEqual(msg.args, None)
1011        self.assertEqual(msg.kwargs, None)
1012        self.assertEqual(msg.progress, None)
1013        self.assertEqual(msg.marshal(), wmsg)
1014
1015        wmsg = [message.Yield.MESSAGE_TYPE, 123456, {}, [1, 2, 3], {u'foo': 23, u'bar': u'hello'}]
1016        msg = message.Yield.parse(wmsg)
1017        self.assertIsInstance(msg, message.Yield)
1018        self.assertEqual(msg.request, 123456)
1019        self.assertEqual(msg.args, [1, 2, 3])
1020        self.assertEqual(msg.kwargs, {u'foo': 23, u'bar': u'hello'})
1021        self.assertEqual(msg.progress, None)
1022        self.assertEqual(msg.marshal(), wmsg)
1023
1024        wmsg = [message.Yield.MESSAGE_TYPE, 123456, {u'progress': True}]
1025        msg = message.Yield.parse(wmsg)
1026        self.assertIsInstance(msg, message.Yield)
1027        self.assertEqual(msg.request, 123456)
1028        self.assertEqual(msg.args, None)
1029        self.assertEqual(msg.kwargs, None)
1030        self.assertEqual(msg.progress, True)
1031        self.assertEqual(msg.marshal(), wmsg)
1032
1033
1034class TestHelloMessage(unittest.TestCase):
1035
1036    def test_ctor(self):
1037        e = message.Hello(u"realm1", {u'publisher': role.RolePublisherFeatures()})
1038        msg = e.marshal()
1039        self.assertEqual(len(msg), 3)
1040        self.assertEqual(msg[0], message.Hello.MESSAGE_TYPE)
1041        self.assertEqual(msg[1], u"realm1")
1042        self.assertEqual(msg[2], {u'roles': {u'publisher': {}}})
1043
1044        e = message.Hello(u"realm1", {u'publisher': role.RolePublisherFeatures(subscriber_blackwhite_listing=True)})
1045        msg = e.marshal()
1046        self.assertEqual(len(msg), 3)
1047        self.assertEqual(msg[0], message.Hello.MESSAGE_TYPE)
1048        self.assertEqual(msg[1], u"realm1")
1049        self.assertEqual(msg[2], {u'roles': {u'publisher': {u'features': {u'subscriber_blackwhite_listing': True}}}})
1050
1051        e = message.Hello(u"realm1", {u'publisher': role.RolePublisherFeatures(subscriber_blackwhite_listing=True)}, resumable=True)
1052        msg = e.marshal()
1053        self.assertEqual(len(msg), 3)
1054        self.assertEqual(msg[0], message.Hello.MESSAGE_TYPE)
1055        self.assertEqual(msg[1], u"realm1")
1056        self.assertEqual(msg[2], {u'roles': {u'publisher': {u'features': {u'subscriber_blackwhite_listing': True}}}, u'resumable': True})
1057
1058    def test_parse_and_marshal(self):
1059        wmsg = [message.Hello.MESSAGE_TYPE, u"realm1", {u'roles': {u'publisher': {}}}]
1060        msg = message.Hello.parse(wmsg)
1061        self.assertIsInstance(msg, message.Hello)
1062        self.assertEqual(msg.realm, u"realm1")
1063        self.assertEqual(msg.roles, {u'publisher': role.RolePublisherFeatures()})
1064        self.assertEqual(msg.resumable, None)
1065        self.assertEqual(msg.marshal(), wmsg)
1066
1067        wmsg = [message.Hello.MESSAGE_TYPE, u"realm1", {u'roles': {u'publisher': {u'features': {u'subscriber_blackwhite_listing': True}}}}]
1068        msg = message.Hello.parse(wmsg)
1069        self.assertIsInstance(msg, message.Hello)
1070        self.assertEqual(msg.realm, u"realm1")
1071        self.assertEqual(msg.roles, {u'publisher': role.RolePublisherFeatures(subscriber_blackwhite_listing=True)})
1072        self.assertEqual(msg.marshal(), wmsg)
1073
1074        wmsg = [message.Hello.MESSAGE_TYPE, u"realm1", {u'roles': {u'publisher': {}}, u'resumable': False}]
1075        msg = message.Hello.parse(wmsg)
1076        self.assertIsInstance(msg, message.Hello)
1077        self.assertEqual(msg.realm, u"realm1")
1078        self.assertEqual(msg.roles, {u'publisher': role.RolePublisherFeatures()})
1079        self.assertEqual(msg.resumable, False)
1080        self.assertEqual(msg.marshal(), wmsg)
1081
1082        wmsg = [message.Hello.MESSAGE_TYPE, u"realm1", {u'roles': {u'publisher': {}}, u'resumable': True, u'resume-session': 1234, u'resume-token': u"dsjgsg"}]
1083        msg = message.Hello.parse(wmsg)
1084        self.assertIsInstance(msg, message.Hello)
1085        self.assertEqual(msg.realm, u"realm1")
1086        self.assertEqual(msg.roles, {u'publisher': role.RolePublisherFeatures()})
1087        self.assertEqual(msg.resumable, True)
1088        self.assertEqual(msg.resume_session, 1234)
1089        self.assertEqual(msg.resume_token, u"dsjgsg")
1090        self.assertEqual(msg.marshal(), wmsg)
1091
1092    def test_str(self):
1093        e = message.Hello(u"realm1", {u'publisher': role.RolePublisherFeatures()})
1094        self.assertIsInstance(str(e), str)
1095
1096
1097class TestGoodbyeMessage(unittest.TestCase):
1098
1099    def test_ctor(self):
1100        reason = u'wamp.error.system_shutdown'
1101        reason_msg = u'The host is shutting down now.'
1102
1103        e = message.Goodbye()
1104        msg = e.marshal()
1105        self.assertEqual(len(msg), 3)
1106        self.assertEqual(msg[0], message.Goodbye.MESSAGE_TYPE)
1107        self.assertEqual(msg[1], {})
1108        self.assertEqual(msg[2], message.Goodbye.DEFAULT_REASON)
1109
1110        e = message.Goodbye(reason=reason)
1111        msg = e.marshal()
1112        self.assertEqual(len(msg), 3)
1113        self.assertEqual(msg[0], message.Goodbye.MESSAGE_TYPE)
1114        self.assertEqual(msg[1], {})
1115        self.assertEqual(msg[2], reason)
1116
1117        e = message.Goodbye(reason=reason, message=reason_msg)
1118        msg = e.marshal()
1119        self.assertEqual(len(msg), 3)
1120        self.assertEqual(msg[0], message.Goodbye.MESSAGE_TYPE)
1121        self.assertEqual(msg[1], {u'message': reason_msg})
1122        self.assertEqual(msg[2], reason)
1123
1124    def test_parse_and_marshal(self):
1125        reason = u'wamp.error.system_shutdown'
1126        reason_msg = u'The host is shutting down now.'
1127
1128        wmsg = [message.Goodbye.MESSAGE_TYPE]
1129        self.assertRaises(ProtocolError, message.Goodbye.parse, wmsg)
1130
1131        wmsg = [message.Goodbye.MESSAGE_TYPE, reason]
1132        self.assertRaises(ProtocolError, message.Goodbye.parse, wmsg)
1133
1134        wmsg = [message.Goodbye.MESSAGE_TYPE, {u'message': 100}, reason]
1135        self.assertRaises(ProtocolError, message.Goodbye.parse, wmsg)
1136
1137        wmsg = [message.Goodbye.MESSAGE_TYPE, {}, reason]
1138        msg = message.Goodbye.parse(wmsg)
1139        self.assertIsInstance(msg, message.Goodbye)
1140        self.assertEqual(msg.reason, reason)
1141        self.assertEqual(msg.message, None)
1142        self.assertEqual(msg.marshal(), wmsg)
1143
1144        wmsg = [message.Goodbye.MESSAGE_TYPE, {u'message': reason_msg}, reason]
1145        msg = message.Goodbye.parse(wmsg)
1146        self.assertIsInstance(msg, message.Goodbye)
1147        self.assertEqual(msg.reason, reason)
1148        self.assertEqual(msg.message, reason_msg)
1149        self.assertEqual(msg.marshal(), wmsg)
1150
1151    def test_str(self):
1152        e = message.Goodbye(reason=u'wamp.error.system_shutdown', message=u'The host is shutting down now.')
1153        self.assertIsInstance(str(e), str)
1154