def test_interface(self): """ L{client.getResolver} returns an object providing L{IResolver}. """ with AlternateReactor(Clock()): resolver = client.getResolver() self.assertTrue(verifyObject(IResolver, resolver))
def test_cache(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{cache.CacheResolver}. """ with AlternateReactor(Clock()): resolver = client.createResolver() res = [r for r in resolver.resolvers if isinstance(r, cache.CacheResolver)] self.assertEqual(1, len(res))
def test_overrideResolvConf(self): """ The I{resolvconf} parameter to L{client.createResolver} overrides the resolver configuration file used by the L{client.Resolver} in the L{resolve.ResolverChain} it returns. """ with AlternateReactor(Clock()): resolver = client.createResolver(resolvconf=b"/foo/bar") self._resolvConfTest(resolver, b"/foo/bar")
def test_defaultResolvConf(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{client.Resolver} using I{/etc/resolv.conf} if no alternate resolver configuration file is specified. """ with AlternateReactor(Clock()): resolver = client.createResolver() self._resolvConfTest(resolver, b"/etc/resolv.conf")
def test_overrideHosts(self): """ The I{hosts} parameter to L{client.createResolver} overrides the hosts file used by the L{hosts.Resolver} in the L{resolve.ResolverChain} it returns. """ with AlternateReactor(Clock()): resolver = client.createResolver(hosts=b"/foo/bar") self._hostsTest(resolver, b"/foo/bar")
def test_defaultHosts(self): """ L{client.createResolver} returns a L{resolve.ResolverChain} including a L{hosts.Resolver} using I{/etc/hosts} if no alternate hosts file is specified. """ with AlternateReactor(Clock()): resolver = client.createResolver() self._hostsTest(resolver, b"/etc/hosts")
def test_idempotent(self): """ Multiple calls to L{client.getResolver} return the same L{IResolver} implementation. """ with AlternateReactor(Clock()): a = client.getResolver() b = client.getResolver() self.assertIs(a, b)
def test_reactor(self): """ The L{client.Resolver} included in the L{resolve.ResolverChain} returned by L{client.createResolver} uses the global reactor. """ reactor = Clock() with AlternateReactor(reactor): resolver = client.createResolver() res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertIs(reactor, res[0]._reactor)
def _verify_error(self, config, expected): """ Assert that when ``DaemonizeTheRealService`` is started using the given configuration it writes the given message to stderr and stops the reactor. :param bytes config: The contents of a ``tahoe.cfg`` file to give to the service. :param bytes expected: A string to assert appears in stderr after the service starts. """ nodedir = FilePath(self.mktemp()) nodedir.makedirs() nodedir.child("tahoe.cfg").setContent(config.encode("ascii")) nodedir.child("tahoe-client.tac").touch() options = parse_options(["run", nodedir.path]) stdout = options.stdout = StringIO() stderr = options.stderr = StringIO() run_options = options.subOptions reactor = MemoryReactor() with AlternateReactor(reactor): service = DaemonizeTheRealService( "client", nodedir.path, run_options, ) service.startService() # We happen to know that the service uses reactor.callWhenRunning # to schedule all its work (though I couldn't tell you *why*). # Make sure those scheduled calls happen. waiting = reactor.whenRunningHooks[:] del reactor.whenRunningHooks[:] for f, a, k in waiting: f(*a, **k) self.assertThat( reactor.hasStopped, Equals(True), ) self.assertThat( stdout.getvalue(), Equals(""), ) self.assertThat( stderr.getvalue(), Contains(expected), )
def test_defaultServers(self): """ If no servers are given, addresses are taken from the file given by the I{resolvconf} parameter to L{client.createResolver}. """ resolvconf = self.path() resolvconf.setContent(b"nameserver 127.1.2.3\n") with AlternateReactor(Clock()): resolver = client.createResolver(resolvconf=resolvconf.path) res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual([], res[0].servers) self.assertEqual([("127.1.2.3", 53)], res[0].dynServers)
def test_overrideServers(self): """ Servers passed to L{client.createResolver} are used in addition to any found in the file given by the I{resolvconf} parameter. """ resolvconf = self.path() resolvconf.setContent(b"nameserver 127.1.2.3\n") with AlternateReactor(Clock()): resolver = client.createResolver(servers=[("127.3.2.1", 53)], resolvconf=resolvconf.path) res = [r for r in resolver.resolvers if isinstance(r, client.Resolver)] self.assertEqual(1, len(res)) self.assertEqual([("127.3.2.1", 53)], res[0].servers) self.assertEqual([("127.1.2.3", 53)], res[0].dynServers)