mir/kea
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/kea synced 2025-08-30 13:37:55 +00:00
Code Issues Releases Wiki Activity

[1866] remove '()' from RCode/Opcode.XXX constants, making all tests pass now

Browse Source
This commit is contained in:
JINMEI Tatuya 2013-01-28 14:59:30 -08:00
parent 4f0716782c
commit d985d0dde4
17 changed files with 308 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/ddns/ddns.py.in
View File

@ -469,7 +469,7 @@ class DDNSServer:
self.__request_msg.clear(Message.PARSE) self.__request_msg.clear(Message.PARSE)
# specify PRESERVE_ORDER as we need to handle each RR separately. # specify PRESERVE_ORDER as we need to handle each RR separately.
self.__request_msg.from_wire(req_data, Message.PRESERVE_ORDER) self.__request_msg.from_wire(req_data, Message.PRESERVE_ORDER)
if self.__request_msg.get_opcode() != Opcode.UPDATE(): if self.__request_msg.get_opcode() != Opcode.UPDATE:
raise self.InternalError('Update request has unexpected ' raise self.InternalError('Update request has unexpected '
'opcode: ' + 'opcode: ' +
str(self.__request_msg.get_opcode())) str(self.__request_msg.get_opcode()))

22
src/bin/ddns/tests/ddns_test.py
View File

@ -169,9 +169,9 @@ class FakeUpdateSession:
self.__msg.make_response() self.__msg.make_response()
self.__msg.clear_section(SECTION_ZONE) self.__msg.clear_section(SECTION_ZONE)
if self.__faked_result == UPDATE_SUCCESS: if self.__faked_result == UPDATE_SUCCESS:
self.__msg.set_rcode(Rcode.NOERROR()) self.__msg.set_rcode(Rcode.NOERROR)
else: else:
self.__msg.set_rcode(Rcode.REFUSED()) self.__msg.set_rcode(Rcode.REFUSED)
return self.__msg return self.__msg
class FakeKeyringModule: class FakeKeyringModule:
@ -887,12 +887,12 @@ class TestDDNSServer(unittest.TestCase):
self.__select_answer = ([], [10], []) self.__select_answer = ([], [10], [])
self.assertRaises(KeyError, self.ddns_server.run) self.assertRaises(KeyError, self.ddns_server.run)
def create_msg(opcode=Opcode.UPDATE(), zones=[TEST_ZONE_RECORD], prereq=[], def create_msg(opcode=Opcode.UPDATE, zones=[TEST_ZONE_RECORD], prereq=[],
tsigctx=None): tsigctx=None):
msg = Message(Message.RENDER) msg = Message(Message.RENDER)
msg.set_qid(TEST_QID) msg.set_qid(TEST_QID)
msg.set_opcode(opcode) msg.set_opcode(opcode)
msg.set_rcode(Rcode.NOERROR()) msg.set_rcode(Rcode.NOERROR)
for z in zones: for z in zones:
msg.add_question(z) msg.add_question(z)
for p in prereq: for p in prereq:
@ -936,7 +936,7 @@ class TestDDNSSession(unittest.TestCase):
return FakeUpdateSession(req_message, client_addr, zone_config, return FakeUpdateSession(req_message, client_addr, zone_config,
self.__faked_result) self.__faked_result)
def check_update_response(self, resp_wire, expected_rcode=Rcode.NOERROR(), def check_update_response(self, resp_wire, expected_rcode=Rcode.NOERROR,
tsig_ctx=None, tcp=False): tsig_ctx=None, tcp=False):
'''Check if given wire data are valid form of update response. '''Check if given wire data are valid form of update response.
@ -963,7 +963,7 @@ class TestDDNSSession(unittest.TestCase):
self.assertNotEqual(None, tsig_record) self.assertNotEqual(None, tsig_record)
self.assertEqual(TSIGError.NOERROR, self.assertEqual(TSIGError.NOERROR,
tsig_ctx.verify(tsig_record, resp_wire)) tsig_ctx.verify(tsig_record, resp_wire))
self.assertEqual(Opcode.UPDATE(), msg.get_opcode()) self.assertEqual(Opcode.UPDATE, msg.get_opcode())
self.assertEqual(expected_rcode, msg.get_rcode()) self.assertEqual(expected_rcode, msg.get_rcode())
self.assertEqual(TEST_QID, msg.get_qid()) self.assertEqual(TEST_QID, msg.get_qid())
for section in [SECTION_ZONE, SECTION_PREREQUISITE, SECTION_UPDATE]: for section in [SECTION_ZONE, SECTION_PREREQUISITE, SECTION_UPDATE]:
@ -977,7 +977,7 @@ class TestDDNSSession(unittest.TestCase):
server_addr = TEST_SERVER6 if ipv6 else TEST_SERVER4 server_addr = TEST_SERVER6 if ipv6 else TEST_SERVER4
client_addr = TEST_CLIENT6 if ipv6 else TEST_CLIENT4 client_addr = TEST_CLIENT6 if ipv6 else TEST_CLIENT4
tsig = TSIGContext(tsig_key) if tsig_key is not None else None tsig = TSIGContext(tsig_key) if tsig_key is not None else None
rcode = Rcode.NOERROR() if result == UPDATE_SUCCESS else Rcode.REFUSED() rcode = Rcode.NOERROR if result == UPDATE_SUCCESS else Rcode.REFUSED
has_response = (result != UPDATE_DROP) has_response = (result != UPDATE_DROP)
self.assertEqual(has_response, self.assertEqual(has_response,
@ -1015,7 +1015,7 @@ class TestDDNSSession(unittest.TestCase):
# Opcode is not UPDATE # Opcode is not UPDATE
self.assertFalse(self.server.handle_request( self.assertFalse(self.server.handle_request(
(self.__sock, None, None, create_msg(opcode=Opcode.QUERY())))) (self.__sock, None, None, create_msg(opcode=Opcode.QUERY))))
self.assertEqual((None, None), (s._sent_data, s._sent_addr)) self.assertEqual((None, None), (s._sent_data, s._sent_addr))
# TSIG verification error. We use UPDATE_DROP to signal check_session # TSIG verification error. We use UPDATE_DROP to signal check_session
@ -1031,7 +1031,7 @@ class TestDDNSSession(unittest.TestCase):
TEST_CLIENT6, TEST_CLIENT6,
create_msg()))) create_msg())))
# this check ensures sendto() was really attempted. # this check ensures sendto() was really attempted.
self.check_update_response(self.__sock._sent_data, Rcode.NOERROR()) self.check_update_response(self.__sock._sent_data, Rcode.NOERROR)
def test_tcp_request(self): def test_tcp_request(self):
# A simple case using TCP: all resopnse data are sent out at once. # A simple case using TCP: all resopnse data are sent out at once.
@ -1040,7 +1040,7 @@ class TestDDNSSession(unittest.TestCase):
self.assertTrue(self.server.handle_request((s, TEST_SERVER6, self.assertTrue(self.server.handle_request((s, TEST_SERVER6,
TEST_CLIENT6, TEST_CLIENT6,
create_msg()))) create_msg())))
self.check_update_response(s._sent_data, Rcode.NOERROR(), tcp=True) self.check_update_response(s._sent_data, Rcode.NOERROR, tcp=True)
# In the current implementation, the socket should be closed # In the current implementation, the socket should be closed
# immedidately after a successful send. # immedidately after a successful send.
self.assertEqual(1, s._close_called) self.assertEqual(1, s._close_called)
@ -1071,7 +1071,7 @@ class TestDDNSSession(unittest.TestCase):
s.make_send_ready() s.make_send_ready()
self.assertEqual(DNSTCPContext.SEND_DONE, self.assertEqual(DNSTCPContext.SEND_DONE,
self.server._tcp_ctxs[s.fileno()][0].send_ready()) self.server._tcp_ctxs[s.fileno()][0].send_ready())
self.check_update_response(s._sent_data, Rcode.NOERROR(), tcp=True) self.check_update_response(s._sent_data, Rcode.NOERROR, tcp=True)
def test_tcp_request_error(self): def test_tcp_request_error(self):
# initial send() on the TCP socket will fail. The request handling # initial send() on the TCP socket will fail. The request handling

20
src/bin/xfrin/tests/xfrin_test.py
View File

@ -317,7 +317,7 @@ class MockXfrinConnection(XfrinConnection):
return len(data) return len(data)
def create_response_data(self, response=True, auth=True, bad_qid=False, def create_response_data(self, response=True, auth=True, bad_qid=False,
rcode=Rcode.NOERROR(), rcode=Rcode.NOERROR,
questions=default_questions, questions=default_questions,
answers=default_answers, answers=default_answers,
authorities=[], authorities=[],
@ -327,7 +327,7 @@ class MockXfrinConnection(XfrinConnection):
if bad_qid: if bad_qid:
qid += 1 qid += 1
resp.set_qid(qid) resp.set_qid(qid)
resp.set_opcode(Opcode.QUERY()) resp.set_opcode(Opcode.QUERY)
resp.set_rcode(rcode) resp.set_rcode(rcode)
if response: if response:
resp.set_header_flag(Message.HEADERFLAG_QR) resp.set_header_flag(Message.HEADERFLAG_QR)
@ -712,7 +712,7 @@ class TestXfrinConnection(unittest.TestCase):
'bad_qid': False, 'bad_qid': False,
'response': True, 'response': True,
'auth': True, 'auth': True,
'rcode': Rcode.NOERROR(), 'rcode': Rcode.NOERROR,
'answers': default_answers, 'answers': default_answers,
'authorities': [], 'authorities': [],
'tsig': False, 'tsig': False,
@ -881,8 +881,8 @@ class TestAXFR(TestXfrinConnection):
def test_create_query(self): def test_create_query(self):
def check_query(expected_qtype, expected_auth): def check_query(expected_qtype, expected_auth):
'''Helper method to repeat the same pattern of tests''' '''Helper method to repeat the same pattern of tests'''
self.assertEqual(Opcode.QUERY(), msg.get_opcode()) self.assertEqual(Opcode.QUERY, msg.get_opcode())
self.assertEqual(Rcode.NOERROR(), msg.get_rcode()) self.assertEqual(Rcode.NOERROR, msg.get_rcode())
self.assertEqual(1, msg.get_rr_count(Message.SECTION_QUESTION)) self.assertEqual(1, msg.get_rr_count(Message.SECTION_QUESTION))
self.assertEqual(TEST_ZONE_NAME, msg.get_question()[0].get_name()) self.assertEqual(TEST_ZONE_NAME, msg.get_question()[0].get_name())
self.assertEqual(expected_qtype, msg.get_question()[0].get_type()) self.assertEqual(expected_qtype, msg.get_question()[0].get_type())
@ -968,7 +968,7 @@ class TestAXFR(TestXfrinConnection):
# server tsig check fail, return with RCODE 9 (NOTAUTH) # server tsig check fail, return with RCODE 9 (NOTAUTH)
self.conn._send_query(RRType.SOA) self.conn._send_query(RRType.SOA)
self.conn.reply_data = \ self.conn.reply_data = \
self.conn.create_response_data(rcode=Rcode.NOTAUTH()) self.conn.create_response_data(rcode=Rcode.NOTAUTH)
self.assertRaises(XfrinProtocolError, self.assertRaises(XfrinProtocolError,
self.conn._handle_xfrin_responses) self.conn._handle_xfrin_responses)
@ -992,7 +992,7 @@ class TestAXFR(TestXfrinConnection):
lambda key: self.__create_mock_tsig(key, TSIGError.BAD_SIG) lambda key: self.__create_mock_tsig(key, TSIGError.BAD_SIG)
self.conn._send_query(RRType.AXFR) self.conn._send_query(RRType.AXFR)
self.conn.reply_data = self.conn.create_response_data( self.conn.reply_data = self.conn.create_response_data(
rcode=Rcode.SERVFAIL()) rcode=Rcode.SERVFAIL)
# xfrin should check TSIG before other part of incoming message # xfrin should check TSIG before other part of incoming message
# validate log message for XfrinException # validate log message for XfrinException
self.__match_exception(XfrinProtocolError, self.__match_exception(XfrinProtocolError,
@ -1019,7 +1019,7 @@ class TestAXFR(TestXfrinConnection):
def test_response_error_code(self): def test_response_error_code(self):
self.conn._send_query(RRType.AXFR) self.conn._send_query(RRType.AXFR)
self.conn.reply_data = self.conn.create_response_data( self.conn.reply_data = self.conn.create_response_data(
rcode=Rcode.SERVFAIL()) rcode=Rcode.SERVFAIL)
self.assertRaises(XfrinProtocolError, self.assertRaises(XfrinProtocolError,
self.conn._handle_xfrin_responses) self.conn._handle_xfrin_responses)
@ -1069,7 +1069,7 @@ class TestAXFR(TestXfrinConnection):
self.assertRaises(XfrinProtocolError, self.conn._check_soa_serial) self.assertRaises(XfrinProtocolError, self.conn._check_soa_serial)
def test_soacheck_error_code(self): def test_soacheck_error_code(self):
self.soa_response_params['rcode'] = Rcode.SERVFAIL() self.soa_response_params['rcode'] = Rcode.SERVFAIL
self.conn.response_generator = self._create_soa_response_data self.conn.response_generator = self._create_soa_response_data
self.assertRaises(XfrinProtocolError, self.conn._check_soa_serial) self.assertRaises(XfrinProtocolError, self.conn._check_soa_serial)
@ -1191,7 +1191,7 @@ class TestAXFR(TestXfrinConnection):
self.conn._tsig_key = TSIG_KEY self.conn._tsig_key = TSIG_KEY
self.conn._tsig_ctx_creator = \ self.conn._tsig_ctx_creator = \
lambda key: self.__create_mock_tsig(key, TSIGError.BAD_SIG) lambda key: self.__create_mock_tsig(key, TSIGError.BAD_SIG)
self.soa_response_params['rcode'] = Rcode.NOTAUTH() self.soa_response_params['rcode'] = Rcode.NOTAUTH
self.conn.response_generator = self._create_soa_response_data self.conn.response_generator = self._create_soa_response_data
self.assertRaises(XfrinProtocolError, self.conn._check_soa_serial) self.assertRaises(XfrinProtocolError, self.conn._check_soa_serial)

6
src/bin/xfrin/xfrin.py.in
View File

@ -715,8 +715,8 @@ class XfrinConnection(asyncore.dispatcher):
query_id = random.randint(0, 0xFFFF) query_id = random.randint(0, 0xFFFF)
self._query_id = query_id self._query_id = query_id
msg.set_qid(query_id) msg.set_qid(query_id)
msg.set_opcode(Opcode.QUERY()) msg.set_opcode(Opcode.QUERY)
msg.set_rcode(Rcode.NOERROR()) msg.set_rcode(Rcode.NOERROR)
msg.add_question(Question(self._zone_name, self._rrclass, query_type)) msg.add_question(Question(self._zone_name, self._rrclass, query_type))
# Remember our serial, if known # Remember our serial, if known
@ -992,7 +992,7 @@ class XfrinConnection(asyncore.dispatcher):
# cause interoperability trouble with stricter checks. # cause interoperability trouble with stricter checks.
msg_rcode = msg.get_rcode() msg_rcode = msg.get_rcode()
if msg_rcode != Rcode.NOERROR(): if msg_rcode != Rcode.NOERROR:
raise XfrinProtocolError('error response: %s' % raise XfrinProtocolError('error response: %s' %
msg_rcode.to_text()) msg_rcode.to_text())

56
src/bin/xfrout/tests/xfrout_test.py.in
View File

@ -238,8 +238,8 @@ class TestXfroutSessionBase(unittest.TestCase):
msg = Message(Message.RENDER) msg = Message(Message.RENDER)
query_id = 0x1035 query_id = 0x1035
msg.set_qid(query_id) msg.set_qid(query_id)
msg.set_opcode(Opcode.QUERY()) msg.set_opcode(Opcode.QUERY)
msg.set_rcode(Rcode.NOERROR()) msg.set_rcode(Rcode.NOERROR)
req_type = RRType.AXFR if ixfr is None else RRType.IXFR req_type = RRType.AXFR if ixfr is None else RRType.IXFR
if with_question: if with_question:
msg.add_question(Question(zone_name, RRClass.IN, msg.add_question(Question(zone_name, RRClass.IN,
@ -342,7 +342,7 @@ class TestXfroutSession(TestXfroutSessionBase):
self.xfrsess._request_data = self.mdata self.xfrsess._request_data = self.mdata
self.xfrsess._server.increase_transfers_counter = lambda : False self.xfrsess._server.increase_transfers_counter = lambda : False
XfroutSession._handle(self.xfrsess) XfroutSession._handle(self.xfrsess)
self.assertEqual(self.sock.read_msg().get_rcode(), Rcode.REFUSED()) self.assertEqual(self.sock.read_msg().get_rcode(), Rcode.REFUSED)
def test_quota_ok(self): def test_quota_ok(self):
'''The default case in terms of the xfrout quota. '''The default case in terms of the xfrout quota.
@ -355,7 +355,7 @@ class TestXfroutSession(TestXfroutSessionBase):
# Replace the data source client to avoid datasrc related exceptions # Replace the data source client to avoid datasrc related exceptions
self.xfrsess.ClientClass = MockDataSrcClient self.xfrsess.ClientClass = MockDataSrcClient
XfroutSession._handle(self.xfrsess) XfroutSession._handle(self.xfrsess)
self.assertEqual(self.sock.read_msg().get_rcode(), Rcode.FORMERR()) self.assertEqual(self.sock.read_msg().get_rcode(), Rcode.FORMERR)
def test_exception_from_session(self): def test_exception_from_session(self):
'''Test the case where the main processing raises an exception. '''Test the case where the main processing raises an exception.
@ -379,7 +379,7 @@ class TestXfroutSession(TestXfroutSessionBase):
request_data = self.create_request_data(ixfr=2011111801) request_data = self.create_request_data(ixfr=2011111801)
rcode, msg = self.xfrsess._parse_query_message(request_data) rcode, msg = self.xfrsess._parse_query_message(request_data)
self.assertEqual(RRType.IXFR, self.xfrsess._request_type) self.assertEqual(RRType.IXFR, self.xfrsess._request_type)
self.assertEqual(Rcode.NOERROR(), rcode) self.assertEqual(Rcode.NOERROR, rcode)
# Broken request: no question # Broken request: no question
self.assertRaises(RuntimeError, self.xfrsess._parse_query_message, self.assertRaises(RuntimeError, self.xfrsess._parse_query_message,
@ -759,19 +759,19 @@ class TestXfroutSession(TestXfroutSessionBase):
self.xfrsess.ClientClass = MockDataSrcClient self.xfrsess.ClientClass = MockDataSrcClient
# Successful case. A zone iterator should be set up. # Successful case. A zone iterator should be set up.
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR)
self.assertNotEqual(None, self.xfrsess._iterator) self.assertNotEqual(None, self.xfrsess._iterator)
# Failure cases # Failure cases
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), Name('notauth.example.com'), TEST_RRCLASS), self.getmsg(), Name('notauth.example.com'), TEST_RRCLASS),
Rcode.NOTAUTH()) Rcode.NOTAUTH)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), Name('nosoa.example.com'), TEST_RRCLASS), self.getmsg(), Name('nosoa.example.com'), TEST_RRCLASS),
Rcode.SERVFAIL()) Rcode.SERVFAIL)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), Name('multisoa.example.com'), TEST_RRCLASS), self.getmsg(), Name('multisoa.example.com'), TEST_RRCLASS),
Rcode.SERVFAIL()) Rcode.SERVFAIL)
def test_xfrout_ixfr_setup(self): def test_xfrout_ixfr_setup(self):
self.xfrsess.ClientClass = MockDataSrcClient self.xfrsess.ClientClass = MockDataSrcClient
@ -781,14 +781,14 @@ class TestXfroutSession(TestXfroutSessionBase):
# up. # up.
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION) self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR)
self.assertNotEqual(None, self.xfrsess._jnl_reader) self.assertNotEqual(None, self.xfrsess._jnl_reader)
# Successful case, but as a result of falling back to AXFR-style # Successful case, but as a result of falling back to AXFR-style
# IXFR. A zone iterator should be set up instead of a journal reader. # IXFR. A zone iterator should be set up instead of a journal reader.
self.mdata = self.create_request_data(ixfr=IXFR_NG_VERSION) self.mdata = self.create_request_data(ixfr=IXFR_NG_VERSION)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR)
self.assertNotEqual(None, self.xfrsess._iterator) self.assertNotEqual(None, self.xfrsess._iterator)
self.assertEqual(None, self.xfrsess._jnl_reader) self.assertEqual(None, self.xfrsess._jnl_reader)
@ -797,7 +797,7 @@ class TestXfroutSession(TestXfroutSessionBase):
# indicating that the response will contain just one SOA. # indicating that the response will contain just one SOA.
self.mdata = self.create_request_data(ixfr=SOA_CURRENT_VERSION+1) self.mdata = self.create_request_data(ixfr=SOA_CURRENT_VERSION+1)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR)
self.assertEqual(None, self.xfrsess._iterator) self.assertEqual(None, self.xfrsess._iterator)
self.assertEqual(None, self.xfrsess._jnl_reader) self.assertEqual(None, self.xfrsess._jnl_reader)
@ -805,7 +805,7 @@ class TestXfroutSession(TestXfroutSessionBase):
# the local SOA. # the local SOA.
self.mdata = self.create_request_data(ixfr=SOA_CURRENT_VERSION) self.mdata = self.create_request_data(ixfr=SOA_CURRENT_VERSION)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), TEST_ZONE_NAME, TEST_RRCLASS), Rcode.NOERROR)
self.assertEqual(None, self.xfrsess._iterator) self.assertEqual(None, self.xfrsess._iterator)
self.assertEqual(None, self.xfrsess._jnl_reader) self.assertEqual(None, self.xfrsess._jnl_reader)
@ -814,7 +814,7 @@ class TestXfroutSession(TestXfroutSessionBase):
zone_name = Name('maxserial.example.com') # whose SOA is 0xffffffff zone_name = Name('maxserial.example.com') # whose SOA is 0xffffffff
self.mdata = self.create_request_data(ixfr=1, zone_name=zone_name) self.mdata = self.create_request_data(ixfr=1, zone_name=zone_name)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOERROR)
self.assertEqual(None, self.xfrsess._iterator) self.assertEqual(None, self.xfrsess._iterator)
self.assertEqual(None, self.xfrsess._jnl_reader) self.assertEqual(None, self.xfrsess._jnl_reader)
@ -823,7 +823,7 @@ class TestXfroutSession(TestXfroutSessionBase):
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
zone_name=zone_name) zone_name=zone_name)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOERROR()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOERROR)
self.assertNotEqual(None, self.xfrsess._iterator) self.assertNotEqual(None, self.xfrsess._iterator)
# Failure cases # Failure cases
@ -831,42 +831,42 @@ class TestXfroutSession(TestXfroutSessionBase):
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
zone_name=zone_name) zone_name=zone_name)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOTAUTH()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOTAUTH)
# this is a strange case: zone's SOA will be found but the journal # this is a strange case: zone's SOA will be found but the journal
# reader won't be created due to 'no such zone'. # reader won't be created due to 'no such zone'.
zone_name = Name('notauth2.example.com') zone_name = Name('notauth2.example.com')
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
zone_name=zone_name) zone_name=zone_name)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOTAUTH()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.NOTAUTH)
zone_name = Name('nosoa.example.com') zone_name = Name('nosoa.example.com')
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
zone_name=zone_name) zone_name=zone_name)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.SERVFAIL()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.SERVFAIL)
zone_name = Name('multisoa.example.com') zone_name = Name('multisoa.example.com')
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
zone_name=zone_name) zone_name=zone_name)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.SERVFAIL()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.SERVFAIL)
# query name doesn't match the SOA's owner # query name doesn't match the SOA's owner
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION) self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.FORMERR()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.FORMERR)
# query's RR class doesn't match the SOA's class # query's RR class doesn't match the SOA's class
zone_name = TEST_ZONE_NAME # make sure the name matches this time zone_name = TEST_ZONE_NAME # make sure the name matches this time
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
soa_class=RRClass.CH) soa_class=RRClass.CH)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.FORMERR()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.FORMERR)
# multiple SOA RRs # multiple SOA RRs
self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION, self.mdata = self.create_request_data(ixfr=IXFR_OK_VERSION,
num_soa=2) num_soa=2)
self.assertEqual(self.xfrsess._xfrout_setup( self.assertEqual(self.xfrsess._xfrout_setup(
self.getmsg(), zone_name, TEST_RRCLASS), Rcode.FORMERR()) self.getmsg(), zone_name, TEST_RRCLASS), Rcode.FORMERR)
def test_dns_xfrout_start_formerror(self): def test_dns_xfrout_start_formerror(self):
# formerror # formerror
@ -876,7 +876,7 @@ class TestXfroutSession(TestXfroutSessionBase):
def test_dns_xfrout_start_notauth(self): def test_dns_xfrout_start_notauth(self):
def notauth(msg, name, rrclass): def notauth(msg, name, rrclass):
return Rcode.NOTAUTH() return Rcode.NOTAUTH
self.xfrsess._xfrout_setup = notauth self.xfrsess._xfrout_setup = notauth
self.xfrsess.dns_xfrout_start(self.sock, self.mdata) self.xfrsess.dns_xfrout_start(self.sock, self.mdata)
get_msg = self.sock.read_msg() get_msg = self.sock.read_msg()
@ -887,11 +887,11 @@ class TestXfroutSession(TestXfroutSessionBase):
raise isc.datasrc.Error('exception for the sake of test') raise isc.datasrc.Error('exception for the sake of test')
self.xfrsess.ClientClass = internal_raise self.xfrsess.ClientClass = internal_raise
self.xfrsess.dns_xfrout_start(self.sock, self.mdata) self.xfrsess.dns_xfrout_start(self.sock, self.mdata)
self.assertEqual(self.sock.read_msg().get_rcode(), Rcode.SERVFAIL()) self.assertEqual(self.sock.read_msg().get_rcode(), Rcode.SERVFAIL)
def test_dns_xfrout_start_noerror(self): def test_dns_xfrout_start_noerror(self):
def noerror(msg, name, rrclass): def noerror(msg, name, rrclass):
return Rcode.NOERROR() return Rcode.NOERROR
self.xfrsess._xfrout_setup = noerror self.xfrsess._xfrout_setup = noerror
def myreply(msg, sock): def myreply(msg, sock):
@ -905,7 +905,7 @@ class TestXfroutSession(TestXfroutSessionBase):
def test_dns_xfrout_start_with_notcallable_xfrreqdone(self): def test_dns_xfrout_start_with_notcallable_xfrreqdone(self):
def noerror(msg, name, rrclass): def noerror(msg, name, rrclass):
return Rcode.NOERROR() return Rcode.NOERROR
self.xfrsess._xfrout_setup = noerror self.xfrsess._xfrout_setup = noerror
def myreply(msg, sock): def myreply(msg, sock):
@ -1177,7 +1177,7 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
self.assertEqual(self.get_counter('ixfr_ended'), 0) self.assertEqual(self.get_counter('ixfr_ended'), 0)
XfroutSession._handle(self.xfrsess) XfroutSession._handle(self.xfrsess)
response = self.sock.read_msg(Message.PRESERVE_ORDER); response = self.sock.read_msg(Message.PRESERVE_ORDER);
self.assertEqual(Rcode.NOERROR(), response.get_rcode()) self.assertEqual(Rcode.NOERROR, response.get_rcode())
self.check_axfr_stream(response) self.check_axfr_stream(response)
self.assertEqual(self.xfrsess._request_type, RRType.AXFR) self.assertEqual(self.xfrsess._request_type, RRType.AXFR)
self.assertNotEqual(self.xfrsess._request_type, RRType.IXFR) self.assertNotEqual(self.xfrsess._request_type, RRType.IXFR)
@ -1191,7 +1191,7 @@ class TestXfroutSessionWithSQLite3(TestXfroutSessionBase):
self.create_request_data(ixfr=IXFR_NG_VERSION) self.create_request_data(ixfr=IXFR_NG_VERSION)
XfroutSession._handle(self.xfrsess) XfroutSession._handle(self.xfrsess)
response = self.sock.read_msg(Message.PRESERVE_ORDER); response = self.sock.read_msg(Message.PRESERVE_ORDER);
self.assertEqual(Rcode.NOERROR(), response.get_rcode()) self.assertEqual(Rcode.NOERROR, response.get_rcode())
# This is an AXFR-style IXFR. So the question section should indicate # This is an AXFR-style IXFR. So the question section should indicate
# that it's an IXFR resposne. # that it's an IXFR resposne.
self.assertEqual(RRType.IXFR, response.get_question()[0].get_type()) self.assertEqual(RRType.IXFR, response.get_question()[0].get_type())

48
src/bin/xfrout/xfrout.py.in
View File

@ -227,9 +227,9 @@ class XfroutSession():
self._tsig_key_ring) self._tsig_key_ring)
tsig_error = self._tsig_ctx.verify(tsig_record, request_data) tsig_error = self._tsig_ctx.verify(tsig_record, request_data)
if tsig_error != TSIGError.NOERROR: if tsig_error != TSIGError.NOERROR:
return Rcode.NOTAUTH() return Rcode.NOTAUTH
return Rcode.NOERROR() return Rcode.NOERROR
def _parse_query_message(self, mdata): def _parse_query_message(self, mdata):
''' parse query message to [socket,message]''' ''' parse query message to [socket,message]'''
@ -239,11 +239,11 @@ class XfroutSession():
Message.from_wire(msg, mdata) Message.from_wire(msg, mdata)
except Exception as err: # Exception is too broad except Exception as err: # Exception is too broad
logger.error(XFROUT_PARSE_QUERY_ERROR, err) logger.error(XFROUT_PARSE_QUERY_ERROR, err)
return Rcode.FORMERR(), None return Rcode.FORMERR, None
# TSIG related checks # TSIG related checks
rcode = self._check_request_tsig(msg, mdata) rcode = self._check_request_tsig(msg, mdata)
if rcode != Rcode.NOERROR(): if rcode != Rcode.NOERROR:
return rcode, msg return rcode, msg
# Make sure the question is valid. This should be ensured by # Make sure the question is valid. This should be ensured by
@ -283,7 +283,7 @@ class XfroutSession():
logger.debug(DBG_XFROUT_TRACE, XFROUT_QUERY_REJECTED, logger.debug(DBG_XFROUT_TRACE, XFROUT_QUERY_REJECTED,
self._request_type, format_addrinfo(self._remote), self._request_type, format_addrinfo(self._remote),
format_zone_str(zone_name, zone_class)) format_zone_str(zone_name, zone_class))
return Rcode.REFUSED(), msg return Rcode.REFUSED, msg
return rcode, msg return rcode, msg
@ -351,16 +351,16 @@ class XfroutSession():
''' '''
result, finder = self._datasrc_client.find_zone(zone_name) result, finder = self._datasrc_client.find_zone(zone_name)
if result != DataSourceClient.SUCCESS: if result != DataSourceClient.SUCCESS:
return (Rcode.NOTAUTH(), None) return (Rcode.NOTAUTH, None)
result, soa_rrset, _ = finder.find(zone_name, RRType.SOA) result, soa_rrset, _ = finder.find(zone_name, RRType.SOA)
if result != ZoneFinder.SUCCESS: if result != ZoneFinder.SUCCESS:
return (Rcode.SERVFAIL(), None) return (Rcode.SERVFAIL, None)
# Especially for database-based zones, a working zone may be in # Especially for database-based zones, a working zone may be in
# a broken state where it has more than one SOA RR. We proactively # a broken state where it has more than one SOA RR. We proactively
# check the condition and abort the xfr attempt if we identify it. # check the condition and abort the xfr attempt if we identify it.
if soa_rrset.get_rdata_count() != 1: if soa_rrset.get_rdata_count() != 1:
return (Rcode.SERVFAIL(), None) return (Rcode.SERVFAIL, None)
return (Rcode.NOERROR(), soa_rrset) return (Rcode.NOERROR, soa_rrset)
def __axfr_setup(self, zone_name): def __axfr_setup(self, zone_name):
'''Setup a zone iterator for AXFR or AXFR-style IXFR. '''Setup a zone iterator for AXFR or AXFR-style IXFR.
@ -379,16 +379,16 @@ class XfroutSession():
# update get_iterator() API so that we can distinguish "no such # update get_iterator() API so that we can distinguish "no such
# zone" and other cases (#1373). For now we consider all these # zone" and other cases (#1373). For now we consider all these
# cases as NOTAUTH. # cases as NOTAUTH.
return Rcode.NOTAUTH() return Rcode.NOTAUTH
# If we are an authoritative name server for the zone, but fail # If we are an authoritative name server for the zone, but fail
# to find the zone's SOA record in datasource, xfrout can't # to find the zone's SOA record in datasource, xfrout can't
# provide zone transfer for it. # provide zone transfer for it.
self._soa = self._iterator.get_soa() self._soa = self._iterator.get_soa()
if self._soa is None or self._soa.get_rdata_count() != 1: if self._soa is None or self._soa.get_rdata_count() != 1:
return Rcode.SERVFAIL() return Rcode.SERVFAIL
return Rcode.NOERROR() return Rcode.NOERROR
def __ixfr_setup(self, request_msg, zone_name, zone_class): def __ixfr_setup(self, request_msg, zone_name, zone_class):
'''Setup a zone journal reader for IXFR. '''Setup a zone journal reader for IXFR.
@ -411,15 +411,15 @@ class XfroutSession():
if auth_rrset.get_rdata_count() != 1: if auth_rrset.get_rdata_count() != 1:
logger.info(XFROUT_IXFR_MULTIPLE_SOA, logger.info(XFROUT_IXFR_MULTIPLE_SOA,
format_addrinfo(self._remote)) format_addrinfo(self._remote))
return Rcode.FORMERR() return Rcode.FORMERR
remote_soa = auth_rrset remote_soa = auth_rrset
if remote_soa is None: if remote_soa is None:
logger.info(XFROUT_IXFR_NO_SOA, format_addrinfo(self._remote)) logger.info(XFROUT_IXFR_NO_SOA, format_addrinfo(self._remote))
return Rcode.FORMERR() return Rcode.FORMERR
# Retrieve the local SOA # Retrieve the local SOA
rcode, self._soa = self._get_zone_soa(zone_name) rcode, self._soa = self._get_zone_soa(zone_name)
if rcode != Rcode.NOERROR(): if rcode != Rcode.NOERROR:
return rcode return rcode
# RFC1995 says "If an IXFR query with the same or newer version # RFC1995 says "If an IXFR query with the same or newer version
@ -437,7 +437,7 @@ class XfroutSession():
logger.info(XFROUT_IXFR_UPTODATE, format_addrinfo(self._remote), logger.info(XFROUT_IXFR_UPTODATE, format_addrinfo(self._remote),
format_zone_str(zone_name, zone_class), format_zone_str(zone_name, zone_class),
begin_serial, end_serial) begin_serial, end_serial)
return Rcode.NOERROR() return Rcode.NOERROR
# Set up the journal reader or fall back to AXFR-style IXFR # Set up the journal reader or fall back to AXFR-style IXFR
try: try:
@ -462,12 +462,12 @@ class XfroutSession():
# between these two operations. We treat it as NOTAUTH. # between these two operations. We treat it as NOTAUTH.
logger.warn(XFROUT_IXFR_NO_ZONE, format_addrinfo(self._remote), logger.warn(XFROUT_IXFR_NO_ZONE, format_addrinfo(self._remote),
format_zone_str(zone_name, zone_class)) format_zone_str(zone_name, zone_class))
return Rcode.NOTAUTH() return Rcode.NOTAUTH
# Use the reader as the iterator to generate the response. # Use the reader as the iterator to generate the response.
self._iterator = self._jnl_reader self._iterator = self._jnl_reader
return Rcode.NOERROR() return Rcode.NOERROR
def _xfrout_setup(self, request_msg, zone_name, zone_class): def _xfrout_setup(self, request_msg, zone_name, zone_class):
'''Setup a context for xfr responses according to the request type. '''Setup a context for xfr responses according to the request type.
@ -500,17 +500,17 @@ class XfroutSession():
#TODO. create query message and parse header #TODO. create query message and parse header
if rcode_ is None: # Dropped by ACL if rcode_ is None: # Dropped by ACL
return return
elif rcode_ == Rcode.NOTAUTH() or rcode_ == Rcode.REFUSED(): elif rcode_ == Rcode.NOTAUTH or rcode_ == Rcode.REFUSED:
return self._reply_query_with_error_rcode(msg, sock_fd, rcode_) return self._reply_query_with_error_rcode(msg, sock_fd, rcode_)
elif rcode_ != Rcode.NOERROR(): elif rcode_ != Rcode.NOERROR:
return self._reply_query_with_error_rcode(msg, sock_fd, return self._reply_query_with_error_rcode(msg, sock_fd,
Rcode.FORMERR()) Rcode.FORMERR)
elif not quota_ok: elif not quota_ok:
logger.warn(XFROUT_QUERY_QUOTA_EXCCEEDED, self._request_typestr, logger.warn(XFROUT_QUERY_QUOTA_EXCCEEDED, self._request_typestr,
format_addrinfo(self._remote), format_addrinfo(self._remote),
self._server._max_transfers_out) self._server._max_transfers_out)
return self._reply_query_with_error_rcode(msg, sock_fd, return self._reply_query_with_error_rcode(msg, sock_fd,
Rcode.REFUSED()) Rcode.REFUSED)
question = msg.get_question()[0] question = msg.get_question()[0]
zone_name = question.get_name() zone_name = question.get_name()
@ -522,8 +522,8 @@ class XfroutSession():
except Exception as ex: except Exception as ex:
logger.error(XFROUT_XFR_TRANSFER_CHECK_ERROR, self._request_typestr, logger.error(XFROUT_XFR_TRANSFER_CHECK_ERROR, self._request_typestr,
format_addrinfo(self._remote), zone_str, ex) format_addrinfo(self._remote), zone_str, ex)
rcode_ = Rcode.SERVFAIL() rcode_ = Rcode.SERVFAIL
if rcode_ != Rcode.NOERROR(): if rcode_ != Rcode.NOERROR:
logger.info(XFROUT_XFR_TRANSFER_FAILED, self._request_typestr, logger.info(XFROUT_XFR_TRANSFER_FAILED, self._request_typestr,
format_addrinfo(self._remote), zone_str, rcode_) format_addrinfo(self._remote), zone_str, rcode_)
return self._reply_query_with_error_rcode(msg, sock_fd, rcode_) return self._reply_query_with_error_rcode(msg, sock_fd, rcode_)

6
src/lib/dns/python/tests/edns_python_test.py
View File

@ -108,8 +108,8 @@ class EDNSTest(unittest.TestCase):
def test_towire_renderer(self): def test_towire_renderer(self):
renderer = MessageRenderer() renderer = MessageRenderer()
extrcode_noerror = Rcode.NOERROR().get_extended_code() extrcode_noerror = Rcode.NOERROR.get_extended_code()
extrcode_badvers = Rcode.BADVERS().get_extended_code() extrcode_badvers = Rcode.BADVERS.get_extended_code()
self.assertEqual(1, self.edns_base.to_wire(renderer, extrcode_noerror)) self.assertEqual(1, self.edns_base.to_wire(renderer, extrcode_noerror))
wiredata = read_wire_data("edns_toWire1.wire") wiredata = read_wire_data("edns_toWire1.wire")
@ -148,7 +148,7 @@ class EDNSTest(unittest.TestCase):
self.assertEqual(0, renderer.get_length()) self.assertEqual(0, renderer.get_length())
def test_towire_buffer(self): def test_towire_buffer(self):
extrcode_noerror = Rcode.NOERROR().get_extended_code() extrcode_noerror = Rcode.NOERROR.get_extended_code()
obuffer = bytes() obuffer = bytes()
obuffer = self.edns_base.to_wire(obuffer, extrcode_noerror) obuffer = self.edns_base.to_wire(obuffer, extrcode_noerror)

30
src/lib/dns/python/tests/message_python_test.py
View File

@ -59,8 +59,8 @@ LONG_TXT4 = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef012
def create_message(): def create_message():
message_render = Message(Message.RENDER) message_render = Message(Message.RENDER)
message_render.set_qid(0x1035) message_render.set_qid(0x1035)
message_render.set_opcode(Opcode.QUERY()) message_render.set_opcode(Opcode.QUERY)
message_render.set_rcode(Rcode.NOERROR()) message_render.set_rcode(Rcode.NOERROR)
message_render.set_header_flag(Message.HEADERFLAG_QR) message_render.set_header_flag(Message.HEADERFLAG_QR)
message_render.set_header_flag(Message.HEADERFLAG_RD) message_render.set_header_flag(Message.HEADERFLAG_RD)
message_render.set_header_flag(Message.HEADERFLAG_AA) message_render.set_header_flag(Message.HEADERFLAG_AA)
@ -161,7 +161,7 @@ class MessageTest(unittest.TestCase):
def test_set_rcode(self): def test_set_rcode(self):
self.assertRaises(TypeError, self.r.set_rcode, "wrong") self.assertRaises(TypeError, self.r.set_rcode, "wrong")
rcode = Rcode.BADVERS() rcode = Rcode.BADVERS
self.r.set_rcode(rcode) self.r.set_rcode(rcode)
self.assertEqual(rcode, self.r.get_rcode()) self.assertEqual(rcode, self.r.get_rcode())
@ -173,7 +173,7 @@ class MessageTest(unittest.TestCase):
def test_set_opcode(self): def test_set_opcode(self):
self.assertRaises(TypeError, self.r.set_opcode, "wrong") self.assertRaises(TypeError, self.r.set_opcode, "wrong")
opcode = Opcode.IQUERY() opcode = Opcode.IQUERY
self.r.set_opcode(opcode) self.r.set_opcode(opcode)
self.assertEqual(opcode, self.r.get_opcode()) self.assertEqual(opcode, self.r.get_opcode())
@ -336,19 +336,19 @@ class MessageTest(unittest.TestCase):
renderer.get_data()) renderer.get_data())
def test_to_wire_without_opcode(self): def test_to_wire_without_opcode(self):
self.r.set_rcode(Rcode.NOERROR()) self.r.set_rcode(Rcode.NOERROR)
self.assertRaises(InvalidMessageOperation, self.r.to_wire, self.assertRaises(InvalidMessageOperation, self.r.to_wire,
MessageRenderer()) MessageRenderer())
def test_to_wire_without_rcode(self): def test_to_wire_without_rcode(self):
self.r.set_opcode(Opcode.QUERY()) self.r.set_opcode(Opcode.QUERY)
self.assertRaises(InvalidMessageOperation, self.r.to_wire, self.assertRaises(InvalidMessageOperation, self.r.to_wire,
MessageRenderer()) MessageRenderer())
def __common_tsigmessage_setup(self, flags=[Message.HEADERFLAG_RD], def __common_tsigmessage_setup(self, flags=[Message.HEADERFLAG_RD],
rrtype=RRType("A"), answer_data=None): rrtype=RRType("A"), answer_data=None):
self.r.set_opcode(Opcode.QUERY()) self.r.set_opcode(Opcode.QUERY)
self.r.set_rcode(Rcode.NOERROR()) self.r.set_rcode(Rcode.NOERROR)
for flag in flags: for flag in flags:
self.r.set_header_flag(flag) self.r.set_header_flag(flag)
if answer_data is not None: if answer_data is not None:
@ -407,8 +407,8 @@ class MessageTest(unittest.TestCase):
self.__common_tsig_checks("message_toWire4.wire") self.__common_tsig_checks("message_toWire4.wire")
def test_to_wire_tsig_truncation3(self): def test_to_wire_tsig_truncation3(self):
self.r.set_opcode(Opcode.QUERY()) self.r.set_opcode(Opcode.QUERY)
self.r.set_rcode(Rcode.NOERROR()) self.r.set_rcode(Rcode.NOERROR)
for i in range(1, 68): for i in range(1, 68):
self.r.add_question(Question(Name("www.example.com"), self.r.add_question(Question(Name("www.example.com"),
RRClass("IN"), RRType(i))) RRClass("IN"), RRType(i)))
@ -469,11 +469,11 @@ test.example.com. 3600 IN A 192.0.2.2
self.assertEqual(msg_str, str(message_render)) self.assertEqual(msg_str, str(message_render))
def test_to_text_without_opcode(self): def test_to_text_without_opcode(self):
self.r.set_rcode(Rcode.NOERROR()) self.r.set_rcode(Rcode.NOERROR)
self.assertRaises(InvalidMessageOperation, self.r.to_text) self.assertRaises(InvalidMessageOperation, self.r.to_text)
def test_to_text_without_rcode(self): def test_to_text_without_rcode(self):
self.r.set_opcode(Opcode.QUERY()) self.r.set_opcode(Opcode.QUERY)
self.assertRaises(InvalidMessageOperation, self.r.to_text) self.assertRaises(InvalidMessageOperation, self.r.to_text)
def test_from_wire(self): def test_from_wire(self):
@ -488,8 +488,8 @@ test.example.com. 3600 IN A 192.0.2.2
message_parse = Message(0) message_parse = Message(0)
factoryFromFile(message_parse, "message_fromWire1") factoryFromFile(message_parse, "message_fromWire1")
self.assertEqual(0x1035, message_parse.get_qid()) self.assertEqual(0x1035, message_parse.get_qid())
self.assertEqual(Opcode.QUERY(), message_parse.get_opcode()) self.assertEqual(Opcode.QUERY, message_parse.get_opcode())
self.assertEqual(Rcode.NOERROR(), message_parse.get_rcode()) self.assertEqual(Rcode.NOERROR, message_parse.get_rcode())
self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_QR)) self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_QR))
self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_RD)) self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_RD))
self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_AA)) self.assertTrue(message_parse.get_header_flag(Message.HEADERFLAG_AA))
@ -568,7 +568,7 @@ test.example.com. 3600 IN A 192.0.2.2
# Extended Rcode = BADVERS # Extended Rcode = BADVERS
message_parse = Message(Message.PARSE) message_parse = Message(Message.PARSE)
factoryFromFile(message_parse, "message_fromWire10.wire") factoryFromFile(message_parse, "message_fromWire10.wire")
self.assertEqual(Rcode.BADVERS(), message_parse.get_rcode()) self.assertEqual(Rcode.BADVERS, message_parse.get_rcode())
# Maximum extended Rcode # Maximum extended Rcode
message_parse.clear(Message.PARSE) message_parse.clear(Message.PARSE)

8
src/lib/dns/python/tests/messagerenderer_python_test.py
View File

@ -31,8 +31,8 @@ class MessageRendererTest(unittest.TestCase):
message = Message(Message.RENDER) message = Message(Message.RENDER)
message.set_qid(123) message.set_qid(123)
message.set_opcode(Opcode.QUERY()) message.set_opcode(Opcode.QUERY)
message.set_rcode(Rcode.NOERROR()) message.set_rcode(Rcode.NOERROR)
message.add_question(Question(name, c, t)) message.add_question(Question(name, c, t))
self.message1 = message self.message1 = message
@ -40,8 +40,8 @@ class MessageRendererTest(unittest.TestCase):
message.set_qid(123) message.set_qid(123)
message.set_header_flag(Message.HEADERFLAG_AA, True) message.set_header_flag(Message.HEADERFLAG_AA, True)
message.set_header_flag(Message.HEADERFLAG_QR, True) message.set_header_flag(Message.HEADERFLAG_QR, True)
message.set_opcode(Opcode.QUERY()) message.set_opcode(Opcode.QUERY)
message.set_rcode(Rcode.NOERROR()) message.set_rcode(Rcode.NOERROR)
message.add_question(Question(name, c, t)) message.add_question(Question(name, c, t))
rrset = RRset(name, c, t, ttl) rrset = RRset(name, c, t, ttl)
rrset.add_rdata(Rdata(t, c, "192.0.2.98")) rrset.add_rdata(Rdata(t, c, "192.0.2.98"))

82
src/lib/dns/python/tests/opcode_python_test.py
View File

@ -34,53 +34,53 @@ class OpcodeTest(unittest.TestCase):
self.assertEqual(Opcode.UPDATE_CODE, Opcode(5).get_code()) self.assertEqual(Opcode.UPDATE_CODE, Opcode(5).get_code())
self.assertEqual(Opcode.RESERVED15_CODE, Opcode(15).get_code()) self.assertEqual(Opcode.RESERVED15_CODE, Opcode(15).get_code())
self.assertEqual(Opcode.QUERY_CODE, Opcode.QUERY().get_code()) self.assertEqual(Opcode.QUERY_CODE, Opcode.QUERY.get_code())
self.assertEqual(Opcode.IQUERY_CODE, Opcode.IQUERY().get_code()) self.assertEqual(Opcode.IQUERY_CODE, Opcode.IQUERY.get_code())
self.assertEqual(Opcode.NOTIFY_CODE, Opcode.NOTIFY().get_code()) self.assertEqual(Opcode.NOTIFY_CODE, Opcode.NOTIFY.get_code())
self.assertEqual(Opcode.UPDATE_CODE, Opcode.UPDATE().get_code()) self.assertEqual(Opcode.UPDATE_CODE, Opcode.UPDATE.get_code())
self.assertEqual(Opcode.RESERVED15_CODE, Opcode.RESERVED15().get_code()) self.assertEqual(Opcode.RESERVED15_CODE, Opcode.RESERVED15.get_code())
def test_get_code(self): def test_get_code(self):
self.assertEqual(0, Opcode.QUERY().get_code()) self.assertEqual(0, Opcode.QUERY.get_code())
self.assertEqual(1, Opcode.IQUERY().get_code()) self.assertEqual(1, Opcode.IQUERY.get_code())
self.assertEqual(2, Opcode.STATUS().get_code()) self.assertEqual(2, Opcode.STATUS.get_code())
self.assertEqual(3, Opcode.RESERVED3().get_code()) self.assertEqual(3, Opcode.RESERVED3.get_code())
self.assertEqual(4, Opcode.NOTIFY().get_code()) self.assertEqual(4, Opcode.NOTIFY.get_code())
self.assertEqual(5, Opcode.UPDATE().get_code()) self.assertEqual(5, Opcode.UPDATE.get_code())
self.assertEqual(6, Opcode.RESERVED6().get_code()) self.assertEqual(6, Opcode.RESERVED6.get_code())
self.assertEqual(7, Opcode.RESERVED7().get_code()) self.assertEqual(7, Opcode.RESERVED7.get_code())
self.assertEqual(8, Opcode.RESERVED8().get_code()) self.assertEqual(8, Opcode.RESERVED8.get_code())
self.assertEqual(9, Opcode.RESERVED9().get_code()) self.assertEqual(9, Opcode.RESERVED9.get_code())
self.assertEqual(10, Opcode.RESERVED10().get_code()) self.assertEqual(10, Opcode.RESERVED10.get_code())
self.assertEqual(11, Opcode.RESERVED11().get_code()) self.assertEqual(11, Opcode.RESERVED11.get_code())
self.assertEqual(12, Opcode.RESERVED12().get_code()) self.assertEqual(12, Opcode.RESERVED12.get_code())
self.assertEqual(13, Opcode.RESERVED13().get_code()) self.assertEqual(13, Opcode.RESERVED13.get_code())
self.assertEqual(14, Opcode.RESERVED14().get_code()) self.assertEqual(14, Opcode.RESERVED14.get_code())
self.assertEqual(15, Opcode.RESERVED15().get_code()) self.assertEqual(15, Opcode.RESERVED15.get_code())
def test_to_text(self): def test_to_text(self):
self.assertEqual("QUERY", Opcode.QUERY().to_text()) self.assertEqual("QUERY", Opcode.QUERY.to_text())
self.assertEqual("QUERY", str(Opcode.QUERY())) self.assertEqual("QUERY", str(Opcode.QUERY))
self.assertEqual("IQUERY", Opcode.IQUERY().to_text()) self.assertEqual("IQUERY", Opcode.IQUERY.to_text())
self.assertEqual("STATUS", Opcode.STATUS().to_text()) self.assertEqual("STATUS", Opcode.STATUS.to_text())
self.assertEqual("RESERVED3", Opcode.RESERVED3().to_text()) self.assertEqual("RESERVED3", Opcode.RESERVED3.to_text())
self.assertEqual("NOTIFY", Opcode.NOTIFY().to_text()) self.assertEqual("NOTIFY", Opcode.NOTIFY.to_text())
self.assertEqual("UPDATE", Opcode.UPDATE().to_text()) self.assertEqual("UPDATE", Opcode.UPDATE.to_text())
self.assertEqual("RESERVED6", Opcode.RESERVED6().to_text()) self.assertEqual("RESERVED6", Opcode.RESERVED6.to_text())
self.assertEqual("RESERVED7", Opcode.RESERVED7().to_text()) self.assertEqual("RESERVED7", Opcode.RESERVED7.to_text())
self.assertEqual("RESERVED8", Opcode.RESERVED8().to_text()) self.assertEqual("RESERVED8", Opcode.RESERVED8.to_text())
self.assertEqual("RESERVED9", Opcode.RESERVED9().to_text()) self.assertEqual("RESERVED9", Opcode.RESERVED9.to_text())
self.assertEqual("RESERVED10", Opcode.RESERVED10().to_text()) self.assertEqual("RESERVED10", Opcode.RESERVED10.to_text())
self.assertEqual("RESERVED11", Opcode.RESERVED11().to_text()) self.assertEqual("RESERVED11", Opcode.RESERVED11.to_text())
self.assertEqual("RESERVED12", Opcode.RESERVED12().to_text()) self.assertEqual("RESERVED12", Opcode.RESERVED12.to_text())
self.assertEqual("RESERVED13", Opcode.RESERVED13().to_text()) self.assertEqual("RESERVED13", Opcode.RESERVED13.to_text())
self.assertEqual("RESERVED14", Opcode.RESERVED14().to_text()) self.assertEqual("RESERVED14", Opcode.RESERVED14.to_text())
self.assertEqual("RESERVED15", Opcode.RESERVED15().to_text()) self.assertEqual("RESERVED15", Opcode.RESERVED15.to_text())
def test_richcmp(self): def test_richcmp(self):
o1 = Opcode.QUERY() o1 = Opcode.QUERY
o2 = Opcode.NOTIFY() o2 = Opcode.NOTIFY
o3 = Opcode.NOTIFY() o3 = Opcode.NOTIFY
self.assertTrue(o2 == o3) self.assertTrue(o2 == o3)
self.assertFalse(o2 != o3) self.assertFalse(o2 != o3)
self.assertTrue(o1 != o2) self.assertTrue(o1 != o2)

60
src/lib/dns/python/tests/rcode_python_test.py
View File

@ -54,36 +54,36 @@ class RcodeTest(unittest.TestCase):
self.assertEqual(Rcode.RESERVED15_CODE, Rcode(15).get_code()) self.assertEqual(Rcode.RESERVED15_CODE, Rcode(15).get_code())
self.assertEqual(Rcode.BADVERS_CODE, Rcode(16).get_code()) self.assertEqual(Rcode.BADVERS_CODE, Rcode(16).get_code())
self.assertEqual(Rcode.NOERROR_CODE, Rcode.NOERROR().get_code()) self.assertEqual(Rcode.NOERROR_CODE, Rcode.NOERROR.get_code())
self.assertEqual(Rcode.FORMERR_CODE, Rcode.FORMERR().get_code()) self.assertEqual(Rcode.FORMERR_CODE, Rcode.FORMERR.get_code())
self.assertEqual(Rcode.NOTIMP_CODE, Rcode.NOTIMP().get_code()) self.assertEqual(Rcode.NOTIMP_CODE, Rcode.NOTIMP.get_code())
self.assertEqual(Rcode.REFUSED_CODE, Rcode.REFUSED().get_code()) self.assertEqual(Rcode.REFUSED_CODE, Rcode.REFUSED.get_code())
self.assertEqual(Rcode.RESERVED15_CODE, Rcode.RESERVED15().get_code()) self.assertEqual(Rcode.RESERVED15_CODE, Rcode.RESERVED15.get_code())
self.assertEqual(Rcode.BADVERS_CODE, Rcode.BADVERS().get_code()) self.assertEqual(Rcode.BADVERS_CODE, Rcode.BADVERS.get_code())
def test_get_code(self): def test_get_code(self):
self.assertEqual(0, Rcode.NOERROR().get_code()) self.assertEqual(0, Rcode.NOERROR.get_code())
self.assertEqual(1, Rcode.FORMERR().get_code()) self.assertEqual(1, Rcode.FORMERR.get_code())
self.assertEqual(2, Rcode.SERVFAIL().get_code()) self.assertEqual(2, Rcode.SERVFAIL.get_code())
self.assertEqual(3, Rcode.NXDOMAIN().get_code()) self.assertEqual(3, Rcode.NXDOMAIN.get_code())
self.assertEqual(4, Rcode.NOTIMP().get_code()) self.assertEqual(4, Rcode.NOTIMP.get_code())
self.assertEqual(5, Rcode.REFUSED().get_code()) self.assertEqual(5, Rcode.REFUSED.get_code())
self.assertEqual(6, Rcode.YXDOMAIN().get_code()) self.assertEqual(6, Rcode.YXDOMAIN.get_code())
self.assertEqual(7, Rcode.YXRRSET().get_code()) self.assertEqual(7, Rcode.YXRRSET.get_code())
self.assertEqual(8, Rcode.NXRRSET().get_code()) self.assertEqual(8, Rcode.NXRRSET.get_code())
self.assertEqual(9, Rcode.NOTAUTH().get_code()) self.assertEqual(9, Rcode.NOTAUTH.get_code())
self.assertEqual(10, Rcode.NOTZONE().get_code()) self.assertEqual(10, Rcode.NOTZONE.get_code())
self.assertEqual(11, Rcode.RESERVED11().get_code()) self.assertEqual(11, Rcode.RESERVED11.get_code())
self.assertEqual(12, Rcode.RESERVED12().get_code()) self.assertEqual(12, Rcode.RESERVED12.get_code())
self.assertEqual(13, Rcode.RESERVED13().get_code()) self.assertEqual(13, Rcode.RESERVED13.get_code())
self.assertEqual(14, Rcode.RESERVED14().get_code()) self.assertEqual(14, Rcode.RESERVED14.get_code())
self.assertEqual(15, Rcode.RESERVED15().get_code()) self.assertEqual(15, Rcode.RESERVED15.get_code())
self.assertEqual(16, Rcode.BADVERS().get_code()) self.assertEqual(16, Rcode.BADVERS.get_code())
def test_get_extended_code(self): def test_get_extended_code(self):
self.assertEqual(0, Rcode.NOERROR().get_extended_code()) self.assertEqual(0, Rcode.NOERROR.get_extended_code())
self.assertEqual(0, Rcode.YXRRSET().get_extended_code()) self.assertEqual(0, Rcode.YXRRSET.get_extended_code())
self.assertEqual(1, Rcode.BADVERS().get_extended_code()) self.assertEqual(1, Rcode.BADVERS.get_extended_code())
self.assertEqual(0xab, Rcode(0xabf).get_extended_code()) self.assertEqual(0xab, Rcode(0xabf).get_extended_code())
self.assertEqual(0xff, Rcode(0xfff).get_extended_code()) self.assertEqual(0xff, Rcode(0xfff).get_extended_code())
@ -107,13 +107,13 @@ class RcodeTest(unittest.TestCase):
self.assertEqual("RESERVED15", Rcode(15).to_text()) self.assertEqual("RESERVED15", Rcode(15).to_text())
self.assertEqual("BADVERS", Rcode(16).to_text()) self.assertEqual("BADVERS", Rcode(16).to_text())
self.assertEqual("17", Rcode(Rcode.BADVERS().get_code() + 1).to_text()) self.assertEqual("17", Rcode(Rcode.BADVERS.get_code() + 1).to_text())
self.assertEqual("4095", Rcode(0xfff).to_text()) self.assertEqual("4095", Rcode(0xfff).to_text())
def test_richcmp(self): def test_richcmp(self):
r1 = Rcode.NOERROR() r1 = Rcode.NOERROR
r2 = Rcode.FORMERR() r2 = Rcode.FORMERR
r3 = Rcode.FORMERR() r3 = Rcode.FORMERR
self.assertTrue(r2 == r3) self.assertTrue(r2 == r3)
self.assertTrue(r1 != r2) self.assertTrue(r1 != r2)
self.assertFalse(r1 == r2) self.assertFalse(r1 == r2)

8
src/lib/dns/python/tests/tsig_python_test.py
View File

@ -61,10 +61,10 @@ class TSIGContextTest(unittest.TestCase):
def createMessageAndSign(self, id, qname, ctx, message_flags=RD_FLAG, def createMessageAndSign(self, id, qname, ctx, message_flags=RD_FLAG,
qtype=RRType.A, answer_data=None, qtype=RRType.A, answer_data=None,
answer_type=None, add_question=True, answer_type=None, add_question=True,
rcode=Rcode.NOERROR()): rcode=Rcode.NOERROR):
self.message.clear(Message.RENDER) self.message.clear(Message.RENDER)
self.message.set_qid(id) self.message.set_qid(id)
self.message.set_opcode(Opcode.QUERY()) self.message.set_opcode(Opcode.QUERY)
self.message.set_rcode(rcode) self.message.set_rcode(rcode)
if (message_flags & QR_FLAG) != 0: if (message_flags & QR_FLAG) != 0:
self.message.set_header_flag(Message.HEADERFLAG_QR) self.message.set_header_flag(Message.HEADERFLAG_QR)
@ -120,7 +120,7 @@ class TSIGContextTest(unittest.TestCase):
self.assertEqual(TSIGContext.STATE_INIT, self.tsig_ctx.get_state()) self.assertEqual(TSIGContext.STATE_INIT, self.tsig_ctx.get_state())
# And there should be no error code. # And there should be no error code.
self.assertEqual(TSIGError(Rcode.NOERROR()), self.tsig_ctx.get_error()) self.assertEqual(TSIGError(Rcode.NOERROR), self.tsig_ctx.get_error())
# No message signed yet # No message signed yet
self.assertRaises(TSIGContextError, self.tsig_ctx.last_had_signature) self.assertRaises(TSIGContextError, self.tsig_ctx.last_had_signature)
@ -329,7 +329,7 @@ class TSIGContextTest(unittest.TestCase):
tsig = self.createMessageAndSign(test_qid, self.test_name, tsig = self.createMessageAndSign(test_qid, self.test_name,
self.tsig_verify_ctx, self.tsig_verify_ctx,
QR_FLAG, RRType.SOA, None, None, QR_FLAG, RRType.SOA, None, None,
True, Rcode.NOTAUTH()) True, Rcode.NOTAUTH)
expected_otherdata = b"\x00\x00\x4d\xa8\xbe\x86" expected_otherdata = b"\x00\x00\x4d\xa8\xbe\x86"
expected_mac = b"\xd4\xb0\x43\xf6\xf4\x44\x95\xec\x8a\x01\x26" +\ expected_mac = b"\xd4\xb0\x43\xf6\xf4\x44\x95\xec\x8a\x01\x26" +\

26
src/lib/dns/python/tests/tsigerror_python_test.py
View File

@ -28,7 +28,7 @@ class TSIGErrorTest(unittest.TestCase):
def test_from_rcode(self): def test_from_rcode(self):
# We use RCODE for code values from 0-15. # We use RCODE for code values from 0-15.
self.assertEqual(0, TSIGError(Rcode.NOERROR()).get_code()) self.assertEqual(0, TSIGError(Rcode.NOERROR).get_code())
self.assertEqual(15, TSIGError(Rcode(15)).get_code()) self.assertEqual(15, TSIGError(Rcode(15)).get_code())
# From error code 16 TSIG errors define a separate space, so passing # From error code 16 TSIG errors define a separate space, so passing
@ -50,19 +50,19 @@ class TSIGErrorTest(unittest.TestCase):
self.assertEqual(TSIGError.BAD_TIME_CODE, TSIGError.BAD_TIME.get_code()) self.assertEqual(TSIGError.BAD_TIME_CODE, TSIGError.BAD_TIME.get_code())
def test_equal(self): def test_equal(self):
self.assertTrue(TSIGError.NOERROR == TSIGError(Rcode.NOERROR())) self.assertTrue(TSIGError.NOERROR == TSIGError(Rcode.NOERROR))
self.assertTrue(TSIGError(Rcode.NOERROR()) == TSIGError.NOERROR) self.assertTrue(TSIGError(Rcode.NOERROR) == TSIGError.NOERROR)
self.assertTrue(TSIGError.BAD_SIG == TSIGError(16)) self.assertTrue(TSIGError.BAD_SIG == TSIGError(16))
self.assertTrue(TSIGError(16) == TSIGError.BAD_SIG) self.assertTrue(TSIGError(16) == TSIGError.BAD_SIG)
def test_nequal(self): def test_nequal(self):
self.assertTrue(TSIGError.BAD_KEY != TSIGError(Rcode.NOERROR())) self.assertTrue(TSIGError.BAD_KEY != TSIGError(Rcode.NOERROR))
self.assertTrue(TSIGError(Rcode.NOERROR()) != TSIGError.BAD_KEY) self.assertTrue(TSIGError(Rcode.NOERROR) != TSIGError.BAD_KEY)
def test_to_text(self): def test_to_text(self):
# TSIGError derived from the standard Rcode # TSIGError derived from the standard Rcode
self.assertEqual("NOERROR", TSIGError(Rcode.NOERROR()).to_text()) self.assertEqual("NOERROR", TSIGError(Rcode.NOERROR).to_text())
# Well known TSIG errors # Well known TSIG errors
self.assertEqual("BADSIG", TSIGError.BAD_SIG.to_text()) self.assertEqual("BADSIG", TSIGError.BAD_SIG.to_text())
@ -74,21 +74,21 @@ class TSIGErrorTest(unittest.TestCase):
self.assertEqual("65535", TSIGError(65535).to_text()); self.assertEqual("65535", TSIGError(65535).to_text());
# also check str() works same way # also check str() works same way
self.assertEqual("NOERROR", str(TSIGError(Rcode.NOERROR()))) self.assertEqual("NOERROR", str(TSIGError(Rcode.NOERROR)))
self.assertEqual("BADSIG", str(TSIGError.BAD_SIG)) self.assertEqual("BADSIG", str(TSIGError.BAD_SIG))
def test_to_rcode(self): def test_to_rcode(self):
# TSIGError derived from the standard Rcode # TSIGError derived from the standard Rcode
self.assertEqual(Rcode.NOERROR(), TSIGError(Rcode.NOERROR()).to_rcode()) self.assertEqual(Rcode.NOERROR, TSIGError(Rcode.NOERROR).to_rcode())
# Well known TSIG errors # Well known TSIG errors
self.assertEqual(Rcode.NOTAUTH(), TSIGError.BAD_SIG.to_rcode()) self.assertEqual(Rcode.NOTAUTH, TSIGError.BAD_SIG.to_rcode())
self.assertEqual(Rcode.NOTAUTH(), TSIGError.BAD_KEY.to_rcode()) self.assertEqual(Rcode.NOTAUTH, TSIGError.BAD_KEY.to_rcode())
self.assertEqual(Rcode.NOTAUTH(), TSIGError.BAD_TIME.to_rcode()) self.assertEqual(Rcode.NOTAUTH, TSIGError.BAD_TIME.to_rcode())
# Unknown (or not yet supported) codes are treated as SERVFAIL. # Unknown (or not yet supported) codes are treated as SERVFAIL.
self.assertEqual(Rcode.SERVFAIL(), TSIGError(19).to_rcode()) self.assertEqual(Rcode.SERVFAIL, TSIGError(19).to_rcode())
self.assertEqual(Rcode.SERVFAIL(), TSIGError(65535).to_rcode()) self.assertEqual(Rcode.SERVFAIL, TSIGError(65535).to_rcode())
# Check there's no redundant refcount (which would cause leak) # Check there's no redundant refcount (which would cause leak)
self.assertEqual(1, sys.getrefcount(TSIGError.BAD_SIG.to_rcode())) self.assertEqual(1, sys.getrefcount(TSIGError.BAD_SIG.to_rcode()))

70
src/lib/python/isc/ddns/session.py
View File

@ -248,14 +248,14 @@ class UpdateSession:
self.__check_update_acl(self.__zname, self.__zclass) self.__check_update_acl(self.__zname, self.__zclass)
self._create_diff() self._create_diff()
prereq_result = self.__check_prerequisites() prereq_result = self.__check_prerequisites()
if prereq_result != Rcode.NOERROR(): if prereq_result != Rcode.NOERROR:
self.__make_response(prereq_result) self.__make_response(prereq_result)
return UPDATE_ERROR, self.__zname, self.__zclass return UPDATE_ERROR, self.__zname, self.__zclass
update_result = self.__do_update() update_result = self.__do_update()
if update_result != Rcode.NOERROR(): if update_result != Rcode.NOERROR:
self.__make_response(update_result) self.__make_response(update_result)
return UPDATE_ERROR, self.__zname, self.__zclass return UPDATE_ERROR, self.__zname, self.__zclass
self.__make_response(Rcode.NOERROR()) self.__make_response(Rcode.NOERROR)
return UPDATE_SUCCESS, self.__zname, self.__zclass return UPDATE_SUCCESS, self.__zname, self.__zclass
except UpdateError as e: except UpdateError as e:
if not e.nolog: if not e.nolog:
@ -272,7 +272,7 @@ class UpdateSession:
except isc.datasrc.Error as e: except isc.datasrc.Error as e:
logger.error(LIBDDNS_DATASRC_ERROR, logger.error(LIBDDNS_DATASRC_ERROR,
ClientFormatter(self.__client_addr, self.__tsig), e) ClientFormatter(self.__client_addr, self.__tsig), e)
self.__make_response(Rcode.SERVFAIL()) self.__make_response(Rcode.SERVFAIL)
return UPDATE_ERROR, None, None return UPDATE_ERROR, None, None
def _get_update_zone(self): def _get_update_zone(self):
@ -295,11 +295,11 @@ class UpdateSession:
n_zones = self.__message.get_rr_count(SECTION_ZONE) n_zones = self.__message.get_rr_count(SECTION_ZONE)
if n_zones != 1: if n_zones != 1:
raise UpdateError('Invalid number of records in zone section: ' + raise UpdateError('Invalid number of records in zone section: ' +
str(n_zones), None, None, Rcode.FORMERR()) str(n_zones), None, None, Rcode.FORMERR)
zrecord = self.__message.get_question()[0] zrecord = self.__message.get_question()[0]
if zrecord.get_type() != RRType.SOA: if zrecord.get_type() != RRType.SOA:
raise UpdateError('update zone section contains non-SOA', raise UpdateError('update zone section contains non-SOA',
None, None, Rcode.FORMERR()) None, None, Rcode.FORMERR)
# See if we're serving a primary zone specified in the zone section. # See if we're serving a primary zone specified in the zone section.
zname = zrecord.get_name() zname = zrecord.get_name()
@ -316,12 +316,12 @@ class UpdateSession:
logger.debug(DBGLVL_TRACE_BASIC, LIBDDNS_UPDATE_FORWARD_FAIL, logger.debug(DBGLVL_TRACE_BASIC, LIBDDNS_UPDATE_FORWARD_FAIL,
ClientFormatter(self.__client_addr, self.__tsig), ClientFormatter(self.__client_addr, self.__tsig),
ZoneFormatter(zname, zclass)) ZoneFormatter(zname, zclass))
raise UpdateError('forward', zname, zclass, Rcode.NOTIMP(), True) raise UpdateError('forward', zname, zclass, Rcode.NOTIMP, True)
# zone wasn't found # zone wasn't found
logger.debug(DBGLVL_TRACE_BASIC, LIBDDNS_UPDATE_NOTAUTH, logger.debug(DBGLVL_TRACE_BASIC, LIBDDNS_UPDATE_NOTAUTH,
ClientFormatter(self.__client_addr, self.__tsig), ClientFormatter(self.__client_addr, self.__tsig),
ZoneFormatter(zname, zclass)) ZoneFormatter(zname, zclass))
raise UpdateError('notauth', zname, zclass, Rcode.NOTAUTH(), True) raise UpdateError('notauth', zname, zclass, Rcode.NOTAUTH, True)
def _create_diff(self): def _create_diff(self):
''' '''
@ -352,7 +352,7 @@ class UpdateSession:
logger.info(LIBDDNS_UPDATE_DENIED, logger.info(LIBDDNS_UPDATE_DENIED,
ClientFormatter(self.__client_addr, self.__tsig), ClientFormatter(self.__client_addr, self.__tsig),
ZoneFormatter(zname, zclass)) ZoneFormatter(zname, zclass))
raise UpdateError('rejected', zname, zclass, Rcode.REFUSED(), True) raise UpdateError('rejected', zname, zclass, Rcode.REFUSED, True)
if action == DROP: if action == DROP:
logger.info(LIBDDNS_UPDATE_DROPPED, logger.info(LIBDDNS_UPDATE_DROPPED,
ClientFormatter(self.__client_addr, self.__tsig), ClientFormatter(self.__client_addr, self.__tsig),
@ -459,7 +459,7 @@ class UpdateSession:
def __check_prerequisites(self): def __check_prerequisites(self):
'''Check the prerequisites section of the UPDATE Message. '''Check the prerequisites section of the UPDATE Message.
RFC2136 Section 2.4. RFC2136 Section 2.4.
Returns a dns Rcode signaling either no error (Rcode.NOERROR()) Returns a dns Rcode signaling either no error (Rcode.NOERROR)
or that one of the prerequisites failed (any other Rcode). or that one of the prerequisites failed (any other Rcode).
''' '''
@ -473,7 +473,7 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.NOTZONE() return Rcode.NOTZONE
# Algorithm taken from RFC2136 Section 3.2 # Algorithm taken from RFC2136 Section 3.2
if rrset.get_class() == RRClass.ANY: if rrset.get_class() == RRClass.ANY:
@ -483,10 +483,10 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
elif rrset.get_type() == RRType.ANY: elif rrset.get_type() == RRType.ANY:
if not self.__prereq_name_in_use(rrset): if not self.__prereq_name_in_use(rrset):
rcode = Rcode.NXDOMAIN() rcode = Rcode.NXDOMAIN
logger.info(LIBDDNS_PREREQ_NAME_IN_USE_FAILED, logger.info(LIBDDNS_PREREQ_NAME_IN_USE_FAILED,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
@ -494,7 +494,7 @@ class UpdateSession:
return rcode return rcode
else: else:
if not self.__prereq_rrset_exists(rrset): if not self.__prereq_rrset_exists(rrset):
rcode = Rcode.NXRRSET() rcode = Rcode.NXRRSET
logger.info(LIBDDNS_PREREQ_RRSET_EXISTS_FAILED, logger.info(LIBDDNS_PREREQ_RRSET_EXISTS_FAILED,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
@ -507,10 +507,10 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
elif rrset.get_type() == RRType.ANY: elif rrset.get_type() == RRType.ANY:
if not self.__prereq_name_not_in_use(rrset): if not self.__prereq_name_not_in_use(rrset):
rcode = Rcode.YXDOMAIN() rcode = Rcode.YXDOMAIN
logger.info(LIBDDNS_PREREQ_NAME_NOT_IN_USE_FAILED, logger.info(LIBDDNS_PREREQ_NAME_NOT_IN_USE_FAILED,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
@ -518,7 +518,7 @@ class UpdateSession:
return rcode return rcode
else: else:
if not self.__prereq_rrset_does_not_exist(rrset): if not self.__prereq_rrset_does_not_exist(rrset):
rcode = Rcode.YXRRSET() rcode = Rcode.YXRRSET
logger.info(LIBDDNS_PREREQ_RRSET_DOES_NOT_EXIST_FAILED, logger.info(LIBDDNS_PREREQ_RRSET_DOES_NOT_EXIST_FAILED,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
@ -530,7 +530,7 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
else: else:
collect_rrsets(exact_match_rrsets, rrset) collect_rrsets(exact_match_rrsets, rrset)
else: else:
@ -538,11 +538,11 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
for collected_rrset in exact_match_rrsets: for collected_rrset in exact_match_rrsets:
if not self.__prereq_rrset_exists_value(collected_rrset): if not self.__prereq_rrset_exists_value(collected_rrset):
rcode = Rcode.NXRRSET() rcode = Rcode.NXRRSET
logger.info(LIBDDNS_PREREQ_RRSET_EXISTS_VAL_FAILED, logger.info(LIBDDNS_PREREQ_RRSET_EXISTS_VAL_FAILED,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
@ -550,7 +550,7 @@ class UpdateSession:
return rcode return rcode
# All prerequisites are satisfied # All prerequisites are satisfied
return Rcode.NOERROR() return Rcode.NOERROR
def __set_soa_rrset(self, rrset): def __set_soa_rrset(self, rrset):
'''Sets the given rrset to the member __added_soa (which '''Sets the given rrset to the member __added_soa (which
@ -570,7 +570,7 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.NOTZONE() return Rcode.NOTZONE
if rrset.get_class() == self.__zclass: if rrset.get_class() == self.__zclass:
# In fact, all metatypes are in a specific range, # In fact, all metatypes are in a specific range,
# so one check can test TKEY to ANY # so one check can test TKEY to ANY
@ -581,7 +581,7 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
if rrset.get_type() == RRType.SOA: if rrset.get_type() == RRType.SOA:
# In case there's multiple soa records in the update # In case there's multiple soa records in the update
# somehow, just take the last # somehow, just take the last
@ -593,40 +593,40 @@ class UpdateSession:
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
if rrset.get_rdata_count() > 0: if rrset.get_rdata_count() > 0:
logger.info(LIBDDNS_UPDATE_DELETE_RRSET_NOT_EMPTY, logger.info(LIBDDNS_UPDATE_DELETE_RRSET_NOT_EMPTY,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
if rrset.get_type().get_code() >= 249 and\ if rrset.get_type().get_code() >= 249 and\
rrset.get_type().get_code() <= 254: rrset.get_type().get_code() <= 254:
logger.info(LIBDDNS_UPDATE_DELETE_BAD_TYPE, logger.info(LIBDDNS_UPDATE_DELETE_BAD_TYPE,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
elif rrset.get_class() == RRClass.NONE: elif rrset.get_class() == RRClass.NONE:
if rrset.get_ttl().get_value() != 0: if rrset.get_ttl().get_value() != 0:
logger.info(LIBDDNS_UPDATE_DELETE_RR_NONZERO_TTL, logger.info(LIBDDNS_UPDATE_DELETE_RR_NONZERO_TTL,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
if rrset.get_type().get_code() >= 249: if rrset.get_type().get_code() >= 249:
logger.info(LIBDDNS_UPDATE_DELETE_RR_BAD_TYPE, logger.info(LIBDDNS_UPDATE_DELETE_RR_BAD_TYPE,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
else: else:
logger.info(LIBDDNS_UPDATE_BAD_CLASS, logger.info(LIBDDNS_UPDATE_BAD_CLASS,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
RRsetFormatter(rrset)) RRsetFormatter(rrset))
return Rcode.FORMERR() return Rcode.FORMERR
return Rcode.NOERROR() return Rcode.NOERROR
def __do_update_add_single_rr(self, rr, existing_rrset): def __do_update_add_single_rr(self, rr, existing_rrset):
'''Helper for __do_update_add_rrs_to_rrset: only add the '''Helper for __do_update_add_rrs_to_rrset: only add the
@ -800,7 +800,7 @@ class UpdateSession:
# for now servfail on such a broken state # for now servfail on such a broken state
if result != ZoneFinder.SUCCESS: if result != ZoneFinder.SUCCESS:
raise UpdateError("Error finding SOA record in datasource.", raise UpdateError("Error finding SOA record in datasource.",
self.__zname, self.__zclass, Rcode.SERVFAIL()) self.__zname, self.__zclass, Rcode.SERVFAIL)
serial_operation = DDNS_SOA() serial_operation = DDNS_SOA()
if self.__added_soa is not None and\ if self.__added_soa is not None and\
serial_operation.soa_update_check(old_soa, self.__added_soa): serial_operation.soa_update_check(old_soa, self.__added_soa):
@ -820,7 +820,7 @@ class UpdateSession:
''' '''
# prescan # prescan
prescan_result = self.__do_prescan() prescan_result = self.__do_prescan()
if prescan_result != Rcode.NOERROR(): if prescan_result != Rcode.NOERROR:
return prescan_result return prescan_result
# update # update
@ -850,13 +850,13 @@ class UpdateSession:
self.__do_update_delete_rrs_from_rrset(rrset) self.__do_update_delete_rrs_from_rrset(rrset)
self.__diff.commit() self.__diff.commit()
return Rcode.NOERROR() return Rcode.NOERROR
except isc.datasrc.Error as dse: except isc.datasrc.Error as dse:
logger.info(LIBDDNS_UPDATE_DATASRC_ERROR, dse) logger.info(LIBDDNS_UPDATE_DATASRC_ERROR, dse)
return Rcode.SERVFAIL() return Rcode.SERVFAIL
except Exception as uce: except Exception as uce:
logger.error(LIBDDNS_UPDATE_UNCAUGHT_EXCEPTION, logger.error(LIBDDNS_UPDATE_UNCAUGHT_EXCEPTION,
ClientFormatter(self.__client_addr), ClientFormatter(self.__client_addr),
ZoneFormatter(self.__zname, self.__zclass), ZoneFormatter(self.__zname, self.__zclass),
uce) uce)
return Rcode.SERVFAIL() return Rcode.SERVFAIL

164
src/lib/python/isc/ddns/tests/session_tests.py
View File

@ -42,8 +42,8 @@ def create_update_msg(zones=[TEST_ZONE_RECORD], prerequisites=[],
updates=[], tsig_key=None): updates=[], tsig_key=None):
msg = Message(Message.RENDER) msg = Message(Message.RENDER)
msg.set_qid(5353) # arbitrary chosen msg.set_qid(5353) # arbitrary chosen
msg.set_opcode(Opcode.UPDATE()) msg.set_opcode(Opcode.UPDATE)
msg.set_rcode(Rcode.NOERROR()) msg.set_rcode(Rcode.NOERROR)
for z in zones: for z in zones:
msg.add_question(z) msg.add_question(z)
for p in prerequisites: for p in prerequisites:
@ -216,7 +216,7 @@ class SessionTestBase(unittest.TestCase):
'''Perform common checks on update resposne message.''' '''Perform common checks on update resposne message.'''
self.assertTrue(msg.get_header_flag(Message.HEADERFLAG_QR)) self.assertTrue(msg.get_header_flag(Message.HEADERFLAG_QR))
# note: we convert opcode to text it'd be more helpful on failure. # note: we convert opcode to text it'd be more helpful on failure.
self.assertEqual(Opcode.UPDATE().to_text(), msg.get_opcode().to_text()) self.assertEqual(Opcode.UPDATE.to_text(), msg.get_opcode().to_text())
self.assertEqual(expected_rcode.to_text(), msg.get_rcode().to_text()) self.assertEqual(expected_rcode.to_text(), msg.get_rcode().to_text())
# All sections should be cleared # All sections should be cleared
self.assertEqual(0, msg.get_rr_count(SECTION_ZONE)) self.assertEqual(0, msg.get_rr_count(SECTION_ZONE))
@ -305,20 +305,20 @@ class SessionTest(SessionTestBase):
self.assertEqual(UPDATE_ERROR, result) self.assertEqual(UPDATE_ERROR, result)
self.assertEqual(None, zname) self.assertEqual(None, zname)
self.assertEqual(None, zclass) self.assertEqual(None, zclass)
self.check_response(session.get_message(), Rcode.FORMERR()) self.check_response(session.get_message(), Rcode.FORMERR)
# Zone section contains multiple records # Zone section contains multiple records
msg = create_update_msg(zones=[TEST_ZONE_RECORD, TEST_ZONE_RECORD]) msg = create_update_msg(zones=[TEST_ZONE_RECORD, TEST_ZONE_RECORD])
session = UpdateSession(msg, TEST_CLIENT4, None) session = UpdateSession(msg, TEST_CLIENT4, None)
self.assertEqual(UPDATE_ERROR, session.handle()[0]) self.assertEqual(UPDATE_ERROR, session.handle()[0])
self.check_response(session.get_message(), Rcode.FORMERR()) self.check_response(session.get_message(), Rcode.FORMERR)
# Zone section's type is not SOA # Zone section's type is not SOA
msg = create_update_msg(zones=[Question(TEST_ZONE_NAME, TEST_RRCLASS, msg = create_update_msg(zones=[Question(TEST_ZONE_NAME, TEST_RRCLASS,
RRType.A)]) RRType.A)])
session = UpdateSession(msg, TEST_CLIENT4, None) session = UpdateSession(msg, TEST_CLIENT4, None)
self.assertEqual(UPDATE_ERROR, session.handle()[0]) self.assertEqual(UPDATE_ERROR, session.handle()[0])
self.check_response(session.get_message(), Rcode.FORMERR()) self.check_response(session.get_message(), Rcode.FORMERR)
def test_update_secondary(self): def test_update_secondary(self):
# specified zone is configured as a secondary. Since this # specified zone is configured as a secondary. Since this
@ -330,7 +330,7 @@ class SessionTest(SessionTestBase):
ZoneConfig({(TEST_ZONE_NAME, TEST_RRCLASS)}, ZoneConfig({(TEST_ZONE_NAME, TEST_RRCLASS)},
TEST_RRCLASS, self._datasrc_client)) TEST_RRCLASS, self._datasrc_client))
self.assertEqual(UPDATE_ERROR, session.handle()[0]) self.assertEqual(UPDATE_ERROR, session.handle()[0])
self.check_response(session.get_message(), Rcode.NOTIMP()) self.check_response(session.get_message(), Rcode.NOTIMP)
def check_notauth(self, zname, zclass=TEST_RRCLASS): def check_notauth(self, zname, zclass=TEST_RRCLASS):
'''Common test sequence for the 'notauth' test''' '''Common test sequence for the 'notauth' test'''
@ -339,7 +339,7 @@ class SessionTest(SessionTestBase):
ZoneConfig({(TEST_ZONE_NAME, TEST_RRCLASS)}, ZoneConfig({(TEST_ZONE_NAME, TEST_RRCLASS)},
TEST_RRCLASS, self._datasrc_client)) TEST_RRCLASS, self._datasrc_client))
self.assertEqual(UPDATE_ERROR, session.handle()[0]) self.assertEqual(UPDATE_ERROR, session.handle()[0])
self.check_response(session.get_message(), Rcode.NOTAUTH()) self.check_response(session.get_message(), Rcode.NOTAUTH)
def test_update_notauth(self): def test_update_notauth(self):
'''Update attempt for non authoritative zones''' '''Update attempt for non authoritative zones'''
@ -364,7 +364,7 @@ class SessionTest(SessionTestBase):
TEST_RRCLASS, TEST_RRCLASS,
BadDataSourceClient())) BadDataSourceClient()))
self.assertEqual(UPDATE_ERROR, session.handle()[0]) self.assertEqual(UPDATE_ERROR, session.handle()[0])
self.check_response(session.get_message(), Rcode.SERVFAIL()) self.check_response(session.get_message(), Rcode.SERVFAIL)
def test_foreach_rr_in_rrset(self): def test_foreach_rr_in_rrset(self):
rrset = create_rrset("www.example.org", TEST_RRCLASS, rrset = create_rrset("www.example.org", TEST_RRCLASS,
@ -632,7 +632,7 @@ class SessionTest(SessionTestBase):
self.assertEqual(expected.to_text(), self.assertEqual(expected.to_text(),
session._UpdateSession__message.get_rcode().to_text()) session._UpdateSession__message.get_rcode().to_text())
# And that the result looks right # And that the result looks right
if expected == Rcode.NOERROR(): if expected == Rcode.NOERROR:
self.assertEqual(UPDATE_SUCCESS, result) self.assertEqual(UPDATE_SUCCESS, result)
else: else:
self.assertEqual(UPDATE_ERROR, result) self.assertEqual(UPDATE_ERROR, result)
@ -672,7 +672,7 @@ class SessionTest(SessionTestBase):
self.assertEqual(expected.to_text(), self.assertEqual(expected.to_text(),
session._UpdateSession__message.get_rcode().to_text()) session._UpdateSession__message.get_rcode().to_text())
# And that the result looks right # And that the result looks right
if expected == Rcode.NOERROR(): if expected == Rcode.NOERROR:
self.assertEqual(UPDATE_SUCCESS, result) self.assertEqual(UPDATE_SUCCESS, result)
else: else:
self.assertEqual(UPDATE_ERROR, result) self.assertEqual(UPDATE_ERROR, result)
@ -727,36 +727,36 @@ class SessionTest(SessionTestBase):
name_not_in_use_no = create_rrset("www.example.org", RRClass.NONE, name_not_in_use_no = create_rrset("www.example.org", RRClass.NONE,
RRType.ANY, 0) RRType.ANY, 0)
# check 'no' result codes # check 'no' result codes
self.check_prerequisite_result(Rcode.NXRRSET(), self.check_prerequisite_result(Rcode.NXRRSET,
[ rrset_exists_no ]) [ rrset_exists_no ])
self.check_prerequisite_result(Rcode.NXRRSET(), self.check_prerequisite_result(Rcode.NXRRSET,
[ rrset_exists_value_no ]) [ rrset_exists_value_no ])
self.check_prerequisite_result(Rcode.YXRRSET(), self.check_prerequisite_result(Rcode.YXRRSET,
[ rrset_does_not_exist_no ]) [ rrset_does_not_exist_no ])
self.check_prerequisite_result(Rcode.NXDOMAIN(), self.check_prerequisite_result(Rcode.NXDOMAIN,
[ name_in_use_no ]) [ name_in_use_no ])
self.check_prerequisite_result(Rcode.YXDOMAIN(), self.check_prerequisite_result(Rcode.YXDOMAIN,
[ name_not_in_use_no ]) [ name_not_in_use_no ])
# the 'yes' codes should result in ok # the 'yes' codes should result in ok
# individually # individually
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ rrset_exists_yes ] ) [ rrset_exists_yes ] )
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ rrset_exists_value_yes ]) [ rrset_exists_value_yes ])
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ rrset_does_not_exist_yes ]) [ rrset_does_not_exist_yes ])
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ name_in_use_yes ]) [ name_in_use_yes ])
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ name_not_in_use_yes ]) [ name_not_in_use_yes ])
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ rrset_exists_value_1, [ rrset_exists_value_1,
rrset_exists_value_2, rrset_exists_value_2,
rrset_exists_value_3]) rrset_exists_value_3])
# and together # and together
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ rrset_exists_yes, [ rrset_exists_yes,
rrset_exists_value_yes, rrset_exists_value_yes,
rrset_does_not_exist_yes, rrset_does_not_exist_yes,
@ -768,7 +768,7 @@ class SessionTest(SessionTestBase):
# try out a permutation, note that one rrset is split up, # try out a permutation, note that one rrset is split up,
# and the order of the RRs should not matter # and the order of the RRs should not matter
self.check_prerequisite_result(Rcode.NOERROR(), self.check_prerequisite_result(Rcode.NOERROR,
[ rrset_exists_value_3, [ rrset_exists_value_3,
rrset_exists_yes, rrset_exists_yes,
rrset_exists_value_2, rrset_exists_value_2,
@ -777,7 +777,7 @@ class SessionTest(SessionTestBase):
# Should fail on the first error, even if most of the # Should fail on the first error, even if most of the
# prerequisites are ok # prerequisites are ok
self.check_prerequisite_result(Rcode.NXDOMAIN(), self.check_prerequisite_result(Rcode.NXDOMAIN,
[ rrset_exists_value_3, [ rrset_exists_value_3,
rrset_exists_yes, rrset_exists_yes,
rrset_exists_value_2, rrset_exists_value_2,
@ -787,38 +787,38 @@ class SessionTest(SessionTestBase):
def test_prerequisite_notzone(self): def test_prerequisite_notzone(self):
rrset = create_rrset("some.other.zone.", RRClass.ANY, RRType.SOA, 0) rrset = create_rrset("some.other.zone.", RRClass.ANY, RRType.SOA, 0)
self.check_prerequisite_result(Rcode.NOTZONE(), [ rrset ]) self.check_prerequisite_result(Rcode.NOTZONE, [ rrset ])
def test_prerequisites_formerr(self): def test_prerequisites_formerr(self):
# test for form errors in the prerequisite section # test for form errors in the prerequisite section
# Class ANY, non-zero TTL # Class ANY, non-zero TTL
rrset = create_rrset("example.org", RRClass.ANY, RRType.SOA, 1) rrset = create_rrset("example.org", RRClass.ANY, RRType.SOA, 1)
self.check_prerequisite_result(Rcode.FORMERR(), [ rrset ]) self.check_prerequisite_result(Rcode.FORMERR, [ rrset ])
# Class ANY, but with rdata # Class ANY, but with rdata
rrset = create_rrset("example.org", RRClass.ANY, RRType.A, 0, rrset = create_rrset("example.org", RRClass.ANY, RRType.A, 0,
[ b'\x00\x00\x00\x00' ]) [ b'\x00\x00\x00\x00' ])
self.check_prerequisite_result(Rcode.FORMERR(), [ rrset ]) self.check_prerequisite_result(Rcode.FORMERR, [ rrset ])
# Class NONE, non-zero TTL # Class NONE, non-zero TTL
rrset = create_rrset("example.org", RRClass.NONE, RRType.SOA, 1) rrset = create_rrset("example.org", RRClass.NONE, RRType.SOA, 1)
self.check_prerequisite_result(Rcode.FORMERR(), [ rrset ]) self.check_prerequisite_result(Rcode.FORMERR, [ rrset ])
# Class NONE, but with rdata # Class NONE, but with rdata
rrset = create_rrset("example.org", RRClass.NONE, RRType.A, 0, rrset = create_rrset("example.org", RRClass.NONE, RRType.A, 0,
[ b'\x00\x00\x00\x00' ]) [ b'\x00\x00\x00\x00' ])
self.check_prerequisite_result(Rcode.FORMERR(), [ rrset ]) self.check_prerequisite_result(Rcode.FORMERR, [ rrset ])
# Matching class and type, but non-zero TTL # Matching class and type, but non-zero TTL
rrset = create_rrset("www.example.org", RRClass.IN, RRType.A, 1, rrset = create_rrset("www.example.org", RRClass.IN, RRType.A, 1,
[ "192.0.2.1" ]) [ "192.0.2.1" ])
self.check_prerequisite_result(Rcode.FORMERR(), [ rrset ]) self.check_prerequisite_result(Rcode.FORMERR, [ rrset ])
# Completely different class # Completely different class
rrset = create_rrset("example.org", RRClass.CH, RRType.TXT, 0, rrset = create_rrset("example.org", RRClass.CH, RRType.TXT, 0,
[ "foo" ]) [ "foo" ])
self.check_prerequisite_result(Rcode.FORMERR(), [ rrset ]) self.check_prerequisite_result(Rcode.FORMERR, [ rrset ])
def __prereq_helper(self, method, expected, rrset): def __prereq_helper(self, method, expected, rrset):
'''Calls the given method with self._datasrc_client '''Calls the given method with self._datasrc_client
@ -907,7 +907,7 @@ class SessionTest(SessionTestBase):
RRType.ANY, 0) RRType.ANY, 0)
# Test a prerequisite that would fail # Test a prerequisite that would fail
self.check_full_handle_result(Rcode.NXDOMAIN(), [], [ name_in_use_no ]) self.check_full_handle_result(Rcode.NXDOMAIN, [], [ name_in_use_no ])
# Change ACL so that it would be denied # Change ACL so that it would be denied
self._acl_map = {(TEST_ZONE_NAME, TEST_RRCLASS): self._acl_map = {(TEST_ZONE_NAME, TEST_RRCLASS):
@ -915,7 +915,7 @@ class SessionTest(SessionTestBase):
# The prerequisite should now not be reached; it should fail on the # The prerequisite should now not be reached; it should fail on the
# ACL # ACL
self.check_full_handle_result(Rcode.REFUSED(), [], [ name_in_use_no ]) self.check_full_handle_result(Rcode.REFUSED, [], [ name_in_use_no ])
def test_prescan(self): def test_prescan(self):
'''Test whether the prescan succeeds on data that is ok, and whether '''Test whether the prescan succeeds on data that is ok, and whether
@ -923,29 +923,29 @@ class SessionTest(SessionTestBase):
# prepare a set of correct update statements # prepare a set of correct update statements
self.__initialize_update_rrsets() self.__initialize_update_rrsets()
self.check_prescan_result(Rcode.NOERROR(), [ self.rrset_update_a ]) self.check_prescan_result(Rcode.NOERROR, [ self.rrset_update_a ])
# check if soa is noticed # check if soa is noticed
self.check_prescan_result(Rcode.NOERROR(), [ self.rrset_update_soa ], self.check_prescan_result(Rcode.NOERROR, [ self.rrset_update_soa ],
self.rrset_update_soa) self.rrset_update_soa)
# Other types of succesful prechecks # Other types of succesful prechecks
self.check_prescan_result(Rcode.NOERROR(), [ self.rrset_update_soa2 ], self.check_prescan_result(Rcode.NOERROR, [ self.rrset_update_soa2 ],
self.rrset_update_soa2) self.rrset_update_soa2)
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_del_name ]) [ self.rrset_update_del_name ])
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_del_name_apex ]) [ self.rrset_update_del_name_apex ])
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset ]) [ self.rrset_update_del_rrset ])
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_del_mx_apex ]) [ self.rrset_update_del_mx_apex ])
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset_part ]) [ self.rrset_update_del_rrset_part ])
# and check a few permutations of the above # and check a few permutations of the above
# all of them (with one of the soas) # all of them (with one of the soas)
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ [
self.rrset_update_a, self.rrset_update_a,
self.rrset_update_soa, self.rrset_update_soa,
@ -960,16 +960,16 @@ class SessionTest(SessionTestBase):
# Two soas. Should we reject or simply use the last? # Two soas. Should we reject or simply use the last?
# (RFC is not really explicit on this, but between the lines I read # (RFC is not really explicit on this, but between the lines I read
# use the last) # use the last)
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_soa, [ self.rrset_update_soa,
self.rrset_update_soa2 ], self.rrset_update_soa2 ],
self.rrset_update_soa2) self.rrset_update_soa2)
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ self.rrset_update_soa2, [ self.rrset_update_soa2,
self.rrset_update_soa ], self.rrset_update_soa ],
self.rrset_update_soa) self.rrset_update_soa)
self.check_prescan_result(Rcode.NOERROR(), self.check_prescan_result(Rcode.NOERROR,
[ [
self.rrset_update_del_mx_apex, self.rrset_update_del_mx_apex,
self.rrset_update_del_name, self.rrset_update_del_name,
@ -985,35 +985,35 @@ class SessionTest(SessionTestBase):
'''Test whether prescan fails on bad data''' '''Test whether prescan fails on bad data'''
# out of zone data # out of zone data
rrset = create_rrset("different.zone", RRClass.ANY, RRType.TXT, 0) rrset = create_rrset("different.zone", RRClass.ANY, RRType.TXT, 0)
self.check_prescan_result(Rcode.NOTZONE(), [ rrset ]) self.check_prescan_result(Rcode.NOTZONE, [ rrset ])
# forbidden type, zone class # forbidden type, zone class
rrset = create_rrset(TEST_ZONE_NAME, TEST_RRCLASS, RRType.ANY, 0, rrset = create_rrset(TEST_ZONE_NAME, TEST_RRCLASS, RRType.ANY, 0,
[ b'\x00' ]) [ b'\x00' ])
self.check_prescan_result(Rcode.FORMERR(), [ rrset ]) self.check_prescan_result(Rcode.FORMERR, [ rrset ])
# non-zero TTL, class ANY # non-zero TTL, class ANY
rrset = create_rrset(TEST_ZONE_NAME, RRClass.ANY, RRType.TXT, 1) rrset = create_rrset(TEST_ZONE_NAME, RRClass.ANY, RRType.TXT, 1)
self.check_prescan_result(Rcode.FORMERR(), [ rrset ]) self.check_prescan_result(Rcode.FORMERR, [ rrset ])
# non-zero Rdata, class ANY # non-zero Rdata, class ANY
rrset = create_rrset(TEST_ZONE_NAME, RRClass.ANY, RRType.TXT, 0, rrset = create_rrset(TEST_ZONE_NAME, RRClass.ANY, RRType.TXT, 0,
[ "foo" ]) [ "foo" ])
self.check_prescan_result(Rcode.FORMERR(), [ rrset ]) self.check_prescan_result(Rcode.FORMERR, [ rrset ])
# forbidden type, class ANY # forbidden type, class ANY
rrset = create_rrset(TEST_ZONE_NAME, RRClass.ANY, RRType.AXFR, 0, rrset = create_rrset(TEST_ZONE_NAME, RRClass.ANY, RRType.AXFR, 0,
[ b'\x00' ]) [ b'\x00' ])
self.check_prescan_result(Rcode.FORMERR(), [ rrset ]) self.check_prescan_result(Rcode.FORMERR, [ rrset ])
# non-zero TTL, class NONE # non-zero TTL, class NONE
rrset = create_rrset(TEST_ZONE_NAME, RRClass.NONE, RRType.TXT, 1) rrset = create_rrset(TEST_ZONE_NAME, RRClass.NONE, RRType.TXT, 1)
self.check_prescan_result(Rcode.FORMERR(), [ rrset ]) self.check_prescan_result(Rcode.FORMERR, [ rrset ])
# forbidden type, class NONE # forbidden type, class NONE
rrset = create_rrset(TEST_ZONE_NAME, RRClass.NONE, RRType.AXFR, 0, rrset = create_rrset(TEST_ZONE_NAME, RRClass.NONE, RRType.AXFR, 0,
[ b'\x00' ]) [ b'\x00' ])
self.check_prescan_result(Rcode.FORMERR(), [ rrset ]) self.check_prescan_result(Rcode.FORMERR, [ rrset ])
def __check_inzone_data(self, expected_result, name, rrtype, def __check_inzone_data(self, expected_result, name, rrtype,
expected_rrset = None): expected_rrset = None):
@ -1066,7 +1066,7 @@ class SessionTest(SessionTestBase):
self.orig_a_rrset) self.orig_a_rrset)
# Add two rrs # Add two rrs
self.check_full_handle_result(Rcode.NOERROR(), [ self.rrset_update_a ]) self.check_full_handle_result(Rcode.NOERROR, [ self.rrset_update_a ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
@ -1074,7 +1074,7 @@ class SessionTest(SessionTestBase):
extended_a_rrset) extended_a_rrset)
# Adding the same RRsets should not make a difference. # Adding the same RRsets should not make a difference.
self.check_full_handle_result(Rcode.NOERROR(), [ self.rrset_update_a ]) self.check_full_handle_result(Rcode.NOERROR, [ self.rrset_update_a ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
@ -1082,7 +1082,7 @@ class SessionTest(SessionTestBase):
extended_a_rrset) extended_a_rrset)
# Now delete those two, and we should end up with the original RRset # Now delete those two, and we should end up with the original RRset
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset_part ]) [ self.rrset_update_del_rrset_part ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
@ -1090,7 +1090,7 @@ class SessionTest(SessionTestBase):
self.orig_a_rrset) self.orig_a_rrset)
# 'Deleting' them again should make no difference # 'Deleting' them again should make no difference
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset_part ]) [ self.rrset_update_del_rrset_part ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
@ -1099,14 +1099,14 @@ class SessionTest(SessionTestBase):
# But deleting the entire rrset, independent of its contents, should # But deleting the entire rrset, independent of its contents, should
# work # work
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset ]) [ self.rrset_update_del_rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN, self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A) RRType.A)
# Check that if we update the SOA, it is updated to our value # Check that if we update the SOA, it is updated to our value
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_soa2 ]) [ self.rrset_update_soa2 ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("example.org"), isc.dns.Name("example.org"),
@ -1126,7 +1126,7 @@ class SessionTest(SessionTestBase):
RRClass.ANY, RRClass.ANY,
RRType.A, RRType.A,
0) 0)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ rrset_delete_glue ]) [ rrset_delete_glue ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("sub.example.org."), isc.dns.Name("sub.example.org."),
@ -1141,7 +1141,7 @@ class SessionTest(SessionTestBase):
RRClass.ANY, RRClass.ANY,
RRType.A, RRType.A,
0) 0)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ rrset_delete_nonexistent_glue ]) [ rrset_delete_nonexistent_glue ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("sub.example.org."), isc.dns.Name("sub.example.org."),
@ -1157,7 +1157,7 @@ class SessionTest(SessionTestBase):
RRType.A) RRType.A)
rrset = create_rrset("new.example.org", TEST_RRCLASS, RRType.A, rrset = create_rrset("new.example.org", TEST_RRCLASS, RRType.A,
3600, [ "192.0.2.1", "192.0.2.2" ]) 3600, [ "192.0.2.1", "192.0.2.2" ])
self.check_full_handle_result(Rcode.NOERROR(), [ rrset ]) self.check_full_handle_result(Rcode.NOERROR, [ rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("new.example.org"), isc.dns.Name("new.example.org"),
RRType.A, RRType.A,
@ -1170,7 +1170,7 @@ class SessionTest(SessionTestBase):
RRType.TXT) RRType.TXT)
rrset = create_rrset("new.example.org", TEST_RRCLASS, RRType.TXT, rrset = create_rrset("new.example.org", TEST_RRCLASS, RRType.TXT,
3600, [ "foo" ]) 3600, [ "foo" ])
self.check_full_handle_result(Rcode.NOERROR(), [ rrset ]) self.check_full_handle_result(Rcode.NOERROR, [ rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("new.example.org"), isc.dns.Name("new.example.org"),
RRType.TXT, RRType.TXT,
@ -1200,7 +1200,7 @@ class SessionTest(SessionTestBase):
rrset3 = create_rrset("new_a.example.org", TEST_RRCLASS, RRType.A, rrset3 = create_rrset("new_a.example.org", TEST_RRCLASS, RRType.A,
3600, [ "192.0.2.2" ]) 3600, [ "192.0.2.2" ])
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ rrset1, rrset2, rrset3 ]) [ rrset1, rrset2, rrset3 ])
# The update should have merged rrset1 and rrset3 # The update should have merged rrset1 and rrset3
@ -1230,14 +1230,14 @@ class SessionTest(SessionTestBase):
RRType.A) RRType.A)
# Delete the entire name # Delete the entire name
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_name ]) [ self.rrset_update_del_name ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN, self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A) RRType.A)
# Should still be gone after pointless second delete # Should still be gone after pointless second delete
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_name ]) [ self.rrset_update_del_name ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN, self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
@ -1285,7 +1285,7 @@ class SessionTest(SessionTestBase):
# Check that we cannot delete the SOA record by direct deletion # Check that we cannot delete the SOA record by direct deletion
# both by name+type and by full rrset # both by name+type and by full rrset
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_soa_apex, [ self.rrset_update_del_soa_apex,
self.rrset_update_soa_del ]) self.rrset_update_soa_del ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
@ -1295,7 +1295,7 @@ class SessionTest(SessionTestBase):
# If we delete everything at the apex, the SOA and NS rrsets should be # If we delete everything at the apex, the SOA and NS rrsets should be
# untouched (but serial will be incremented) # untouched (but serial will be incremented)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_name_apex ]) [ self.rrset_update_del_name_apex ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("example.org"), isc.dns.Name("example.org"),
@ -1312,7 +1312,7 @@ class SessionTest(SessionTestBase):
# Deleting the NS rrset by name and type only, it should also be left # Deleting the NS rrset by name and type only, it should also be left
# untouched # untouched
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_ns_apex ]) [ self.rrset_update_del_ns_apex ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("example.org"), isc.dns.Name("example.org"),
@ -1327,7 +1327,7 @@ class SessionTest(SessionTestBase):
short_ns_rrset = create_rrset("example.org", TEST_RRCLASS, short_ns_rrset = create_rrset("example.org", TEST_RRCLASS,
RRType.NS, 3600, RRType.NS, 3600,
[ "ns3.example.org." ]) [ "ns3.example.org." ])
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset_ns ]) [ self.rrset_update_del_rrset_ns ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("example.org"), isc.dns.Name("example.org"),
@ -1341,7 +1341,7 @@ class SessionTest(SessionTestBase):
new_ns = create_rrset("example.org", TEST_RRCLASS, RRType.NS, 3600, new_ns = create_rrset("example.org", TEST_RRCLASS, RRType.NS, 3600,
[ "newns1.example.org", "newns2.example.org" ]) [ "newns1.example.org", "newns2.example.org" ])
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ new_ns, [ new_ns,
self.rrset_update_del_rrset_ns ]) self.rrset_update_del_rrset_ns ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
@ -1359,7 +1359,7 @@ class SessionTest(SessionTestBase):
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("example.org"), isc.dns.Name("example.org"),
RRType.MX) RRType.MX)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset_mx ]) [ self.rrset_update_del_rrset_mx ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET, self.__check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
isc.dns.Name("example.org"), isc.dns.Name("example.org"),
@ -1372,7 +1372,7 @@ class SessionTest(SessionTestBase):
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A) RRType.A)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_a, [ self.rrset_update_a,
self.rrset_update_del_rrset ]) self.rrset_update_del_rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN, self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
@ -1386,7 +1386,7 @@ class SessionTest(SessionTestBase):
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A) RRType.A)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_a, [ self.rrset_update_a,
self.rrset_update_del_name ]) self.rrset_update_del_name ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN, self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
@ -1400,7 +1400,7 @@ class SessionTest(SessionTestBase):
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A) RRType.A)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_rrset, [ self.rrset_update_del_rrset,
self.rrset_update_a ]) self.rrset_update_a ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
@ -1415,7 +1415,7 @@ class SessionTest(SessionTestBase):
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A) RRType.A)
self.check_full_handle_result(Rcode.NOERROR(), self.check_full_handle_result(Rcode.NOERROR,
[ self.rrset_update_del_name, [ self.rrset_update_del_name,
self.rrset_update_a ]) self.rrset_update_a ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
@ -1439,7 +1439,7 @@ class SessionTest(SessionTestBase):
rrset = create_rrset("cname.example.org", TEST_RRCLASS, RRType.A, rrset = create_rrset("cname.example.org", TEST_RRCLASS, RRType.A,
3600, [ "192.0.2.1" ]) 3600, [ "192.0.2.1" ])
self.check_full_handle_result(Rcode.NOERROR(), [ rrset ]) self.check_full_handle_result(Rcode.NOERROR, [ rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME, self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
isc.dns.Name("cname.example.org"), isc.dns.Name("cname.example.org"),
RRType.A, RRType.A,
@ -1449,7 +1449,7 @@ class SessionTest(SessionTestBase):
new_cname_rrset = create_rrset("cname.example.org", TEST_RRCLASS, new_cname_rrset = create_rrset("cname.example.org", TEST_RRCLASS,
RRType.CNAME, 3600, RRType.CNAME, 3600,
[ "mail.example.org." ]) [ "mail.example.org." ])
self.check_full_handle_result(Rcode.NOERROR(), [ new_cname_rrset ]) self.check_full_handle_result(Rcode.NOERROR, [ new_cname_rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME, self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
isc.dns.Name("cname.example.org"), isc.dns.Name("cname.example.org"),
RRType.A, RRType.A,
@ -1466,7 +1466,7 @@ class SessionTest(SessionTestBase):
new_cname_rrset = create_rrset("www.example.org", TEST_RRCLASS, new_cname_rrset = create_rrset("www.example.org", TEST_RRCLASS,
RRType.CNAME, 3600, RRType.CNAME, 3600,
[ "mail.example.org." ]) [ "mail.example.org." ])
self.check_full_handle_result(Rcode.NOERROR(), [ new_cname_rrset ]) self.check_full_handle_result(Rcode.NOERROR, [ new_cname_rrset ])
self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS, self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
isc.dns.Name("www.example.org"), isc.dns.Name("www.example.org"),
RRType.A, RRType.A,
@ -1475,13 +1475,13 @@ class SessionTest(SessionTestBase):
def test_update_bad_class(self): def test_update_bad_class(self):
rrset = create_rrset("example.org.", RRClass.CH, RRType.TXT, 0, rrset = create_rrset("example.org.", RRClass.CH, RRType.TXT, 0,
[ "foo" ]) [ "foo" ])
self.check_full_handle_result(Rcode.FORMERR(), [ rrset ]) self.check_full_handle_result(Rcode.FORMERR, [ rrset ])
def test_uncaught_exception(self): def test_uncaught_exception(self):
def my_exc(): def my_exc():
raise Exception("foo") raise Exception("foo")
self._session._UpdateSession__update_soa = my_exc self._session._UpdateSession__update_soa = my_exc
self.assertEqual(Rcode.SERVFAIL().to_text(), self.assertEqual(Rcode.SERVFAIL.to_text(),
self._session._UpdateSession__do_update().to_text()) self._session._UpdateSession__do_update().to_text())
class SessionACLTest(SessionTestBase): class SessionACLTest(SessionTestBase):
@ -1527,7 +1527,7 @@ class SessionACLTest(SessionTestBase):
self._datasrc_client, self._datasrc_client,
acl_map)) acl_map))
self.assertEqual((UPDATE_ERROR, None, None), session.handle()) self.assertEqual((UPDATE_ERROR, None, None), session.handle())
self.check_response(session.get_message(), Rcode.REFUSED()) self.check_response(session.get_message(), Rcode.REFUSED)
# If the message contains TSIG, it should match the ACCEPT # If the message contains TSIG, it should match the ACCEPT
# ACL entry, and the request should be granted. # ACL entry, and the request should be granted.

6
src/lib/python/isc/notify/notify_out.py
View File

@ -509,8 +509,8 @@ class NotifyOut:
msg = Message(Message.RENDER) msg = Message(Message.RENDER)
qid = random.randint(0, 0xFFFF) qid = random.randint(0, 0xFFFF)
msg.set_qid(qid) msg.set_qid(qid)
msg.set_opcode(Opcode.NOTIFY()) msg.set_opcode(Opcode.NOTIFY)
msg.set_rcode(Rcode.NOERROR()) msg.set_rcode(Rcode.NOERROR)
msg.set_header_flag(Message.HEADERFLAG_AA) msg.set_header_flag(Message.HEADERFLAG_AA)
msg.add_question(Question(zone_name, zone_class, RRType.SOA)) msg.add_question(Question(zone_name, zone_class, RRType.SOA))
msg.add_rrset(Message.SECTION_ANSWER, self._get_zone_soa(zone_name, msg.add_rrset(Message.SECTION_ANSWER, self._get_zone_soa(zone_name,
@ -566,7 +566,7 @@ class NotifyOut:
Name(zone_notify_info.zone_name).to_text()) Name(zone_notify_info.zone_name).to_text())
return _BAD_QUERY_NAME return _BAD_QUERY_NAME
if msg.get_opcode() != Opcode.NOTIFY(): if msg.get_opcode() != Opcode.NOTIFY:
logger.warn(NOTIFY_OUT_REPLY_BAD_OPCODE, from_addr[0], logger.warn(NOTIFY_OUT_REPLY_BAD_OPCODE, from_addr[0],
from_addr[1], msg.get_opcode().to_text()) from_addr[1], msg.get_opcode().to_text())
return _BAD_OPCODE return _BAD_OPCODE

2
tools/query_cmp/src/lib/handledns.py
View File

@ -187,7 +187,7 @@ def send_req(query, server, port=53, timeout=5):
msg = Message(Message.RENDER) msg = Message(Message.RENDER)
msg.set_qid(int(qheader['id'])) msg.set_qid(int(qheader['id']))
msg.set_opcode(Opcode.QUERY()) msg.set_opcode(Opcode.QUERY)
msg.set_rcode(Rcode(int(qheader['rcode']))) msg.set_rcode(Rcode(int(qheader['rcode'])))
if qheader['qr'] == 1: if qheader['qr'] == 1: