Example #1
0
 def test_foolscap_handlers(self):
     """
     ``create_connection_handlers`` returns a Foolscap connection handlers
     dictionary mapping ``"tcp"`` to
     ``foolscap.connections.tcp.DefaultTCP``, ``"tor"`` to the supplied Tor
     provider's handler, and ``"i2p"`` to the supplied I2P provider's
     handler.
     """
     config = config_from_string(
         "fake.port",
         "no-basedir",
         BASECONFIG,
     )
     tor_endpoint = object()
     tor = ConstantAddresses(handler=tor_endpoint)
     i2p_endpoint = object()
     i2p = ConstantAddresses(handler=i2p_endpoint)
     _, foolscap_handlers = create_connection_handlers(
         config,
         i2p,
         tor,
     )
     self.assertThat(
         foolscap_handlers,
         MatchesDict({
             "tcp": IsInstance(tcp.DefaultTCP),
             "i2p": Equals(i2p_endpoint),
             "tor": Equals(tor_endpoint),
         }),
     )
Example #2
0
    def _do_test_connect(self, endpoint, reachable):
        reactor = object()
        txi2p = object()
        args = []
        if endpoint:
            args = ["--i2p-sam-port=%s" % endpoint]
        cli_config = make_cli_config("basedir", "--listen=i2p", *args)
        stdout = cli_config.stdout
        expected_port = "tcp:127.0.0.1:7656"
        if endpoint:
            expected_port = endpoint
        tried = []
        def _try_to_connect(reactor, port, stdout, txi2p):
            tried.append( (reactor, port, stdout, txi2p) )
            if not reachable:
                return defer.succeed(None)
            if port == expected_port:
                return defer.succeed(True)
            return defer.succeed(None)

        with mock.patch("allmydata.util.i2p_provider._try_to_connect",
                        _try_to_connect):
            d = i2p_provider._connect_to_i2p(reactor, cli_config, txi2p)
        if not reachable:
            f = self.failureResultOf(d)
            self.assertIsInstance(f.value, ValueError)
            self.assertEqual(str(f.value),
                             "unable to reach any default I2P SAM port")
            return
        successful_port = self.successResultOf(d)
        self.assertEqual(successful_port, expected_port)
        expected = [(reactor, "tcp:127.0.0.1:7656", stdout, txi2p)]
        if endpoint:
            expected = [(reactor, endpoint, stdout, txi2p)]
        self.assertEqual(tried, expected)
Example #3
0
 def test_default(self):
     default_connection_handlers, _ = create_connection_handlers(
         self.config,
         ConstantAddresses(handler=object()),
         ConstantAddresses(handler=object()),
     )
     self.assertEqual(default_connection_handlers["tcp"], "tcp")
     self.assertEqual(default_connection_handlers["tor"], "tor")
     self.assertEqual(default_connection_handlers["i2p"], "i2p")
    def _do_test_launch(self, executable):
        basedir = self.mktemp()
        os.mkdir(basedir)
        private_dir = os.path.join(basedir, "private")
        os.mkdir(private_dir)
        reactor = object()
        args = ["--listen=tor", "--tor-launch"]
        if executable:
            args.append("--tor-executable=%s" % executable)
        cli_config = make_cli_config(basedir, *args)
        protocol = object()
        launch_tor = mock.Mock(return_value=defer.succeed(("control_endpoint",
                                                           protocol)))
        txtorcon = mock.Mock()
        ehs = mock.Mock()
        # This appears to be a native string in the real txtorcon object...
        ehs.private_key = ensure_str("privkey")
        ehs.hostname = "ONION.onion"
        txtorcon.EphemeralHiddenService = mock.Mock(return_value=ehs)
        ehs.add_to_tor = mock.Mock(return_value=defer.succeed(None))
        ehs.remove_from_tor = mock.Mock(return_value=defer.succeed(None))

        with mock_txtorcon(txtorcon):
            with mock.patch("allmydata.util.tor_provider._launch_tor",
                            launch_tor):
                with mock.patch(
                        "allmydata.util.tor_provider.allocate_tcp_port",
                        return_value=999999):
                    d = tor_provider.create_config(reactor, cli_config)
        tahoe_config_tor, tor_port, tor_location = self.successResultOf(d)

        launch_tor.assert_called_with(reactor, executable,
                                      os.path.abspath(private_dir), txtorcon)
        txtorcon.EphemeralHiddenService.assert_called_with(
            "3457 127.0.0.1:999999")
        ehs.add_to_tor.assert_called_with(protocol)
        ehs.remove_from_tor.assert_called_with(protocol)

        expected = {
            "launch": "true",
            "onion": "true",
            "onion.local_port": "999999",
            "onion.external_port": "3457",
            "onion.private_key_file": os.path.join("private",
                                                   "tor_onion.privkey"),
        }
        if executable:
            expected["tor.executable"] = executable
        self.assertEqual(tahoe_config_tor, expected)
        self.assertEqual(tor_port, "tcp:999999:interface=127.0.0.1")
        self.assertEqual(tor_location, "tor:ONION.onion:3457")
        fn = os.path.join(basedir, tahoe_config_tor["onion.private_key_file"])
        with open(fn, "rb") as f:
            privkey = f.read()
        self.assertEqual(privkey, b"privkey")
Example #5
0
    def test_handler_default(self):
        i2p = mock.Mock()
        handler = object()
        i2p.default = mock.Mock(return_value=handler)
        reactor = object()

        with mock_i2p(i2p):
            p = i2p_provider.create(reactor, FakeConfig())
        h = p.get_i2p_handler()
        self.assertIs(h, handler)
        i2p.default.assert_called_with(reactor, keyfile=None)
Example #6
0
    def test_handler_launch(self):
        i2p = mock.Mock()
        handler = object()
        i2p.launch = mock.Mock(return_value=handler)
        reactor = object()

        with mock_i2p(i2p):
            p = i2p_provider.create(reactor,
                                    FakeConfig(launch=True))
        h = p.get_i2p_handler()
        self.assertIs(h, handler)
        i2p.launch.assert_called_with(i2p_configdir=None, i2p_binary=None)
Example #7
0
    def test_handler_configdir(self):
        i2p = mock.Mock()
        handler = object()
        i2p.local_i2p = mock.Mock(return_value=handler)
        reactor = object()

        with mock_i2p(i2p):
            p = i2p_provider.create(reactor,
                                    FakeConfig(**{"i2p.configdir": "configdir"}))
        h = p.get_i2p_handler()
        i2p.local_i2p.assert_called_with("configdir")
        self.assertIs(h, handler)
Example #8
0
 def test_connections_tcp_disabled(self):
     config = config_from_string(
         "no-basedir",
         "fake.port",
         BASECONFIG + "[connections]\ntcp = disabled\n" +
         "[node]\nreveal-IP-address = false\n",
     )
     default_connection_handlers, _ = create_connection_handlers(
         config,
         ConstantAddresses(handler=object()),
         ConstantAddresses(handler=object()),
     )
     self.assertEqual(default_connection_handlers["tcp"], None)
Example #9
0
 def test_tcp_disabled(self):
     config = config_from_string(
         "fake.port",
         "no-basedir",
         BASECONFIG + "[connections]\ntcp = disabled\n",
     )
     default_connection_handlers, _ = create_connection_handlers(
         config,
         ConstantAddresses(handler=object()),
         ConstantAddresses(handler=object()),
     )
     self.assertEqual(default_connection_handlers["tcp"], None)
     self.assertEqual(default_connection_handlers["tor"], "tor")
     self.assertEqual(default_connection_handlers["i2p"], "i2p")
Example #10
0
 def test_try(self):
     reactor = object()
     txi2p = mock.Mock()
     d = defer.succeed(True)
     txi2p.testAPI = mock.Mock(return_value=d)
     ep = object()
     stdout = StringIO()
     with mock.patch("allmydata.util.i2p_provider.clientFromString",
                     return_value=ep) as cfs:
         d = i2p_provider._try_to_connect(reactor, "desc", stdout, txi2p)
     r = self.successResultOf(d)
     self.assertTrue(r)
     cfs.assert_called_with(reactor, "desc")
     txi2p.testAPI.assert_called_with(reactor, 'SAM', ep)
 def test_try(self):
     reactor = object()
     txtorcon = mock.Mock()
     tor_state = object()
     d = defer.succeed(tor_state)
     txtorcon.build_tor_connection = mock.Mock(return_value=d)
     ep = object()
     stdout = StringIO()
     with mock.patch("allmydata.util.tor_provider.clientFromString",
                     return_value=ep) as cfs:
         d = tor_provider._try_to_connect(reactor, "desc", stdout, txtorcon)
     r = self.successResultOf(d)
     self.assertIs(r, tor_state)
     cfs.assert_called_with(reactor, "desc")
     txtorcon.build_tor_connection.assert_called_with(ep)
Example #12
0
    def test_handler_launch_configdir_executable(self):
        i2p = mock.Mock()
        handler = object()
        i2p.launch = mock.Mock(return_value=handler)
        reactor = object()

        with mock_i2p(i2p):
            p = i2p_provider.create(reactor,
                                    FakeConfig(launch=True,
                                               **{"i2p.configdir": "configdir",
                                                  "i2p.executable": "myi2p",
                                               }))
        h = p.get_i2p_handler()
        self.assertIs(h, handler)
        i2p.launch.assert_called_with(i2p_configdir="configdir", i2p_binary="myi2p")
Example #13
0
 def test_unknown(self):
     config = config_from_string(
         "fake.port",
         "no-basedir",
         BASECONFIG + "[connections]\ntcp = unknown\n",
     )
     with self.assertRaises(ValueError) as ctx:
         create_connection_handlers(
             config,
             ConstantAddresses(handler=object()),
             ConstantAddresses(handler=object()),
         )
     self.assertIn("'tahoe.cfg [connections] tcp='", str(ctx.exception))
     self.assertIn("uses unknown handler type 'unknown'",
                   str(ctx.exception))
    def test_control_endpoint(self):
        basedir = self.mktemp()
        os.mkdir(basedir)
        private_dir = os.path.join(basedir, "private")
        os.mkdir(private_dir)
        reactor = object()
        cli_config = make_cli_config(basedir, "--listen=tor")
        protocol = object()
        connect_to_tor = mock.Mock(return_value=defer.succeed(("goodport",
                                                               protocol)))
        txtorcon = mock.Mock()
        ehs = mock.Mock()
        ehs.private_key = b"privkey"
        ehs.hostname = "ONION.onion"
        txtorcon.EphemeralHiddenService = mock.Mock(return_value=ehs)
        ehs.add_to_tor = mock.Mock(return_value=defer.succeed(None))
        ehs.remove_from_tor = mock.Mock(return_value=defer.succeed(None))

        with mock_txtorcon(txtorcon):
            with mock.patch("allmydata.util.tor_provider._connect_to_tor",
                            connect_to_tor):
                with mock.patch(
                        "allmydata.util.tor_provider.allocate_tcp_port",
                        return_value=999999):
                    d = tor_provider.create_config(reactor, cli_config)
        tahoe_config_tor, tor_port, tor_location = self.successResultOf(d)

        connect_to_tor.assert_called_with(reactor, cli_config, txtorcon)
        txtorcon.EphemeralHiddenService.assert_called_with(
            "3457 127.0.0.1:999999")
        ehs.add_to_tor.assert_called_with(protocol)
        ehs.remove_from_tor.assert_called_with(protocol)

        expected = {
            "control.port": "goodport",
            "onion": "true",
            "onion.local_port": "999999",
            "onion.external_port": "3457",
            "onion.private_key_file": os.path.join("private",
                                                   "tor_onion.privkey"),
        }
        self.assertEqual(tahoe_config_tor, expected)
        self.assertEqual(tor_port, "tcp:999999:interface=127.0.0.1")
        self.assertEqual(tor_location, "tor:ONION.onion:3457")
        fn = os.path.join(basedir, tahoe_config_tor["onion.private_key_file"])
        with open(fn, "rb") as f:
            privkey = f.read()
        self.assertEqual(privkey, b"privkey")
Example #15
0
    def test_types_isinstance_newobject(self):
        a = list()
        b = dict()
        c = set()
        self.assertTrue(isinstance(a, object))
        self.assertTrue(isinstance(b, object))
        self.assertTrue(isinstance(c, object))

        # Old-style class instances on Py2 should still report as an instance
        # of object as usual on Py2:
        class D:
            pass
        d = D()
        self.assertTrue(isinstance(d, object))

        e = object()
        self.assertTrue(isinstance(e, object))

        class F(object):
            pass
        f = F()
        self.assertTrue(isinstance(f, object))

        class G(F):
            pass
        g = G()
        self.assertTrue(isinstance(g, object))

        class H():
            pass
        h = H()
        self.assertTrue(isinstance(h, object))
Example #16
0
 def test_tor_unimportable(self):
     """
     If the configuration calls for substituting Tor for TCP and
     ``foolscap.connections.tor`` is not importable then
     ``create_connection_handlers`` raises ``ValueError`` with a message
     explaining this makes Tor unusable.
     """
     self.config = config_from_string(
         "fake.port",
         "no-basedir",
         BASECONFIG + "[connections]\ntcp = tor\n",
     )
     tor_provider = create_tor_provider(
         reactor,
         self.config,
         import_tor=lambda: None,
     )
     with self.assertRaises(ValueError) as ctx:
         default_connection_handlers, _ = create_connection_handlers(
             self.config,
             i2p_provider=ConstantAddresses(handler=object()),
             tor_provider=tor_provider,
         )
     self.assertEqual(
         str(ctx.exception),
         "'tahoe.cfg [connections] tcp='"
         " uses unavailable/unimportable handler type 'tor'."
         " Please pip install tahoe-lafs[tor] to fix.",
     )
Example #17
0
 def test_try_unhandled_error(self):
     reactor = object()
     txi2p = mock.Mock()
     d = defer.fail(ValueError("oops"))
     txi2p.testAPI = mock.Mock(return_value=d)
     ep = object()
     stdout = StringIO()
     with mock.patch("allmydata.util.i2p_provider.clientFromString",
                     return_value=ep) as cfs:
         d = i2p_provider._try_to_connect(reactor, "desc", stdout, txi2p)
     f = self.failureResultOf(d)
     self.assertIsInstance(f.value, ValueError)
     self.assertEqual(str(f.value), "oops")
     cfs.assert_called_with(reactor, "desc")
     txi2p.testAPI.assert_called_with(reactor, 'SAM', ep)
     self.assertEqual(stdout.getvalue(), "")
Example #18
0
    def test_handler_sam_endpoint(self):
        i2p = mock.Mock()
        handler = object()
        i2p.sam_endpoint = mock.Mock(return_value=handler)
        ep = object()
        reactor = object()

        with mock_i2p(i2p):
            p = i2p_provider.create(reactor,
                                    FakeConfig(**{"sam.port": "ep_desc"}))
            with mock.patch("allmydata.util.i2p_provider.clientFromString",
                            return_value=ep) as cfs:
                h = p.get_i2p_handler()
        cfs.assert_called_with(reactor, "ep_desc")
        self.assertIs(h, handler)
        i2p.sam_endpoint.assert_called_with(ep, keyfile=None)
    def test_handler_launch(self):
        reactor = object()
        tor = mock.Mock()
        txtorcon = mock.Mock()
        handler = object()
        tor.control_endpoint_maker = mock.Mock(return_value=handler)
        tor.add_context = mock.Mock(return_value=EmptyContext())
        with mock_tor(tor):
            with mock_txtorcon(txtorcon):
                p = tor_provider.create(reactor, FakeConfig(launch=True))
        h = p.get_tor_handler()
        self.assertIs(h, handler)
        tor.control_endpoint_maker.assert_called_with(p._make_control_endpoint,
                                                      takes_status=True)

        # make sure Tor is launched just once, the first time an endpoint is
        # requested, and never again. The clientFromString() function is
        # called once each time.

        ep_desc = object()
        launch_tor = mock.Mock(return_value=defer.succeed((ep_desc, None)))
        ep = object()
        cfs = mock.Mock(return_value=ep)
        with mock.patch("allmydata.util.tor_provider._launch_tor", launch_tor):
            with mock.patch("allmydata.util.tor_provider.clientFromString",
                            cfs):
                d = p._make_control_endpoint(reactor,
                                             update_status=lambda status: None)
                yield flushEventualQueue()
                self.assertIs(self.successResultOf(d), ep)
                launch_tor.assert_called_with(
                    reactor, None, os.path.join("basedir", "private"),
                    txtorcon)
                cfs.assert_called_with(reactor, ep_desc)

        launch_tor2 = mock.Mock(return_value=defer.succeed((ep_desc, None)))
        cfs2 = mock.Mock(return_value=ep)
        with mock.patch("allmydata.util.tor_provider._launch_tor",
                        launch_tor2):
            with mock.patch("allmydata.util.tor_provider.clientFromString",
                            cfs2):
                d2 = p._make_control_endpoint(
                    reactor, update_status=lambda status: None)
                yield flushEventualQueue()
                self.assertIs(self.successResultOf(d2), ep)
                self.assertEqual(launch_tor2.mock_calls, [])
                cfs2.assert_called_with(reactor, ep_desc)
    def test_handler_control_endpoint(self):
        tor = mock.Mock()
        handler = object()
        tor.control_endpoint = mock.Mock(return_value=handler)
        ep = object()
        cfs = mock.Mock(return_value=ep)
        reactor = object()

        with mock_tor(tor):
            p = tor_provider.create(reactor,
                                    FakeConfig(**{"control.port": "ep_desc"}))
            with mock.patch("allmydata.util.tor_provider.clientFromString",
                            cfs):
                h = p.get_tor_handler()
        self.assertIs(h, handler)
        cfs.assert_called_with(reactor, "ep_desc")
        tor.control_endpoint.assert_called_with(ep)
Example #21
0
 def test_try_handled_error(self):
     reactor = object()
     txi2p = mock.Mock()
     d = defer.fail(error.ConnectError("oops"))
     txi2p.testAPI = mock.Mock(return_value=d)
     ep = object()
     stdout = StringIO()
     with mock.patch("allmydata.util.i2p_provider.clientFromString",
                     return_value=ep) as cfs:
         d = i2p_provider._try_to_connect(reactor, "desc", stdout, txi2p)
     r = self.successResultOf(d)
     self.assertIs(r, None)
     cfs.assert_called_with(reactor, "desc")
     txi2p.testAPI.assert_called_with(reactor, 'SAM', ep)
     self.assertEqual(stdout.getvalue(),
                      "Unable to reach I2P SAM API at 'desc': "
                      "An error occurred while connecting: oops.\n")
Example #22
0
 def test_non_iterator(self):
     """
     The default behaviour of next(o) for a newobject o should be to raise a
     TypeError, as with the corresponding builtin object.
     """
     o = object()
     with self.assertRaises(TypeError):
         next(o)
Example #23
0
 def test_return_value(self, logger):
     """
     The decorated function's return value is passed through.
     """
     result = object()
     @log_call_deferred(action_type=u"the-action")
     def f():
         return result
     self.assertThat(f(), succeeded(Is(result)))
Example #24
0
    def test_cannot_assign_new_attributes_to_object(self):
        """
        New attributes cannot be assigned to object() instances in Python.
        The same should apply to newobject.
        """
        from builtins import object

        with self.assertRaises(AttributeError):
            object().arbitrary_attribute_name = True
    def test_cannot_assign_new_attributes_to_object(self):
        """
        New attributes cannot be assigned to object() instances in Python.
        The same should apply to newobject.
        """
        from builtins import object

        with self.assertRaises(AttributeError):
          object().arbitrary_attribute_name = True
    def _do_test_connect(self, endpoint, reachable):
        reactor = object()
        txtorcon = object()
        args = []
        if endpoint:
            args = ["--tor-control-port=%s" % endpoint]
        cli_config = make_cli_config("basedir", "--listen=tor", *args)
        stdout = cli_config.stdout
        expected_port = "tcp:127.0.0.1:9151"
        if endpoint:
            expected_port = endpoint
        tor_state = mock.Mock
        tor_state.protocol = object()
        tried = []

        def _try_to_connect(reactor, port, stdout, txtorcon):
            tried.append((reactor, port, stdout, txtorcon))
            if not reachable:
                return defer.succeed(None)
            if port == expected_port:  # second one on the list
                return defer.succeed(tor_state)
            return defer.succeed(None)

        with mock.patch("allmydata.util.tor_provider._try_to_connect",
                        _try_to_connect):
            d = tor_provider._connect_to_tor(reactor, cli_config, txtorcon)
        if not reachable:
            f = self.failureResultOf(d)
            self.assertIsInstance(f.value, ValueError)
            self.assertEqual(str(f.value),
                             "unable to reach any default Tor control port")
            return
        successful_port, tor_control_proto = self.successResultOf(d)
        self.assertEqual(successful_port, expected_port)
        self.assertIs(tor_control_proto, tor_state.protocol)
        expected = [
            (reactor, "unix:/var/run/tor/control", stdout, txtorcon),
            (reactor, "tcp:127.0.0.1:9051", stdout, txtorcon),
            (reactor, "tcp:127.0.0.1:9151", stdout, txtorcon),
        ]
        if endpoint:
            expected = [(reactor, endpoint, stdout, txtorcon)]
        self.assertEqual(tried, expected)
Example #27
0
    def test_connections(self):
        config = config_from_string(
            "fake.port",
            "no-basedir",
            BASECONFIG + "[node]\nreveal-IP-address = false\n",
        )

        with self.assertRaises(PrivacyError) as ctx:
            create_connection_handlers(
                config,
                ConstantAddresses(handler=object()),
                ConstantAddresses(handler=object()),
            )

        self.assertEqual(
            str(ctx.exception),
            "Privacy requested with `reveal-IP-address = false` "
            "but `tcp = tcp` conflicts with this.",
        )
    def test_handler_default(self):
        tor = mock.Mock()
        handler = object()
        tor.default_socks = mock.Mock(return_value=handler)

        with mock_tor(tor):
            p = tor_provider.create("reactor", FakeConfig())
            h = p.get_tor_handler()
        self.assertIs(h, handler)
        tor.default_socks.assert_called_with()
Example #29
0
 def test_stdout(self):
     """
     A ``file:`` description with a path of ``-`` causes logs to be written to
     stdout.
     """
     reactor = object()
     self.assertThat(
         _parse_destination_description("file:-")(reactor),
         Equals(FileDestination(stdout, encoder=AnyBytesJSONEncoder)),
     )
Example #30
0
 def test_enabled_plugin(self):
     """
     An announcement that could be matched by a plugin that is enabled with
     configuration is matched and the plugin's storage client is used.
     """
     plugin_config = {
         "abc": "xyz",
     }
     plugin_name = "tahoe-lafs-dummy-v1"
     yield self.make_node(
         introducer_furl=SOME_FURL,
         storage_plugin=plugin_name,
         plugin_config=plugin_config,
     )
     server_id = b"v0-abcdef"
     ann = {
         u"service-name":
         u"storage",
         u"storage-options": [{
             # and this announcement is for a plugin with a matching name
             u"name":
             plugin_name,
             u"storage-server-FURL":
             SOME_FURL.decode("ascii"),
         }],
     }
     self.publish(server_id, ann, self.introducer_client)
     storage = self.get_storage(server_id, self.node)
     self.assertTrue(verifyObject(
         IFoolscapStorageServer,
         storage,
     ), )
     expected_rref = object()
     # Can't easily establish a real Foolscap connection so fake the result
     # of doing so...
     self.set_rref(server_id, self.node, expected_rref)
     self.expectThat(
         storage.storage_server,
         MatchesAll(
             IsInstance(DummyStorageClient),
             MatchesStructure(
                 get_rref=AfterPreprocessing(
                     lambda get_rref: get_rref(),
                     Is(expected_rref),
                 ),
                 configuration=Equals(plugin_config),
                 announcement=Equals({
                     u'name':
                     plugin_name,
                     u'storage-server-FURL':
                     u'pb://abcde@nowhere/fake',
                 }),
             ),
         ),
     )
    def test_control_endpoint(self):
        basedir = self.mktemp()
        os.mkdir(basedir)
        fn = os.path.join(basedir, "keyfile")
        with open(fn, "w") as f:
            f.write("private key")
        reactor = object()
        cfg = FakeConfig(basedir=basedir,
                         onion=True,
                         **{
                             "control.port": "ep_desc",
                             "onion.local_port": 123,
                             "onion.external_port": 456,
                             "onion.private_key_file": "keyfile",
                         })

        txtorcon = mock.Mock()
        with mock_txtorcon(txtorcon):
            p = tor_provider.create(reactor, cfg)
        tor_state = mock.Mock()
        tor_state.protocol = object()
        txtorcon.build_tor_connection = mock.Mock(return_value=tor_state)
        ehs = mock.Mock()
        ehs.add_to_tor = mock.Mock(return_value=defer.succeed(None))
        ehs.remove_from_tor = mock.Mock(return_value=defer.succeed(None))
        txtorcon.EphemeralHiddenService = mock.Mock(return_value=ehs)
        tcep = object()
        cfs = mock.Mock(return_value=tcep)
        with mock.patch("allmydata.util.tor_provider.clientFromString", cfs):
            d = p.startService()
            yield flushEventualQueue()
        self.successResultOf(d)
        self.assertIs(p._onion_ehs, ehs)
        self.assertIs(p._onion_tor_control_proto, tor_state.protocol)
        cfs.assert_called_with(reactor, "ep_desc")
        txtorcon.build_tor_connection.assert_called_with(tcep)
        txtorcon.EphemeralHiddenService.assert_called_with(
            "456 127.0.0.1:123", b"private key")
        ehs.add_to_tor.assert_called_with(tor_state.protocol)

        yield p.stopService()
        ehs.remove_from_tor.assert_called_with(tor_state.protocol)
    def test_bool_empty_object(self):
        """
        The default result of bool(newobject()) should be True, as with builtin
        objects.
        """
        o = object()
        self.assertTrue(bool(o))

        class MyClass(object):
            pass

        obj = MyClass()
        self.assertTrue(bool(obj))
Example #33
0
from future.backports.email import errors
from future.backports.email import message
from future.backports.email._policybase import compat32

NLCRE = re.compile('\r\n|\r|\n')
NLCRE_bol = re.compile('(\r\n|\r|\n)')
NLCRE_eol = re.compile('(\r\n|\r|\n)\Z')
NLCRE_crack = re.compile('(\r\n|\r|\n)')
# RFC 2822 $3.6.8 Optional fields.  ftext is %d33-57 / %d59-126, Any character
# except controls, SP, and ":".
headerRE = re.compile(r'^(From |[\041-\071\073-\176]{1,}:|[\t ])')
EMPTYSTRING = ''
NL = '\n'

NeedMoreData = object()


# @implements_iterator
class BufferedSubFile(object):
    """A file-ish object that can have new data loaded into it.

    You can also push and pop line-matching predicates onto a stack.  When the
    current predicate matches the current line, a false EOF response
    (i.e. empty string) is returned instead.  This lets the parser adhere to a
    simple abstraction -- it parses until EOF closes the current message.
    """
    def __init__(self):
        # The last partial line pushed into this object.
        self._partial = ''
        # The list of full, pushed lines, in reverse order