Initial Commit

environment/Lib/site-packages/autobahn/twisted/test/__init__.py

@@ -0,0 +1,25 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################

environment/Lib/site-packages/autobahn/twisted/test/test_tx_application_runner.py

@@ -0,0 +1,124 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+# t.i.reactor doesn't exist until we've imported it once, but we
+# need it to exist so we can @patch it out in the tests ...
+from twisted.internet import reactor  # noqa
+from unittest.mock import patch, Mock
+
+from twisted.internet.defer import inlineCallbacks, succeed
+from twisted.trial import unittest
+
+from autobahn.twisted.wamp import ApplicationRunner
+
+
+def raise_error(*args, **kw):
+    raise RuntimeError("we always fail")
+
+
+class TestApplicationRunner(unittest.TestCase):
+    @patch('twisted.internet.reactor')
+    def test_runner_default(self, fakereactor):
+        fakereactor.connectTCP = Mock(side_effect=raise_error)
+        runner = ApplicationRunner('ws://fake:1234/ws', 'dummy realm')
+
+        # we should get "our" RuntimeError when we call run
+        self.assertRaises(RuntimeError, runner.run, raise_error)
+
+        # both reactor.run and reactor.stop should have been called
+        self.assertEqual(fakereactor.run.call_count, 1)
+        self.assertEqual(fakereactor.stop.call_count, 1)
+
+    @patch('twisted.internet.reactor')
+    @inlineCallbacks
+    def test_runner_no_run(self, fakereactor):
+        fakereactor.connectTCP = Mock(side_effect=raise_error)
+        runner = ApplicationRunner('ws://fake:1234/ws', 'dummy realm')
+
+        try:
+            yield runner.run(raise_error, start_reactor=False)
+            self.fail()  # should have raise an exception, via Deferred
+
+        except RuntimeError as e:
+            # make sure it's "our" exception
+            self.assertEqual(e.args[0], "we always fail")
+
+        # neither reactor.run() NOR reactor.stop() should have been called
+        # (just connectTCP() will have been called)
+        self.assertEqual(fakereactor.run.call_count, 0)
+        self.assertEqual(fakereactor.stop.call_count, 0)
+
+    @patch('twisted.internet.reactor')
+    def test_runner_no_run_happypath(self, fakereactor):
+        proto = Mock()
+        fakereactor.connectTCP = Mock(return_value=succeed(proto))
+        runner = ApplicationRunner('ws://fake:1234/ws', 'dummy realm')
+
+        d = runner.run(Mock(), start_reactor=False)
+
+        # shouldn't have actually connected to anything
+        # successfully, and the run() call shouldn't have inserted
+        # any of its own call/errbacks. (except the cleanup handler)
+        self.assertFalse(d.called)
+        self.assertEqual(1, len(d.callbacks))
+
+        # neither reactor.run() NOR reactor.stop() should have been called
+        # (just connectTCP() will have been called)
+        self.assertEqual(fakereactor.run.call_count, 0)
+        self.assertEqual(fakereactor.stop.call_count, 0)
+
+    @patch('twisted.internet.reactor')
+    def test_runner_bad_proxy(self, fakereactor):
+        proxy = 'myproxy'
+
+        self.assertRaises(
+            AssertionError,
+            ApplicationRunner,
+            'ws://fake:1234/ws', 'dummy realm',
+            proxy=proxy
+        )
+
+    @patch('twisted.internet.reactor')
+    def test_runner_proxy(self, fakereactor):
+        proto = Mock()
+        fakereactor.connectTCP = Mock(return_value=succeed(proto))
+
+        proxy = {'host': 'myproxy', 'port': 3128}
+
+        runner = ApplicationRunner('ws://fake:1234/ws', 'dummy realm', proxy=proxy)
+
+        d = runner.run(Mock(), start_reactor=False)
+
+        # shouldn't have actually connected to anything
+        # successfully, and the run() call shouldn't have inserted
+        # any of its own call/errbacks. (except the cleanup handler)
+        self.assertFalse(d.called)
+        self.assertEqual(1, len(d.callbacks))
+
+        # neither reactor.run() NOR reactor.stop() should have been called
+        # (just connectTCP() will have been called)
+        self.assertEqual(fakereactor.run.call_count, 0)
+        self.assertEqual(fakereactor.stop.call_count, 0)

environment/Lib/site-packages/autobahn/twisted/test/test_tx_choosereactor.py

@@ -0,0 +1,139 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+import sys
+from unittest.mock import Mock
+
+import twisted.internet
+from twisted.trial import unittest
+
+from autobahn.twisted import choosereactor
+
+
+class ChooseReactorTests(unittest.TestCase):
+
+    def patch_reactor(self, name, new_reactor):
+        """
+        Patch ``name`` so that Twisted will grab a fake reactor instead of
+        a real one.
+        """
+        if hasattr(twisted.internet, name):
+            self.patch(twisted.internet, name, new_reactor)
+        else:
+            def _cleanup():
+                delattr(twisted.internet, name)
+            setattr(twisted.internet, name, new_reactor)
+
+    def patch_modules(self):
+        """
+        Patch ``sys.modules`` so that Twisted believes there is no
+        installed reactor.
+        """
+        old_modules = dict(sys.modules)
+
+        new_modules = dict(sys.modules)
+        del new_modules["twisted.internet.reactor"]
+
+        def _cleanup():
+            sys.modules = old_modules
+
+        self.addCleanup(_cleanup)
+        sys.modules = new_modules
+
+    def test_unknown(self):
+        """
+        ``install_optimal_reactor`` will use the default reactor if it is
+        unable to detect the platform it is running on.
+        """
+        reactor_mock = Mock()
+        self.patch_reactor("selectreactor", reactor_mock)
+        self.patch(sys, "platform", "unknown")
+
+        # Emulate that a reactor has not been installed
+        self.patch_modules()
+
+        choosereactor.install_optimal_reactor()
+        reactor_mock.install.assert_called_once_with()
+
+    def test_mac(self):
+        """
+        ``install_optimal_reactor`` will install KQueueReactor on
+        Darwin (OS X).
+        """
+        reactor_mock = Mock()
+        self.patch_reactor("kqreactor", reactor_mock)
+        self.patch(sys, "platform", "darwin")
+
+        # Emulate that a reactor has not been installed
+        self.patch_modules()
+
+        choosereactor.install_optimal_reactor()
+        reactor_mock.install.assert_called_once_with()
+
+    def test_win(self):
+        """
+        ``install_optimal_reactor`` will install IOCPReactor on Windows.
+        """
+        if sys.platform != 'win32':
+            raise unittest.SkipTest('unit test requires Windows')
+
+        reactor_mock = Mock()
+        self.patch_reactor("iocpreactor", reactor_mock)
+        self.patch(sys, "platform", "win32")
+
+        # Emulate that a reactor has not been installed
+        self.patch_modules()
+
+        choosereactor.install_optimal_reactor()
+        reactor_mock.install.assert_called_once_with()
+
+    def test_bsd(self):
+        """
+        ``install_optimal_reactor`` will install KQueueReactor on BSD.
+        """
+        reactor_mock = Mock()
+        self.patch_reactor("kqreactor", reactor_mock)
+        self.patch(sys, "platform", "freebsd11")
+
+        # Emulate that a reactor has not been installed
+        self.patch_modules()
+
+        choosereactor.install_optimal_reactor()
+        reactor_mock.install.assert_called_once_with()
+
+    def test_linux(self):
+        """
+        ``install_optimal_reactor`` will install EPollReactor on Linux.
+        """
+        reactor_mock = Mock()
+        self.patch_reactor("epollreactor", reactor_mock)
+        self.patch(sys, "platform", "linux")
+
+        # Emulate that a reactor has not been installed
+        self.patch_modules()
+
+        choosereactor.install_optimal_reactor()
+        reactor_mock.install.assert_called_once_with()

environment/Lib/site-packages/autobahn/twisted/test/test_tx_component.py

@@ -0,0 +1,438 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+import os
+from unittest.mock import Mock, patch
+
+if os.environ.get('USE_TWISTED', False):
+    from autobahn.twisted.component import Component
+    from zope.interface import directlyProvides
+    from autobahn.wamp.message import Welcome, Goodbye, Hello, Abort
+    from autobahn.wamp.serializer import JsonSerializer
+    from autobahn.testutil import FakeTransport
+    from twisted.internet.interfaces import IStreamClientEndpoint
+    from twisted.internet.defer import inlineCallbacks, succeed, Deferred
+    from twisted.internet.task import Clock
+    from twisted.trial import unittest
+    from txaio.testutil import replace_loop
+
+    class ConnectionTests(unittest.TestCase):
+
+        def setUp(self):
+            pass
+
+        @patch('txaio.sleep', return_value=succeed(None))
+        @inlineCallbacks
+        def test_successful_connect(self, fake_sleep):
+            endpoint = Mock()
+            joins = []
+
+            def joined(session, details):
+                joins.append((session, details))
+                return session.leave()
+            directlyProvides(endpoint, IStreamClientEndpoint)
+            component = Component(
+                transports={
+                    "type": "websocket",
+                    "url": "ws://127.0.0.1/ws",
+                    "endpoint": endpoint,
+                }
+            )
+            component.on('join', joined)
+
+            def connect(factory, **kw):
+                proto = factory.buildProtocol('ws://localhost/')
+                transport = FakeTransport()
+                proto.makeConnection(transport)
+
+                from autobahn.websocket.protocol import WebSocketProtocol
+                from base64 import b64encode
+                from hashlib import sha1
+                key = proto.websocket_key + WebSocketProtocol._WS_MAGIC
+                proto.data = (
+                    b"HTTP/1.1 101 Switching Protocols\x0d\x0a"
+                    b"Upgrade: websocket\x0d\x0a"
+                    b"Connection: upgrade\x0d\x0a"
+                    b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a"
+                    b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a"
+                )
+                proto.processHandshake()
+
+                from autobahn.wamp import role
+                features = role.RoleBrokerFeatures(
+                    publisher_identification=True,
+                    pattern_based_subscription=True,
+                    session_meta_api=True,
+                    subscription_meta_api=True,
+                    subscriber_blackwhite_listing=True,
+                    publisher_exclusion=True,
+                    subscription_revocation=True,
+                    payload_transparency=True,
+                    payload_encryption_cryptobox=True,
+                )
+
+                msg = Welcome(123456, dict(broker=features), realm='realm')
+                serializer = JsonSerializer()
+                data, is_binary = serializer.serialize(msg)
+                proto.onMessage(data, is_binary)
+
+                msg = Goodbye()
+                proto.onMessage(*serializer.serialize(msg))
+                proto.onClose(True, 100, "some old reason")
+
+                return succeed(proto)
+            endpoint.connect = connect
+
+            # XXX it would actually be nicer if we *could* support
+            # passing a reactor in here, but the _batched_timer =
+            # make_batched_timer() stuff (slash txaio in general)
+            # makes this "hard".
+            reactor = Clock()
+            with replace_loop(reactor):
+                yield component.start(reactor=reactor)
+                self.assertTrue(len(joins), 1)
+                # make sure we fire all our time-outs
+                reactor.advance(3600)
+
+        @patch('txaio.sleep', return_value=succeed(None))
+        def test_successful_proxy_connect(self, fake_sleep):
+            endpoint = Mock()
+            directlyProvides(endpoint, IStreamClientEndpoint)
+            component = Component(
+                transports={
+                    "type": "websocket",
+                    "url": "ws://127.0.0.1/ws",
+                    "endpoint": endpoint,
+                    "proxy": {
+                        "host": "10.0.0.0",
+                        "port": 65000,
+                    },
+                    "max_retries": 0,
+                },
+                is_fatal=lambda _: True,
+            )
+
+            @component.on_join
+            def joined(session, details):
+                return session.leave()
+
+            def connect(factory, **kw):
+                return succeed(Mock())
+            endpoint.connect = connect
+
+            # XXX it would actually be nicer if we *could* support
+            # passing a reactor in here, but the _batched_timer =
+            # make_batched_timer() stuff (slash txaio in general)
+            # makes this "hard".
+            reactor = Clock()
+
+            got_proxy_connect = Deferred()
+
+            def _tcp(host, port, factory, **kw):
+                self.assertEqual("10.0.0.0", host)
+                self.assertEqual(port, 65000)
+                got_proxy_connect.callback(None)
+                return endpoint.connect(factory._wrappedFactory)
+            reactor.connectTCP = _tcp
+
+            with replace_loop(reactor):
+                d = component.start(reactor=reactor)
+
+                def done(x):
+                    if not got_proxy_connect.called:
+                        got_proxy_connect.callback(x)
+                # make sure we fire all our time-outs
+                d.addCallbacks(done, done)
+                reactor.advance(3600)
+                return got_proxy_connect
+
+        @patch('txaio.sleep', return_value=succeed(None))
+        @inlineCallbacks
+        def test_cancel(self, fake_sleep):
+            """
+            if we start a component but call .stop before it connects, ever,
+            it should still exit properly
+            """
+            endpoint = Mock()
+            directlyProvides(endpoint, IStreamClientEndpoint)
+            component = Component(
+                transports={
+                    "type": "websocket",
+                    "url": "ws://127.0.0.1/ws",
+                    "endpoint": endpoint,
+                }
+            )
+
+            def connect(factory, **kw):
+                return Deferred()
+            endpoint.connect = connect
+
+            # XXX it would actually be nicer if we *could* support
+            # passing a reactor in here, but the _batched_timer =
+            # make_batched_timer() stuff (slash txaio in general)
+            # makes this "hard".
+            reactor = Clock()
+            with replace_loop(reactor):
+                d = component.start(reactor=reactor)
+                component.stop()
+                yield d
+
+        @inlineCallbacks
+        def test_cancel_while_waiting(self):
+            """
+            if we start a component but call .stop before it connects, ever,
+            it should still exit properly -- even if we're 'between'
+            connection attempts
+            """
+            endpoint = Mock()
+            directlyProvides(endpoint, IStreamClientEndpoint)
+            component = Component(
+                transports={
+                    "type": "websocket",
+                    "url": "ws://127.0.0.1/ws",
+                    "endpoint": endpoint,
+                    "max_retries": 0,
+                    "max_retry_delay": 5,
+                    "initial_retry_delay": 5,
+                },
+            )
+
+            # XXX it would actually be nicer if we *could* support
+            # passing a reactor in here, but the _batched_timer =
+            # make_batched_timer() stuff (slash txaio in general)
+            # makes this "hard".
+            reactor = Clock()
+            with replace_loop(reactor):
+
+                def connect(factory, **kw):
+                    d = Deferred()
+                    reactor.callLater(10, d.errback(RuntimeError("no connect for yo")))
+                    return d
+                endpoint.connect = connect
+
+                d0 = component.start(reactor=reactor)
+                assert component._delay_f is not None
+                assert not component._done_f.called
+
+                d1 = component.stop()
+                assert component._done_f is None
+                assert d0.called
+
+                yield d1
+                yield d0
+
+        @patch('txaio.sleep', return_value=succeed(None))
+        @inlineCallbacks
+        def test_connect_no_auth_method(self, fake_sleep):
+            endpoint = Mock()
+
+            directlyProvides(endpoint, IStreamClientEndpoint)
+            component = Component(
+                transports={
+                    "type": "websocket",
+                    "url": "ws://127.0.0.1/ws",
+                    "endpoint": endpoint,
+                },
+                is_fatal=lambda e: True,
+            )
+
+            def connect(factory, **kw):
+                proto = factory.buildProtocol('boom')
+                proto.makeConnection(Mock())
+
+                from autobahn.websocket.protocol import WebSocketProtocol
+                from base64 import b64encode
+                from hashlib import sha1
+                key = proto.websocket_key + WebSocketProtocol._WS_MAGIC
+                proto.data = (
+                    b"HTTP/1.1 101 Switching Protocols\x0d\x0a"
+                    b"Upgrade: websocket\x0d\x0a"
+                    b"Connection: upgrade\x0d\x0a"
+                    b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a"
+                    b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a"
+                )
+                proto.processHandshake()
+
+                from autobahn.wamp import role
+                subrole = role.RoleSubscriberFeatures()
+
+                msg = Hello("realm", roles=dict(subscriber=subrole), authmethods=["anonymous"])
+                serializer = JsonSerializer()
+                data, is_binary = serializer.serialize(msg)
+                proto.onMessage(data, is_binary)
+
+                msg = Abort(reason="wamp.error.no_auth_method")
+                proto.onMessage(*serializer.serialize(msg))
+                proto.onClose(False, 100, "wamp.error.no_auth_method")
+
+                return succeed(proto)
+            endpoint.connect = connect
+
+            # XXX it would actually be nicer if we *could* support
+            # passing a reactor in here, but the _batched_timer =
+            # make_batched_timer() stuff (slash txaio in general)
+            # makes this "hard".
+            reactor = Clock()
+            with replace_loop(reactor):
+                with self.assertRaises(RuntimeError) as ctx:
+                    d = component.start(reactor=reactor)
+                    # make sure we fire all our time-outs
+                    reactor.advance(3600)
+                    yield d
+            self.assertIn(
+                "Exhausted all transport",
+                str(ctx.exception)
+            )
+
+    class InvalidTransportConfigs(unittest.TestCase):
+
+        def test_invalid_key(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=dict(
+                        foo='bar',  # totally invalid key
+                    ),
+                )
+            self.assertIn("'foo' is not", str(ctx.exception))
+
+        def test_invalid_key_transport_list(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        dict(type='websocket', url='ws://127.0.0.1/ws'),
+                        dict(foo='bar'),  # totally invalid key
+                    ]
+                )
+            self.assertIn("'foo' is not a valid configuration item", str(ctx.exception))
+
+        def test_invalid_serializer_key(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        {
+                            "url": "ws://127.0.0.1/ws",
+                            "serializer": ["quux"],
+                        }
+                    ]
+                )
+            self.assertIn("only for rawsocket", str(ctx.exception))
+
+        def test_invalid_serializer(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        {
+                            "url": "ws://127.0.0.1/ws",
+                            "serializers": ["quux"],
+                        }
+                    ]
+                )
+            self.assertIn("Invalid serializer", str(ctx.exception))
+
+        def test_invalid_serializer_type_0(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        {
+                            "url": "ws://127.0.0.1/ws",
+                            "serializers": [1, 2],
+                        }
+                    ]
+                )
+            self.assertIn("must be a list", str(ctx.exception))
+
+        def test_invalid_serializer_type_1(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        {
+                            "url": "ws://127.0.0.1/ws",
+                            "serializers": 1,
+                        }
+                    ]
+                )
+            self.assertIn("must be a list", str(ctx.exception))
+
+        def test_invalid_type_key(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        {
+                            "type": "bad",
+                        }
+                    ]
+                )
+            self.assertIn("Invalid transport type", str(ctx.exception))
+
+        def test_invalid_type(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        "foo"
+                    ]
+                )
+            self.assertIn("invalid WebSocket URL", str(ctx.exception))
+
+        def test_no_url(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    transports=[
+                        {
+                            "type": "websocket",
+                        }
+                    ]
+                )
+            self.assertIn("Transport requires 'url'", str(ctx.exception))
+
+        def test_endpoint_bogus_object(self):
+            with self.assertRaises(ValueError) as ctx:
+                Component(
+                    main=lambda r, s: None,
+                    transports=[
+                        {
+                            "type": "websocket",
+                            "url": "ws://example.com/ws",
+                            "endpoint": ("not", "a", "dict"),
+                        }
+                    ]
+                )
+            self.assertIn("'endpoint' configuration must be", str(ctx.exception))
+
+        def test_endpoint_valid(self):
+            Component(
+                main=lambda r, s: None,
+                transports=[
+                    {
+                        "type": "websocket",
+                        "url": "ws://example.com/ws",
+                        "endpoint": {
+                            "type": "tcp",
+                            "host": "1.2.3.4",
+                            "port": "4321",
+                        }
+                    }
+                ]
+            )

environment/Lib/site-packages/autobahn/twisted/test/test_tx_endpoint_plugins.py

@@ -0,0 +1,49 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+from twisted.trial.unittest import TestCase
+
+
+class PluginTests(TestCase):
+    if True:
+        skip = "Plugins don't work under Python3 yet"
+
+    def test_import(self):
+        from twisted.plugins import autobahn_endpoints
+        self.assertTrue(hasattr(autobahn_endpoints, 'AutobahnClientParser'))
+
+    def test_parse_client_basic(self):
+        from twisted.plugins import autobahn_endpoints
+        self.assertTrue(hasattr(autobahn_endpoints, 'AutobahnClientParser'))
+        from twisted.internet.endpoints import clientFromString, quoteStringArgument
+        from twisted.internet import reactor
+
+        ep_string = "autobahn:{0}:url={1}".format(
+            quoteStringArgument('tcp:localhost:9000'),
+            quoteStringArgument('ws://localhost:9000'),
+        )
+        # we're just testing that this doesn't fail entirely
+        clientFromString(reactor, ep_string)

environment/Lib/site-packages/autobahn/twisted/test/test_tx_protocol.py

@@ -0,0 +1,447 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+from unittest.mock import Mock
+
+import txaio
+txaio.use_twisted()
+
+from autobahn.util import wildcards2patterns
+from autobahn.twisted.websocket import WebSocketServerFactory
+from autobahn.twisted.websocket import WebSocketServerProtocol
+from autobahn.twisted.websocket import WebSocketClientProtocol
+from autobahn.wamp.types import TransportDetails
+from autobahn.websocket.types import ConnectingRequest
+from twisted.python.failure import Failure
+from twisted.internet.error import ConnectionDone, ConnectionAborted, \
+    ConnectionLost
+from twisted.trial import unittest
+try:
+    from twisted.internet.testing import StringTransport
+except ImportError:
+    from twisted.test.proto_helpers import StringTransport
+from autobahn.testutil import FakeTransport
+
+
+class ExceptionHandlingTests(unittest.TestCase):
+    """
+    Tests that we format various exception variations properly during
+    connectionLost
+    """
+
+    def setUp(self):
+        self.factory = WebSocketServerFactory()
+        self.proto = WebSocketServerProtocol()
+        self.proto.factory = self.factory
+        self.proto.log = Mock()
+
+    def tearDown(self):
+        for call in [
+                self.proto.autoPingPendingCall,
+                self.proto.autoPingTimeoutCall,
+                self.proto.openHandshakeTimeoutCall,
+                self.proto.closeHandshakeTimeoutCall,
+        ]:
+            if call is not None:
+                call.cancel()
+
+    def test_connection_done(self):
+        # pretend we connected
+        self.proto._connectionMade()
+
+        self.proto.connectionLost(Failure(ConnectionDone()))
+
+        messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls])
+        self.assertTrue('closed cleanly' in messages)
+
+    def test_connection_aborted(self):
+        # pretend we connected
+        self.proto._connectionMade()
+
+        self.proto.connectionLost(Failure(ConnectionAborted()))
+
+        messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls])
+        self.assertTrue(' aborted ' in messages)
+
+    def test_connection_lost(self):
+        # pretend we connected
+        self.proto._connectionMade()
+
+        self.proto.connectionLost(Failure(ConnectionLost()))
+
+        messages = ' '.join([str(x[1]) for x in self.proto.log.mock_calls])
+        self.assertTrue(' was lost ' in messages)
+
+    def test_connection_lost_arg(self):
+        # pretend we connected
+        self.proto._connectionMade()
+
+        self.proto.connectionLost(Failure(ConnectionLost("greetings")))
+
+        messages = ' '.join([str(x[1]) + str(x[2]) for x in self.proto.log.mock_calls])
+        self.assertTrue(' was lost ' in messages)
+        self.assertTrue('greetings' in messages)
+
+
+class Hixie76RejectionTests(unittest.TestCase):
+    """
+    Hixie-76 should not be accepted by an Autobahn server.
+    """
+    def test_handshake_fails(self):
+        """
+        A handshake from a client only supporting Hixie-76 will fail.
+        """
+        t = FakeTransport()
+        f = WebSocketServerFactory()
+        p = WebSocketServerProtocol()
+        p.factory = f
+        p.transport = t
+
+        # from http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+        http_request = b"GET /demo HTTP/1.1\r\nHost: example.com\r\nConnection: Upgrade\r\nSec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\nSec-WebSocket-Protocol: sample\r\nUpgrade: WebSocket\r\nSec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\nOrigin: http://example.com\r\n\r\n^n:ds[4U"
+
+        p.openHandshakeTimeout = 0
+        p._connectionMade()
+        p.data = http_request
+        p.processHandshake()
+        self.assertIn(b"HTTP/1.1 400", t._written)
+        self.assertIn(b"Hixie76 protocol not supported", t._written)
+
+
+class WebSocketOriginMatching(unittest.TestCase):
+    """
+    Test that we match Origin: headers properly, when asked to
+    """
+
+    def setUp(self):
+        self.factory = WebSocketServerFactory()
+        self.factory.setProtocolOptions(
+            allowedOrigins=['127.0.0.1:*', '*.example.com:*']
+        )
+        self.proto = WebSocketServerProtocol()
+        self.proto.transport = StringTransport()
+        self.proto.factory = self.factory
+        self.proto.failHandshake = Mock()
+        self.proto._connectionMade()
+
+    def tearDown(self):
+        for call in [
+                self.proto.autoPingPendingCall,
+                self.proto.autoPingTimeoutCall,
+                self.proto.openHandshakeTimeoutCall,
+                self.proto.closeHandshakeTimeoutCall,
+        ]:
+            if call is not None:
+                call.cancel()
+
+    def test_match_full_origin(self):
+        self.proto.data = b"\r\n".join([
+            b'GET /ws HTTP/1.1',
+            b'Host: www.example.com',
+            b'Sec-WebSocket-Version: 13',
+            b'Origin: http://www.example.com.malicious.com',
+            b'Sec-WebSocket-Extensions: permessage-deflate',
+            b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
+            b'Connection: keep-alive, Upgrade',
+            b'Upgrade: websocket',
+            b'\r\n',  # last string doesn't get a \r\n from join()
+        ])
+        self.proto.consumeData()
+
+        self.assertTrue(self.proto.failHandshake.called, "Handshake should have failed")
+        arg = self.proto.failHandshake.mock_calls[0][1][0]
+        self.assertTrue('not allowed' in arg)
+
+    def test_match_wrong_scheme_origin(self):
+        # some monkey-business since we already did this in setUp, but
+        # we want a different set of matching origins
+        self.factory.setProtocolOptions(
+            allowedOrigins=['http://*.example.com:*']
+        )
+        self.proto.allowedOriginsPatterns = self.factory.allowedOriginsPatterns
+        self.proto.allowedOrigins = self.factory.allowedOrigins
+
+        # the actual test
+        self.factory.isSecure = False
+        self.proto.data = b"\r\n".join([
+            b'GET /ws HTTP/1.1',
+            b'Host: www.example.com',
+            b'Sec-WebSocket-Version: 13',
+            b'Origin: https://www.example.com',
+            b'Sec-WebSocket-Extensions: permessage-deflate',
+            b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
+            b'Connection: keep-alive, Upgrade',
+            b'Upgrade: websocket',
+            b'\r\n',  # last string doesn't get a \r\n from join()
+        ])
+        self.proto.consumeData()
+
+        self.assertTrue(self.proto.failHandshake.called, "Handshake should have failed")
+        arg = self.proto.failHandshake.mock_calls[0][1][0]
+        self.assertTrue('not allowed' in arg)
+
+    def test_match_origin_secure_scheme(self):
+        self.factory.isSecure = True
+        self.factory.port = 443
+        self.proto.data = b"\r\n".join([
+            b'GET /ws HTTP/1.1',
+            b'Host: www.example.com',
+            b'Sec-WebSocket-Version: 13',
+            b'Origin: https://www.example.com',
+            b'Sec-WebSocket-Extensions: permessage-deflate',
+            b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
+            b'Connection: keep-alive, Upgrade',
+            b'Upgrade: websocket',
+            b'\r\n',  # last string doesn't get a \r\n from join()
+        ])
+        self.proto.consumeData()
+
+        self.assertFalse(self.proto.failHandshake.called, "Handshake should have succeeded")
+
+    def test_match_origin_documentation_example(self):
+        """
+        Test the examples from the docs
+        """
+        self.factory.setProtocolOptions(
+            allowedOrigins=['*://*.example.com:*']
+        )
+        self.factory.isSecure = True
+        self.factory.port = 443
+        self.proto.data = b"\r\n".join([
+            b'GET /ws HTTP/1.1',
+            b'Host: www.example.com',
+            b'Sec-WebSocket-Version: 13',
+            b'Origin: http://www.example.com',
+            b'Sec-WebSocket-Extensions: permessage-deflate',
+            b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
+            b'Connection: keep-alive, Upgrade',
+            b'Upgrade: websocket',
+            b'\r\n',  # last string doesn't get a \r\n from join()
+        ])
+        self.proto.consumeData()
+
+        self.assertFalse(self.proto.failHandshake.called, "Handshake should have succeeded")
+
+    def test_match_origin_examples(self):
+        """
+        All the example origins from RFC6454 (3.2.1)
+        """
+        # we're just testing the low-level function here...
+        from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
+        policy = wildcards2patterns(['*example.com:*'])
+
+        # should parametrize test ...
+        for url in ['http://example.com/', 'http://example.com:80/',
+                    'http://example.com/path/file',
+                    'http://example.com/;semi=true',
+                    # 'http://example.com./',
+                    '//example.com/',
+                    'http://@example.com']:
+            self.assertTrue(_is_same_origin(_url_to_origin(url), 'http', 80, policy), url)
+
+    def test_match_origin_counter_examples(self):
+        """
+        All the example 'not-same' origins from RFC6454 (3.2.1)
+        """
+        # we're just testing the low-level function here...
+        from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
+        policy = wildcards2patterns(['example.com'])
+
+        for url in ['http://ietf.org/', 'http://example.org/',
+                    'https://example.com/', 'http://example.com:8080/',
+                    'http://www.example.com/']:
+            self.assertFalse(_is_same_origin(_url_to_origin(url), 'http', 80, policy))
+
+    def test_match_origin_edge(self):
+        # we're just testing the low-level function here...
+        from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
+        policy = wildcards2patterns(['http://*example.com:80'])
+
+        self.assertTrue(
+            _is_same_origin(_url_to_origin('http://example.com:80'), 'http', 80, policy)
+        )
+        self.assertFalse(
+            _is_same_origin(_url_to_origin('http://example.com:81'), 'http', 81, policy)
+        )
+        self.assertFalse(
+            _is_same_origin(_url_to_origin('https://example.com:80'), 'http', 80, policy)
+        )
+
+    def test_origin_from_url(self):
+        from autobahn.websocket.protocol import _url_to_origin
+
+        # basic function
+        self.assertEqual(
+            _url_to_origin('http://example.com'),
+            ('http', 'example.com', 80)
+        )
+        # should lower-case scheme
+        self.assertEqual(
+            _url_to_origin('hTTp://example.com'),
+            ('http', 'example.com', 80)
+        )
+
+    def test_origin_file(self):
+        from autobahn.websocket.protocol import _url_to_origin
+        self.assertEqual('null', _url_to_origin('file:///etc/passwd'))
+
+    def test_origin_null(self):
+        from autobahn.websocket.protocol import _is_same_origin, _url_to_origin
+        self.assertEqual('null', _url_to_origin('null'))
+        self.assertFalse(
+            _is_same_origin(_url_to_origin('null'), 'http', 80, [])
+        )
+        self.assertFalse(
+            _is_same_origin(_url_to_origin('null'), 'https', 80, [])
+        )
+        self.assertFalse(
+            _is_same_origin(_url_to_origin('null'), '', 80, [])
+        )
+        self.assertFalse(
+            _is_same_origin(_url_to_origin('null'), None, 80, [])
+        )
+
+
+class WebSocketXForwardedFor(unittest.TestCase):
+    """
+    Test that (only) a trusted X-Forwarded-For can replace the peer address.
+    """
+
+    def setUp(self):
+        self.factory = WebSocketServerFactory()
+        self.factory.setProtocolOptions(
+            trustXForwardedFor=2
+        )
+        self.proto = WebSocketServerProtocol()
+        self.proto.transport = StringTransport()
+        self.proto.factory = self.factory
+        self.proto.failHandshake = Mock()
+        self.proto._connectionMade()
+
+    def tearDown(self):
+        for call in [
+                self.proto.autoPingPendingCall,
+                self.proto.autoPingTimeoutCall,
+                self.proto.openHandshakeTimeoutCall,
+                self.proto.closeHandshakeTimeoutCall,
+        ]:
+            if call is not None:
+                call.cancel()
+
+    def test_trusted_addresses(self):
+        self.proto.data = b"\r\n".join([
+            b'GET /ws HTTP/1.1',
+            b'Host: www.example.com',
+            b'Origin: http://www.example.com',
+            b'Sec-WebSocket-Version: 13',
+            b'Sec-WebSocket-Extensions: permessage-deflate',
+            b'Sec-WebSocket-Key: tXAxWFUqnhi86Ajj7dRY5g==',
+            b'Connection: keep-alive, Upgrade',
+            b'Upgrade: websocket',
+            b'X-Forwarded-For: 1.2.3.4, 2.3.4.5, 111.222.33.44',
+            b'\r\n',  # last string doesn't get a \r\n from join()
+        ])
+        self.proto.consumeData()
+
+        self.assertEquals(
+            self.proto.peer, "2.3.4.5",
+            "The second address in X-Forwarded-For should have been picked as the peer address")
+
+
+class OnConnectingTests(unittest.TestCase):
+    """
+    Tests related to onConnecting callback
+
+    These tests are testing generic behavior, but are somewhat tied to
+    'a framework' so we're just testing using Twisted-specifics here.
+    """
+
+    def test_on_connecting_client_fails(self):
+
+        MAGIC_STR = 'bad stuff'
+
+        class TestProto(WebSocketClientProtocol):
+            state = None
+            wasClean = True
+            log = Mock()
+
+            def onConnecting(self, transport_details):
+                raise RuntimeError(MAGIC_STR)
+
+        proto = TestProto()
+        proto.transport = FakeTransport()
+        d = proto.startHandshake()
+        self.successResultOf(d)  # error is ignored
+        # ... but error should be logged
+        self.assertTrue(len(proto.log.mock_calls) > 0)
+        magic_found = False
+        for i in range(len(proto.log.mock_calls)):
+            if MAGIC_STR in str(proto.log.mock_calls[i]):
+                magic_found = True
+        self.assertTrue(magic_found, 'MAGIC_STR not found when expected')
+
+    def test_on_connecting_client_success(self):
+
+        class TestProto(WebSocketClientProtocol):
+            state = None
+            wasClean = True
+            perMessageCompressionOffers = []
+            version = 18
+            openHandshakeTimeout = 5
+            log = Mock()
+
+            def onConnecting(self, transport_details):
+                return ConnectingRequest(
+                    host="example.com",
+                    port=443,
+                    resource="/ws",
+                )
+
+        proto = TestProto()
+        proto.transport = FakeTransport()
+        proto.factory = Mock()
+        proto._connectionMade()
+
+        d = proto.startHandshake()
+        req = self.successResultOf(d)
+        self.assertEqual("example.com", req.host)
+        self.assertEqual(443, req.port)
+        self.assertEqual("/ws", req.resource)
+
+    def test_str_transport(self):
+        details = TransportDetails(
+            channel_type=TransportDetails.CHANNEL_TYPE_FUNCTION,
+            peer="example.com",
+            is_secure=False,
+            channel_id={},
+        )
+        # we can str() this and it doesn't fail
+        str(details)
+
+    def test_str_connecting(self):
+        req = ConnectingRequest(host="example.com", port="1234", resource="/ws")
+        # we can str() this and it doesn't fail
+        str(req)

environment/Lib/site-packages/autobahn/twisted/test/test_tx_rawsocket.py

@@ -0,0 +1,70 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+import unittest
+from unittest.mock import Mock
+
+from autobahn.twisted.rawsocket import (WampRawSocketServerFactory,
+                                        WampRawSocketServerProtocol,
+                                        WampRawSocketClientFactory,
+                                        WampRawSocketClientProtocol)
+from autobahn.testutil import FakeTransport
+
+
+class RawSocketHandshakeTests(unittest.TestCase):
+
+    def test_handshake_succeeds(self):
+        """
+        A client can connect to a server.
+        """
+        session_mock = Mock()
+        t = FakeTransport()
+        f = WampRawSocketClientFactory(lambda: session_mock)
+        p = WampRawSocketClientProtocol()
+        p.transport = t
+        p.factory = f
+
+        server_session_mock = Mock()
+        st = FakeTransport()
+        sf = WampRawSocketServerFactory(lambda: server_session_mock)
+        sp = WampRawSocketServerProtocol()
+        sp.transport = st
+        sp.factory = sf
+
+        sp.connectionMade()
+        p.connectionMade()
+
+        # Send the server the client handshake
+        sp.dataReceived(t._written[0:1])
+        sp.dataReceived(t._written[1:4])
+
+        # Send the client the server handshake
+        p.dataReceived(st._written)
+
+        # The handshake succeeds, a session on each end is created
+        # onOpen is called on the session
+        session_mock.onOpen.assert_called_once_with(p)
+        server_session_mock.onOpen.assert_called_once_with(sp)

environment/Lib/site-packages/autobahn/twisted/test/test_tx_websocket_agent.py

@@ -0,0 +1,81 @@
+from twisted.trial import unittest
+
+try:
+    from autobahn.twisted.testing import create_memory_agent, MemoryReactorClockResolver, create_pumper
+    HAVE_TESTING = True
+except ImportError:
+    HAVE_TESTING = False
+
+from twisted.internet.defer import inlineCallbacks
+from autobahn.twisted.websocket import WebSocketServerProtocol
+
+
+class TestAgent(unittest.TestCase):
+
+    skip = not HAVE_TESTING
+
+    def setUp(self):
+        self.pumper = create_pumper()
+        self.reactor = MemoryReactorClockResolver()
+        return self.pumper.start()
+
+    def tearDown(self):
+        return self.pumper.stop()
+
+    @inlineCallbacks
+    def test_echo_server(self):
+
+        class EchoServer(WebSocketServerProtocol):
+            def onMessage(self, msg, is_binary):
+                self.sendMessage(msg)
+
+        agent = create_memory_agent(self.reactor, self.pumper, EchoServer)
+        proto = yield agent.open("ws://localhost:1234/ws", dict())
+
+        messages = []
+
+        def got(msg, is_binary):
+            messages.append(msg)
+        proto.on("message", got)
+
+        proto.sendMessage(b"hello")
+
+        if True:
+            # clean close
+            proto.sendClose()
+        else:
+            # unclean close
+            proto.transport.loseConnection()
+        yield proto.is_closed
+        self.assertEqual([b"hello"], messages)
+
+    # FIXME:
+    # /twisted/util.py", line 162, in transport_channel_id channel_id_type, type(transport)))
+    # builtins.RuntimeError: cannot determine TLS channel ID of type "tls-unique" when TLS is not
+    # available on this transport <class 'twisted.test.iosim.FakeTransport'>
+    # @inlineCallbacks
+    # def test_secure_echo_server(self):
+
+    #     class EchoServer(WebSocketServerProtocol):
+    #         def onMessage(self, msg, is_binary):
+    #             self.sendMessage(msg)
+
+    #     agent = create_memory_agent(self.reactor, self.pumper, EchoServer)
+    #     proto = yield agent.open("wss://localhost:1234/ws", dict())
+
+    #     messages = []
+
+    #     def got(msg, is_binary):
+    #         messages.append(msg)
+    #     proto.on("message", got)
+
+    #     proto.sendMessage(b"hello")
+
+    #     if True:
+    #         # clean close
+    #         proto.sendClose()
+    #     else:
+    #         # unclean close
+    #         proto.transport.loseConnection()
+    #     yield proto.is_closed
+    #     self.assertEqual([b"hello"], messages)

environment/Lib/site-packages/autobahn/twisted/test/test_wamp_runner.py

@@ -0,0 +1,90 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+###############################################################################
+
+import unittest
+
+from unittest.mock import patch
+from zope.interface import implementer
+from twisted.internet.interfaces import IReactorTime
+
+
+@implementer(IReactorTime)
+class FakeReactor(object):
+    """
+    This just fakes out enough reactor methods so .run() can work.
+    """
+    stop_called = False
+
+    def __init__(self, to_raise):
+        self.stop_called = False
+        self.to_raise = to_raise
+        self.delayed = []
+
+    def run(self, *args, **kw):
+        raise self.to_raise
+
+    def stop(self):
+        self.stop_called = True
+
+    def callLater(self, delay, func, *args, **kwargs):
+        self.delayed.append((delay, func, args, kwargs))
+
+    def connectTCP(self, *args, **kw):
+        raise RuntimeError("ConnectTCP shouldn't get called")
+
+
+class TestWampTwistedRunner(unittest.TestCase):
+    # XXX should figure out *why* but the test_protocol timeout
+    # tests fail if we *don't* patch out this txaio stuff. So,
+    # presumably it's messing up some global state that both tests
+    # implicitly depend on ...
+
+    @patch('txaio.use_twisted')
+    @patch('txaio.start_logging')
+    @patch('txaio.config')
+    def test_connect_error(self, *args):
+        """
+        Ensure the runner doesn't swallow errors and that it exits the
+        reactor properly if there is one.
+        """
+        try:
+            from autobahn.twisted.wamp import ApplicationRunner
+            from twisted.internet.error import ConnectionRefusedError
+            # the 'reactor' member doesn't exist until we import it
+            from twisted.internet import reactor  # noqa: F401
+        except ImportError:
+            raise unittest.SkipTest('No twisted')
+
+        runner = ApplicationRunner('ws://localhost:1', 'realm')
+        exception = ConnectionRefusedError("It's a trap!")
+
+        with patch('twisted.internet.reactor', FakeReactor(exception)) as mockreactor:
+            self.assertRaises(
+                ConnectionRefusedError,
+                # pass a no-op session-creation method
+                runner.run, lambda _: None, start_reactor=True
+            )
+            self.assertTrue(mockreactor.stop_called)