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)
