def test_boundedQueries(self):
"""
L{Resolver.lookupAddress} won't issue more queries following
delegations than the limit passed to its initializer.
"""
servers = {
("1.1.2.3", 53): {
# First query - force it to start over with a name lookup of
# ns1.example.com
(b"example.com", A): {
"authority":
[(b"example.com", Record_NS(b"ns1.example.com"))],
},
# Second query - let it resume the original lookup with the
# address of the nameserver handling the delegation.
(b"ns1.example.com", A): {
"answers": [(b"ns1.example.com", Record_A("10.0.0.2"))],
},
},
("10.0.0.2", 53): {
# Third query - let it jump straight to asking the
# delegation server by including its address here (different
# case from the first query).
(b"example.com", A): {
"authority":
[(b"example.com", Record_NS(b"ns2.example.com"))],
"additional": [(b"ns2.example.com", Record_A("10.0.0.3"))],
},
},
("10.0.0.3", 53): {
# Fourth query - give it the answer, we're done.
(b"example.com", A): {
"answers": [(b"example.com", Record_A("10.0.0.4"))],
},
},
}
# Make two resolvers. One which is allowed to make 3 queries
# maximum, and so will fail, and on which may make 4, and so should
# succeed.
failer = self._getResolver(servers, 3)
failD = self.assertFailure(failer.lookupAddress(b"example.com"),
ResolverError)
succeeder = self._getResolver(servers, 4)
succeedD = succeeder.lookupAddress(b"example.com")
succeedD.addCallback(getOnePayload)
succeedD.addCallback(self.assertEqual, Record_A("10.0.0.4"))
return gatherResults([failD, succeedD])
def test_lookupNameservers(self):
"""
L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except
it queries for I{NS} records instead of I{A} records.
"""
servers = {
("1.1.2.3", 53): {
(b"example.com", A): {
"rCode": ENAME,
},
(b"example.com", NS): {
"answers":
[(b"example.com", Record_NS(b"ns1.example.com"))],
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupNameservers(b"example.com")
def getOneName(results):
ans, auth, add = results
return ans[0].payload.name
d.addCallback(getOneName)
d.addCallback(self.assertEqual, Name(b"ns1.example.com"))
return d
def test_lookupChecksClass(self):
"""
If a response includes a record with a class different from the one
in the query, it is ignored and lookup continues until a record with
the right class is found.
"""
badClass = Record_A("10.0.0.1")
badClass.CLASS = HS
servers = {
("1.1.2.3", 53): {
(b"foo.example.com", A): {
"answers": [(b"foo.example.com", badClass)],
"authority":
[(b"foo.example.com", Record_NS(b"ns1.example.com"))],
"additional": [(b"ns1.example.com", Record_A("10.0.0.2"))],
},
},
("10.0.0.2", 53): {
(b"foo.example.com", A): {
"answers": [(b"foo.example.com", Record_A("10.0.0.3"))],
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b"foo.example.com")
d.addCallback(getOnePayload)
d.addCallback(self.assertEqual, Record_A("10.0.0.3"))
return d
def test_missingGlue(self):
"""
If an intermediate response includes no glue records for the
authorities, separate queries are made to find those addresses.
"""
servers = {
("1.1.2.3", 53): {
(b"foo.example.com", A): {
"authority":
[(b"foo.example.com", Record_NS(b"ns1.example.org"))],
# Conspicuous lack of an additional section naming ns1.example.com
},
(b"ns1.example.org", A): {
"answers": [(b"ns1.example.org", Record_A("10.0.0.1"))],
},
},
("10.0.0.1", 53): {
(b"foo.example.com", A): {
"answers": [(b"foo.example.com", Record_A("10.0.0.2"))],
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b"foo.example.com")
d.addCallback(getOneAddress)
d.addCallback(self.assertEqual, "10.0.0.2")
return d
def test_missingGlue(self):
"""
If an intermediate response includes no glue records for the
authorities, separate queries are made to find those addresses.
"""
servers = {
('1.1.2.3', 53): {
(b'foo.example.com', A): {
'authority':
[(b'foo.example.com', Record_NS(b'ns1.example.org'))],
# Conspicuous lack of an additional section naming ns1.example.com
},
(b'ns1.example.org', A): {
'answers': [(b'ns1.example.org', Record_A('10.0.0.1'))],
},
},
('10.0.0.1', 53): {
(b'foo.example.com', A): {
'answers': [(b'foo.example.com', Record_A('10.0.0.2'))],
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b'foo.example.com')
d.addCallback(getOneAddress)
d.addCallback(self.assertEqual, '10.0.0.2')
return d
def test_lookupAddress(self):
"""
L{root.Resolver.lookupAddress} looks up the I{A} records for the
specified hostname by first querying one of the root servers the
resolver was created with and then following the authority delegations
until a result is received.
"""
servers = {
("1.1.2.3", 53): {
(b"foo.example.com", A): {
"authority":
[(b"foo.example.com", Record_NS(b"ns1.example.com"))],
"additional":
[(b"ns1.example.com", Record_A("34.55.89.144"))],
},
},
("34.55.89.144", 53): {
(b"foo.example.com", A): {
"answers": [(b"foo.example.com", Record_A("10.0.0.1"))],
}
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b"foo.example.com")
d.addCallback(getOneAddress)
d.addCallback(self.assertEqual, "10.0.0.1")
return d
def test_lookupAddress(self):
"""
L{root.Resolver.lookupAddress} looks up the I{A} records for the
specified hostname by first querying one of the root servers the
resolver was created with and then following the authority delegations
until a result is received.
"""
servers = {
('1.1.2.3', 53): {
(b'foo.example.com', A): {
'authority':
[(b'foo.example.com', Record_NS(b'ns1.example.com'))],
'additional':
[(b'ns1.example.com', Record_A('34.55.89.144'))],
},
},
('34.55.89.144', 53): {
(b'foo.example.com', A): {
'answers': [(b'foo.example.com', Record_A('10.0.0.1'))],
}
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b'foo.example.com')
d.addCallback(getOneAddress)
d.addCallback(self.assertEqual, '10.0.0.1')
return d
def test_lookupChecksClass(self):
"""
If a response includes a record with a class different from the one
in the query, it is ignored and lookup continues until a record with
the right class is found.
"""
badClass = Record_A('10.0.0.1')
badClass.CLASS = HS
servers = {
('1.1.2.3', 53): {
('foo.example.com', A): {
'answers': [('foo.example.com', badClass)],
'authority':
[('foo.example.com', Record_NS('ns1.example.com'))],
'additional': [('ns1.example.com', Record_A('10.0.0.2'))],
},
},
('10.0.0.2', 53): {
('foo.example.com', A): {
'answers': [('foo.example.com', Record_A('10.0.0.3'))],
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress('foo.example.com')
d.addCallback(getOnePayload)
d.addCallback(self.assertEqual, Record_A('10.0.0.3'))
return d
def nameservers(host, *addresses):
"""
Return NS records and A record glue for the given host.
"""
if not addresses:
addresses = [dornkirk, ns2]
records = []
for i, addr in enumerate(addresses):
records.extend([
(host, Record_NS('ns%d.twistedmatrix.com' % (i + 1, ), ttl='1H')),
('ns%d.twistedmatrix.com' % (i + 1, ), Record_A(addr, ttl='1H'))
])
return records
def test_delegationLookupEmpty(self):
"""
If there are no records in the response to a lookup of a delegation
nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires
with L{ResolverError}.
"""
servers = {
("1.1.2.3", 53): {
(b"example.com", A): {
"authority": [(b"example.com", Record_NS(b"ns1.example.com"))],
},
(b"ns1.example.com", A): {},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b"example.com")
return self.assertFailure(d, ResolverError)
def test_delegationLookupError(self):
"""
If there is an error resolving the nameserver in a delegation response,
the L{Deferred} returned by L{Resolver.lookupAddress} fires with that
error.
"""
servers = {
('1.1.2.3', 53): {
('example.com', A): {
'authority': [('example.com', Record_NS('ns1.example.com'))],
},
('ns1.example.com', A): {
'rCode': ENAME,
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress('example.com')
return self.assertFailure(d, DNSNameError)
def test_delegationLookupError(self):
"""
If there is an error resolving the nameserver in a delegation response,
the L{Deferred} returned by L{Resolver.lookupAddress} fires with that
error.
"""
servers = {
("1.1.2.3", 53): {
(b"example.com", A): {
"authority": [(b"example.com", Record_NS(b"ns1.example.com"))],
},
(b"ns1.example.com", A): {
"rCode": ENAME,
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupAddress(b"example.com")
return self.assertFailure(d, DNSNameError)
def test_lookupNameservers(self):
"""
L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except
it queries for I{NS} records instead of I{A} records.
"""
servers = {
('1.1.2.3', 53): {
('example.com', A): {
'rCode': ENAME,
},
('example.com', NS): {
'answers': [('example.com', Record_NS('ns1.example.com'))],
},
},
}
resolver = self._getResolver(servers)
d = resolver.lookupNameservers('example.com')
d.addCallback(lambda (ans, auth, add): str(ans[0].payload.name))
d.addCallback(self.assertEquals, 'ns1.example.com')
return d
