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