def setUp(self, *mocks):
super(MdnsServiceTest, self).setUp()
mdns.CONF = RoObject({'service:mdns': RoObject(storage_driver=None)})
# _rpc_endpoints is a property
mock_rpc_endpoints = mocks[0]
mock_rpc_endpoints.__get__ = mock.Mock(
return_value=[mock.MagicMock(), mock.MagicMock()])
self.mdns = mdns.Service()
self.mdns.tg = mock.Mock(name='tg')
def test_make_and_send_dns_message_nxdomain(self):
zone = RoObject(name='zn')
self.notify._make_dns_message = mock.Mock(return_value='')
response = RoObject(rcode=mock.Mock(return_value=dns.rcode.NXDOMAIN))
self.notify._send_dns_message = mock.Mock(return_value=response)
out = self.notify._make_and_send_dns_message(zone, 'host', 123, 1, 2,
3)
self.assertEqual((response, 1), out)
def setUp(self, *mocks):
super(BackendAgentTest, self).setUp()
agent.CONF = RoObject({'service:mdns': RoObject(all_tcp=False)})
self.agent = SCAgentPoolBackend()
self.agent.timeout = 1
self.agent.host = 2
self.agent.port = 3
self.agent.retry_interval = 4
self.agent.max_retries = 5
self.agent.delay = 6
def test_send_dns_message_tcp(self, *mocks):
agent.CONF = RoObject({
'service:mdns': RoObject(all_tcp=True)
})
mocks[1].return_value = 'mock tcp resp'
out = self.agent._send_dns_message('msg', 'host', 123, 1)
assert not agent.dns_query.udp.called
agent.dns_query.tcp.assert_called_with('msg', 'host', port=123,
timeout=1)
self.assertEqual('mock tcp resp', out)
def test_get_serial_number_nxdomain(self, *mocks):
response = RoObject(answer=[
RoObject(rdclass=dns.rdataclass.IN, rdtype=dns.rdatatype.SOA)
],
rcode=Mock(return_value=dns.rcode.NXDOMAIN))
zone = RoObject(name='zn', serial=314)
self.notify._make_and_send_dns_message = Mock(return_value=(response,
1))
out = self.notify.get_serial_number('c', zone, 'h', 1234, 1, 2, 3, 4)
self.assertEqual(('NO_ZONE', None, 0), out)
def test_get_serial_number_nxdomain_deleted_zone(self, mock_sleep):
# The zone is not found and it's not was supposed be there
response = RoObject(answer=[
RoObject(rdclass=dns.rdataclass.IN, rdtype=dns.rdatatype.SOA)
],
rcode=mock.Mock(return_value=dns.rcode.NXDOMAIN))
zone = RoObject(name='zn', serial=0, action='DELETE')
self.notify._make_and_send_dns_message = mock.Mock(
return_value=(response, 1))
out = self.notify.get_serial_number('c', zone, 'h', 1234, 1, 2, 3, 4)
self.assertEqual(('NO_ZONE', 0, 3), out)
def test_make_and_send_dns_message_error_flags(self, *mocks):
zone = RoObject(name='zn')
self.notify._make_dns_message = Mock(return_value='')
response = RoObject(
rcode=Mock(return_value=dns.rcode.NOERROR),
# rcode is NOERROR but flags are not NOERROR
flags=123,
ednsflags=321)
self.notify._send_dns_message = Mock(return_value=response)
out = self.notify._make_and_send_dns_message(zone, 'host', 123, 1, 2,
3)
self.assertEqual((None, 1), out)
def test_make_and_send_dns_message_missing_AA_flags(self, *mocks):
zone = RoObject(name='zn')
self.notify._make_dns_message = Mock(return_value='')
response = RoObject(
rcode=Mock(return_value=dns.rcode.NOERROR),
# rcode is NOERROR but (flags & dns.flags.AA) gives 0
flags=0,
)
self.notify._send_dns_message = Mock(return_value=response)
out = self.notify._make_and_send_dns_message(zone, 'host', 123, 1, 2,
3)
self.assertEqual((None, 1), out)
def setUp(self):
zms.CONF = RoObject({
'service:zone_manager': RoObject({
'enabled_tasks': None, # enable all tasks
'export_synchronous': True
}),
'zone_manager_task:zone_purge': '',
})
super(ZoneManagerTest, self).setUp()
self.tm = zms.Service()
self.tm._storage = mock.Mock()
self.tm._rpc_server = mock.Mock()
self.tm._quota = mock.Mock()
self.tm.quota.limit_check = mock.Mock()
def test_get_serial_number_too_many_retries(self, mock_sleep):
zone = RoObject(name='zn', serial=314)
ds = RoObject(items=[RoObject(serial=310)])
response = RoObject(answer=[
RoObject(name='zn',
rdclass=dns.rdataclass.IN,
rdtype=dns.rdatatype.SOA,
to_rdataset=mock.Mock(return_value=ds))
],
rcode=mock.Mock(return_value=dns.rcode.NOERROR))
self.notify._make_and_send_dns_message = mock.Mock(
return_value=(response, 1))
out = self.notify.get_serial_number('c', zone, 'h', 1234, 1, 2, 3, 4)
self.assertEqual(('ERROR', 310, 0), out)
def test_periodic_recover(self, mock_get_ctx, *mocks):
z = RoObject(name='a_zone')
def mock_get_failed_zones(ctx, action):
if action == pm_module.DELETE_ACTION:
return [z] * 3
if action == pm_module.CREATE_ACTION:
return [z] * 4
if action == pm_module.UPDATE_ACTION:
return [z] * 5
self.pm._get_failed_zones = mock_get_failed_zones
self.pm.delete_zone = Mock()
self.pm.create_zone = Mock()
self.pm.update_zone = Mock()
mock_ctx = mock_get_ctx.return_value
self.pm.periodic_recovery()
self.pm.delete_zone.assert_called_with(mock_ctx, z)
self.assertEqual(3, self.pm.delete_zone.call_count)
self.pm.create_zone.assert_called_with(mock_ctx, z)
self.assertEqual(4, self.pm.create_zone.call_count)
self.pm.update_zone.assert_called_with(mock_ctx, z)
self.assertEqual(5, self.pm.update_zone.call_count)
def test_get_serial_number_ok(self, *mocks):
zone = RoObject(name='zn', serial=314)
ds = RoObject(items=[zone])
response = RoObject(answer=[
RoObject(name='zn',
rdclass=dns.rdataclass.IN,
rdtype=dns.rdatatype.SOA,
to_rdataset=Mock(return_value=ds))
],
rcode=Mock(return_value=dns.rcode.NOERROR))
self.notify._make_and_send_dns_message = Mock(return_value=(response,
1))
out = self.notify.get_serial_number('c', zone, 'h', 1234, 1, 2, 3, 4)
self.assertEqual(('SUCCESS', 314, 3), out)
def setUp(self):
super(PeriodicSecondaryRefreshTest, self).setUp()
opts = {
"producer_task:periodic_secondary_refresh":
RoObject({"per_page": 100})
}
self.setup_opts(opts)
# Mock a ctxt...
self.ctxt = mock.Mock()
self.useFixture(
fixtures.MockPatchObject(context.DesignateContext,
'get_admin_context',
return_value=self.ctxt))
# Mock a central...
self.central = mock.Mock()
self.useFixture(
fixtures.MockPatchObject(central_api.CentralAPI,
'get_instance',
return_value=self.central))
self.task = tasks.PeriodicSecondaryRefreshTask()
self.task.my_partitions = 0, 9
def test_iter_zones(self, get_central):
# Test that the iteration code is working properly.
central = mock.Mock()
get_central.return_value = central
ctxt = mock.Mock()
iterer = self.task._iter_zones(ctxt)
items = [RoObject(id=generate_uuid()) for i in range(0, 5)]
central.find_zones.return_value = items
# Iterate through the items causing the "paging" to be done.
list(map(lambda i: next(iterer), items))
central.find_zones.assert_called_once_with(ctxt,
{"shard": "BETWEEN 0,9"},
limit=100)
central.find_zones.reset_mock()
# Call next on the iterator and see it trying to load a new page.
# Also this will raise a StopIteration since there are no more items.
central.find_zones.return_value = []
self.assertRaises(StopIteration, next, iterer)
central.find_zones.assert_called_once_with(ctxt,
{"shard": "BETWEEN 0,9"},
marker=items[-1].id,
limit=100)
def test_periodic_recover_exception(self, mock_get_ctx, *mocks):
z = RoObject(name='a_zone')
# Raise an exception half through the recovery
def mock_get_failed_zones(ctx, action):
if action == pm_module.DELETE_ACTION:
return [z] * 3
if action == pm_module.CREATE_ACTION:
return [z] * 4
self.pm._get_failed_zones = mock_get_failed_zones
self.pm.pool_manager_api.delete_zone = Mock()
self.pm.pool_manager_api.create_zone = Mock(
side_effect=Exception('oops'))
self.pm.pool_manager_api.update_zone = Mock()
mock_ctx = mock_get_ctx.return_value
self.pm.periodic_recovery()
self.pm.pool_manager_api.delete_zone.assert_called_with(mock_ctx, z)
self.assertEqual(3, self.pm.pool_manager_api.delete_zone.call_count)
self.pm.pool_manager_api.create_zone.assert_called_with(mock_ctx, z)
self.assertEqual(1, self.pm.pool_manager_api.create_zone.call_count)
self.assertEqual(0, self.pm.pool_manager_api.update_zone.call_count)
def test_delete_zone_exception(self, *mock):
self.agent._make_and_send_dns_message = Mock(return_value=(None, 2))
with testtools.ExpectedException(exceptions.Backend):
self.agent.delete_zone('ctx', RoObject(name='zn'))
self.agent._make_and_send_dns_message.assert_called_with(
'zn', 1, 14, pcodes.DELETE, pcodes.SUCCESS, 2, 3)
def test_delete_zone(self, *mock):
self.agent._make_and_send_dns_message = Mock(return_value=(1, 2))
out = self.agent.delete_zone('ctx', RoObject(name='zn'))
self.agent._make_and_send_dns_message.assert_called_with(
'zn', 1, 14, pcodes.DELETE, pcodes.SUCCESS, 2, 3)
self.assertIsNone(out)
def test_create_zone(self, *mock):
self.agent._make_and_send_dns_message = Mock(return_value=(1, 2))
out = self.agent.create_zone('ctx', RoObject(name='zn'))
self.agent._make_and_send_dns_message.assert_called_with(
'zn', 1, 14, agent.CREATE, agent.SUCCESS, 2, 3)
self.assertEqual(None, out)
def setUp(self):
self.useFixture(cfg_fixture.Config(CONF))
service.CONF = RoObject({
'service:producer': RoObject({
'enabled_tasks': None, # enable all tasks
}),
'producer_task:zone_purge': '',
})
super(ProducerTest, self).setUp()
self.stdlog = fixtures.StandardLogging()
self.useFixture(self.stdlog)
self.service = service.Service()
self.service.rpc_server = mock.Mock()
self.service._storage = mock.Mock()
self.service._quota = mock.Mock()
self.service._quota.limit_check = mock.Mock()
def test_make_and_send_dns_message_timeout(self, *mocks):
zone = RoObject(name='zn')
self.notify._make_dns_message = Mock(return_value='')
self.notify._send_dns_message = Mock(side_effect=dns.exception.Timeout)
out = self.notify._make_and_send_dns_message(zone, 'host', 123, 1, 2,
3)
self.assertEqual((None, 3), out)
def test_update_zone(self, *mock):
self.agent.mdns_api.notify_zone_changed = Mock()
zone = RoObject(name='zn')
out = self.agent.update_zone('ctx', zone)
self.agent.mdns_api.notify_zone_changed.assert_called_with(
'ctx', zone, 2, 3, 1, 4, 5, 6)
self.assertIsNone(out)
def setup_opts(self, config):
opts = RoObject(**config)
self.opts = opts
self.opts_patcher = mock.patch('oslo_config.cfg.CONF')
self.addCleanup(self.opts_patcher.stop)
self.opts_mock = self.opts_patcher.start()
self.opts_mock.__getitem__.side_effect = lambda n: opts[n]
def test_make_and_send_dns_message(self):
self.backend._make_dns_message = mock.Mock(return_value='')
response = RoObject(rcode=mock.Mock(return_value=dns.rcode.NOERROR),
flags=agent.dns.flags.AA,
ednsflags=321)
self.backend._send_dns_message = mock.Mock(return_value=response)
out = self.backend._make_and_send_dns_message('h', 123, 1, 2, 3, 4, 5)
self.assertEqual((response, 0), out)
def test_poll_for_serial_number(self, *mocks):
self.notify.get_serial_number = Mock(return_value=('status', 99, 9))
ns = RoObject(host='host', port=1234)
self.notify.poll_for_serial_number('c', 'z', ns, 1, 2, 3, 4)
self.notify.get_serial_number.assert_called_with(
'c', 'z', 'host', 1234, 1, 2, 3, 4)
self.notify.pool_manager_api.update_status.assert_called_with(
'c', 'z', ns, 'status', 99)
def test_make_and_send_dns_message_bad_response(self):
zone = RoObject(name='zn')
self.notify._make_dns_message = mock.Mock(return_value='')
self.notify._send_dns_message = mock.Mock(
side_effect=notify.dns_query.BadResponse)
out = self.notify._make_and_send_dns_message(zone, 'host', 123, 1, 2,
3)
self.assertEqual((None, 1), out)
def setUp(self):
self.useFixture(cfg_fixture.Config(CONF))
service.CONF = RoObject({
'service:producer': RoObject({
'enabled_tasks': None, # enable all tasks
}),
# TODO(timsim): Remove this
'service:zone_manager': RoObject({
'enabled_tasks': None, # enable all tasks
'export_synchronous': True
}),
'producer_task:zone_purge': '',
})
super(ProducerTest, self).setUp()
self.service = service.Service()
self.service._storage = mock.Mock()
self.service._rpc_server = mock.Mock()
self.service._quota = mock.Mock()
self.service.quota.limit_check = mock.Mock()
def test_make_and_send_dns_message_econnrefused(self):
# bug #1558096
zone = RoObject(name='zn')
self.notify._make_dns_message = mock.Mock(return_value='')
socket_error = socket.error()
socket_error.errno = socket.errno.ECONNREFUSED
# socket errors other than EAGAIN should raise
self.notify._send_dns_message = mock.Mock(side_effect=socket_error)
self.assertRaises(socket.error, self.notify._make_and_send_dns_message,
zone, 'host', 123, 1, 2, 3)
def test_make_and_send_dns_message_error_flags(self):
self.backend._make_dns_message = mock.Mock(return_value='')
response = RoObject(
rcode=mock.Mock(return_value=dns.rcode.NOERROR),
# rcode is NOERROR but flags are not NOERROR
flags=123,
ednsflags=321)
self.backend._send_dns_message = mock.Mock(return_value=response)
out = self.backend._make_and_send_dns_message('h', 123, 1, 2, 3, 4, 5)
self.assertEqual((None, 0), out)
def test_make_and_send_dns_message_missing_AA_flags(self):
self.backend._make_dns_message = mock.Mock(return_value='')
response = RoObject(
rcode=mock.Mock(return_value=dns.rcode.NOERROR),
# rcode is NOERROR but (flags & dns.flags.AA) gives 0
flags=0,
)
self.backend._send_dns_message = mock.Mock(return_value=response)
out = self.backend._make_and_send_dns_message('h', 123, 1, 2, 3, 4, 5)
self.assertEqual((None, 0), out)
def test_start_zone_export(self, _):
zone = RoObject(id=3)
context = mock.Mock()
export = {}
self.tm.storage.count_recordsets.return_value = 1
assert self.tm.storage.count_recordsets() == 1
self.tm._determine_export_method = mock.Mock()
self.tm.start_zone_export(context, zone, export)
assert self.tm._determine_export_method.called
assert self.tm.central_api.update_zone_export.called
call_args = self.tm._determine_export_method.call_args_list[0][0]
self.assertEqual((context, export, 1), call_args)