class SchedulerClientTestCase(test.TestCase):
def setUp(self):
super(SchedulerClientTestCase, self).setUp()
self.client = scheduler_client.SchedulerClient()
def test_constructor(self):
self.assertIsNotNone(self.client.queryclient)
self.assertIsNotNone(self.client.reportclient)
@mock.patch.object(scheduler_query_client.SchedulerQueryClient,
'select_destinations')
def test_select_destinations(self, mock_select_destinations):
self.assertIsNone(self.client.queryclient.instance)
self.client.select_destinations('ctxt', 'fake_spec', 'fake_prop')
self.assertIsNotNone(self.client.queryclient.instance)
mock_select_destinations.assert_called_once_with(
'ctxt', 'fake_spec', 'fake_prop')
@mock.patch.object(scheduler_query_client.SchedulerQueryClient,
'select_destinations',
side_effect=messaging.MessagingTimeout())
def test_select_destinations_timeout(self, mock_select_destinations):
# check if the scheduler service times out properly
fake_args = ['ctxt', 'fake_spec', 'fake_prop']
self.assertRaises(messaging.MessagingTimeout,
self.client.select_destinations, *fake_args)
mock_select_destinations.assert_has_calls([mock.call(*fake_args)] * 2)
@mock.patch.object(
scheduler_query_client.SchedulerQueryClient,
'select_destinations',
side_effect=[messaging.MessagingTimeout(), mock.DEFAULT])
def test_select_destinations_timeout_once(self, mock_select_destinations):
# scenario: the scheduler service times out & recovers after failure
fake_args = ['ctxt', 'fake_spec', 'fake_prop']
self.client.select_destinations(*fake_args)
mock_select_destinations.assert_has_calls([mock.call(*fake_args)] * 2)
@mock.patch.object(scheduler_report_client.SchedulerReportClient,
'update_resource_stats')
def test_update_resource_stats(self, mock_update_resource_stats):
self.assertIsNone(self.client.reportclient.instance)
self.client.update_resource_stats('ctxt', 'fake_name', 'fake_stats')
self.assertIsNotNone(self.client.reportclient.instance)
mock_update_resource_stats.assert_called_once_with(
'ctxt', 'fake_name', 'fake_stats')
def _send(self, target, ctxt, message, wait_for_reply=None, timeout=None):
self._check_serialize(message)
exchange = self._exchange_manager.get_exchange(target.exchange)
reply_q = None
if wait_for_reply:
reply_q = moves.queue.Queue()
exchange.deliver_message(target.topic,
ctxt,
message,
server=target.server,
fanout=target.fanout,
reply_q=reply_q)
if wait_for_reply:
try:
reply, failure = reply_q.get(timeout=timeout)
if failure:
raise failure
else:
return reply
except moves.queue.Empty:
raise messaging.MessagingTimeout('No reply on topic %s' %
target.topic)
return None
def get_reply(self, timeout):
"""Retrieve the reply."""
if not self._reply_queue:
return None
try:
return self._reply_queue.get(timeout=timeout)
except moves.queue.Empty:
raise messaging.MessagingTimeout('Timed out waiting for a reply')
def test_engine_alive_timeout(self):
slock = stack_lock.StackLock(self.context, self.stack, self.engine_id)
mget_client = self.patchobject(stack_lock.rpc_messaging,
'get_rpc_client')
mclient = mget_client.return_value
mclient_ctx = mclient.prepare.return_value
mclient_ctx.call.side_effect = messaging.MessagingTimeout('too slow')
ret = slock.engine_alive(self.context, self.engine_id)
self.assertIs(False, ret)
mclient.prepare.assert_called_once_with(timeout=2)
mclient_ctx.call.assert_called_once_with(self.context, 'listening')
class ApiV2NameServersTest(ApiV2TestCase):
def setUp(self):
super(ApiV2NameServersTest, self).setUp()
# Create a domain
self.domain = self.create_domain()
def test_get_nameservers(self):
url = '/zones/%s/nameservers' % self.domain['id']
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('nameservers', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 0 nameservers
self.assertEqual(1, len(response.json['nameservers']))
servers = self.central_service.get_domain_servers(
self.admin_context, self.domain['id'])
self.assertEqual(servers[0]['id'],
response.json['nameservers'][0]['id'])
self.assertEqual(servers[0]['name'],
response.json['nameservers'][0]['name'])
self.create_server(name='nsx.mydomain.com.')
response = self.client.get(url)
self.assertEqual(2, len(response.json['nameservers']))
def test_get_nameservers_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s/nameservers')
@patch.object(central_service.Service,
'get_domain_servers',
side_effect=messaging.MessagingTimeout())
def test_get_nameservers_timeout(self, _):
url = '/zones/ba751950-6193-11e3-949a-0800200c9a66/nameservers'
self._assert_exception('timeout', 504, self.client.get, url)
def test_get_dvr_mac_address_retried_max(self):
raise_timeout = messaging.MessagingTimeout()
# Raise a timeout every time until we give up, currently 5 tries
self._setup_for_dvr_test()
self.agent.dvr_agent.dvr_mac_address = None
with contextlib.nested(
mock.patch.object(self.agent.dvr_agent.plugin_rpc,
'get_dvr_mac_address_by_host',
side_effect=raise_timeout),
mock.patch.object(utils, "execute"),
) as (rpc_mock, execute_mock):
self.agent.dvr_agent.get_dvr_mac_address()
self.assertIsNone(self.agent.dvr_agent.dvr_mac_address)
self.assertFalse(self.agent.dvr_agent.in_distributed_mode())
self.assertEqual(self.agent.dvr_agent.plugin_rpc.
get_dvr_mac_address_by_host.call_count, 5)
def test_get_dvr_mac_address_retried(self):
valid_entry = {'host': 'cn1', 'mac_address': 'aa:22:33:44:55:66'}
raise_timeout = messaging.MessagingTimeout()
# Raise a timeout the first 2 times it calls get_dvr_mac_address()
self._setup_for_dvr_test()
self.agent.dvr_agent.dvr_mac_address = None
with mock.patch.object(self.agent.dvr_agent.plugin_rpc,
'get_dvr_mac_address_by_host',
side_effect=(raise_timeout, raise_timeout,
valid_entry)):
self.agent.dvr_agent.get_dvr_mac_address()
self.assertEqual('aa:22:33:44:55:66',
self.agent.dvr_agent.dvr_mac_address)
self.assertTrue(self.agent.dvr_agent.in_distributed_mode())
self.assertEqual(self.agent.dvr_agent.plugin_rpc.
get_dvr_mac_address_by_host.call_count, 3)
def _poll_connection(self, msg_id, timeout):
while True:
while self.incoming:
message_data = self.incoming.pop(0)
incoming_msg_id = message_data.pop('_msg_id', None)
if incoming_msg_id == msg_id:
return self._process_reply(message_data)
self.waiters.put(incoming_msg_id, message_data)
try:
self.conn.consume(limit=1, timeout=timeout)
except rpc_common.Timeout:
raise messaging.MessagingTimeout('Timed out waiting for a '
'reply to message ID %s'
% msg_id)
def get(self, msg_id, timeout):
try:
return self._queues[msg_id].get(block=True, timeout=timeout)
except moves.queue.Empty:
raise messaging.MessagingTimeout('Timed out waiting for a reply '
'to message ID %s' % msg_id)
class ApiV1ServersTest(ApiV1Test):
def setUp(self):
super(ApiV1ServersTest, self).setUp()
# All Server Checks should be performed as an admin, so..
# Override to policy to make everyone an admin.
self.policy({'admin': '@'})
def test_create_server(self):
# Create a server
fixture = self.get_server_fixture(0)
response = self.post('servers', data=fixture)
self.assertIn('id', response.json)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], fixture['name'])
def test_create_server_junk(self):
# Create a server
fixture = self.get_server_fixture(0)
# Add a junk property
fixture['junk'] = 'Junk Field'
# Ensure it fails with a 400
self.post('servers', data=fixture, status_code=400)
def test_create_server_with_invalid_name(self):
# Create a server
fixture = self.get_server_fixture(0)
# Add a invalid name
fixture['name'] = '$#$%^^'
# Ensure it fails with a 400
self.post('servers', data=fixture, status_code=400)
@patch.object(central_service.Service, 'update_pool',
side_effect=messaging.MessagingTimeout())
def test_create_server_timeout(self, _):
# Create a server
fixture = self.get_server_fixture(0)
self.post('servers', data=fixture, status_code=504)
@patch.object(central_service.Service, 'update_pool',
side_effect=exceptions.DuplicateServer())
def test_create_server_duplicate(self, _):
# Create a server
fixture = self.get_server_fixture(0)
self.post('servers', data=fixture, status_code=409)
def test_get_servers(self):
# Fetch the default pool
pool = self.storage.get_pool(self.admin_context, default_pool_id)
# Fetch the list of servers
response = self.get('servers')
self.assertIn('servers', response.json)
self.assertEqual(len(pool.ns_records), len(response.json['servers']))
# Add a new NS record to the pool
pool.ns_records.append(
objects.PoolNsRecord(priority=0, hostname='new-ns1.example.org.'))
# Save the pool to add a new nameserver
self.storage.update_pool(self.admin_context, pool)
# Fetch the list of servers
response = self.get('servers')
self.assertIn('servers', response.json)
self.assertEqual(len(pool.ns_records), len(response.json['servers']))
# Add a new NS record to the pool
pool.ns_records.append(
objects.PoolNsRecord(priority=0, hostname='new-ns2.example.org.'))
# Save the pool to add a new nameserver
self.storage.update_pool(self.admin_context, pool)
response = self.get('servers')
self.assertIn('servers', response.json)
self.assertEqual(len(pool.ns_records), len(response.json['servers']))
@patch.object(central_service.Service, 'get_pool',
side_effect=messaging.MessagingTimeout())
def test_get_servers_timeout(self, _):
self.get('servers', status_code=504)
def test_get_server(self):
# Fetch the default pool
pool = self.storage.get_pool(self.admin_context, default_pool_id)
# Fetch the Server from the pool
response = self.get('servers/%s' % pool.ns_records[0].id)
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], pool.ns_records[0]['id'])
@patch.object(central_service.Service, 'get_pool',
side_effect=messaging.MessagingTimeout())
def test_get_server_timeout(self, _):
# Fetch the default pool
pool = self.storage.get_pool(self.admin_context, default_pool_id)
self.get('servers/%s' % pool.ns_records[0].id, status_code=504)
def test_get_server_with_invalid_id(self):
self.get('servers/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff98GH',
status_code=404)
def test_get_server_missing(self):
self.get('servers/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
def test_update_server(self):
# Fetch the default pool
pool = self.storage.get_pool(self.admin_context, default_pool_id)
data = {'name': 'new-ns1.example.org.'}
response = self.put('servers/%s' % pool.ns_records[0].id,
data=data)
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], pool.ns_records[0].id)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], 'new-ns1.example.org.')
def test_update_server_missing(self):
data = {'name': 'test.example.org.'}
self.put('servers/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980', data=data,
status_code=404)
def test_update_server_junk(self):
# Fetch the default pool
pool = self.storage.get_pool(self.admin_context, default_pool_id)
data = {'name': 'test.example.org.', 'junk': 'Junk Field'}
self.put('servers/%s' % pool.ns_records[0].id, data=data,
status_code=400)
def test_delete_server(self):
# Fetch the default pool
pool = self.storage.get_pool(self.admin_context, default_pool_id)
# Create a second server so that we can delete the first
# because the last remaining server is not allowed to be deleted
# Add a new NS record to the pool
pool.ns_records.append(
objects.PoolNsRecord(priority=0, hostname='new-ns2.example.org.'))
# Save the pool to add a new nameserver
self.storage.update_pool(self.admin_context, pool)
# Now delete the server
self.delete('servers/%s' % pool.ns_records[1].id)
# Ensure we can no longer fetch the deleted server
self.get('servers/%s' % pool.ns_records[1].id, status_code=404)
# Also, verify we cannot delete last remaining server
self.delete('servers/%s' % pool.ns_records[0].id, status_code=400)
def test_delete_server_with_invalid_id(self):
self.delete('servers/9fdadfb1-cf96-4259-ac6b-bb7b6d2ff98GH',
status_code=404)
def test_delete_server_missing(self):
self.delete('servers/9fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
class ApiV1RecordsTest(ApiV1Test):
def setUp(self):
super(ApiV1RecordsTest, self).setUp()
self.domain = self.create_domain()
self.recordset = self.create_recordset(self.domain, 'A')
def test_create_record(self):
recordset_fixture = self.get_recordset_fixture(
self.domain['name'])
fixture = self.get_record_fixture(recordset_fixture['type'])
fixture.update({
'name': recordset_fixture['name'],
'type': recordset_fixture['type'],
})
# Create a record
response = self.post('domains/%s/records' % self.domain['id'],
data=fixture)
self.assertIn('id', response.json)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], fixture['name'])
def test_create_record_existing_recordset(self):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
# Create a record
response = self.post('domains/%s/records' % self.domain['id'],
data=fixture)
self.assertIn('id', response.json)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], fixture['name'])
@patch.object(central_service.Service, 'create_record')
def test_create_record_trailing_slash(self, mock):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
# Create a record with a trailing slash
self.post('domains/%s/records/' % self.domain['id'],
data=fixture)
# verify that the central service is called
self.assertTrue(mock.called)
def test_create_record_junk(self):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
# Add a junk property
fixture['junk'] = 'Junk Field'
# Create a record, Ensuring it fails with a 400
self.post('domains/%s/records' % self.domain['id'], data=fixture,
status_code=400)
def test_create_record_utf_description(self):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
#Add a UTF-8 riddled description
fixture['description'] = "utf-8:2H₂+O₂⇌2H₂O,R=4.7kΩ,⌀200mm∮E⋅da=Q,n" \
",∑f(i)=∏g(i),∀x∈ℝ:⌈x⌉"
# Create a record, Ensuring it succeeds
self.post('domains/%s/records' % self.domain['id'], data=fixture)
def test_create_record_description_too_long(self):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
# Add a description that is too long
fixture['description'] = "x" * 161
# Create a record, Ensuring it Fails with a 400
self.post('domains/%s/records' % self.domain['id'], data=fixture,
status_code=400)
def test_create_record_negative_ttl(self):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
# Set the TTL to a negative value
fixture['ttl'] = -1
# Create a record, Ensuring it Fails with a 400
self.post('domains/%s/records' % self.domain['id'], data=fixture,
status_code=400)
@patch.object(central_service.Service, 'create_record',
side_effect=messaging.MessagingTimeout())
def test_create_record_timeout(self, _):
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
# Create a record
self.post('domains/%s/records' % self.domain['id'], data=fixture,
status_code=504)
def test_create_wildcard_record(self):
# Prepare a record
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': '*.%s' % self.recordset['name'],
'type': self.recordset['type'],
})
# Create a record
response = self.post('domains/%s/records' % self.domain['id'],
data=fixture)
self.assertIn('id', response.json)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], fixture['name'])
def test_create_srv_record(self):
recordset_fixture = self.get_recordset_fixture(
self.domain['name'], 'SRV')
fixture = self.get_record_fixture(recordset_fixture['type'])
fixture.update({
'name': recordset_fixture['name'],
'type': recordset_fixture['type'],
})
# Create a record
response = self.post('domains/%s/records' % self.domain['id'],
data=fixture)
self.assertIn('id', response.json)
self.assertEqual(response.json['type'], fixture['type'])
self.assertEqual(response.json['name'], fixture['name'])
self.assertEqual(response.json['priority'], fixture['priority'])
self.assertEqual(response.json['data'], fixture['data'])
def test_create_invalid_data_srv_record(self):
recordset_fixture = self.get_recordset_fixture(
self.domain['name'], 'SRV')
fixture = self.get_record_fixture(recordset_fixture['type'])
fixture.update({
'name': recordset_fixture['name'],
'type': recordset_fixture['type'],
})
invalid_datas = [
'I 5060 sip.%s' % self.domain['name'],
'5060 sip.%s' % self.domain['name'],
'5060 I sip.%s' % self.domain['name'],
'0 5060 sip',
'sip',
'sip.%s' % self.domain['name'],
]
for invalid_data in invalid_datas:
fixture['data'] = invalid_data
# Attempt to create the record
self.post('domains/%s/records' % self.domain['id'], data=fixture,
status_code=400)
def test_create_invalid_name_srv_record(self):
recordset_fixture = self.get_recordset_fixture(
self.domain['name'], 'SRV')
fixture = self.get_record_fixture(recordset_fixture['type'])
fixture.update({
'name': recordset_fixture['name'],
'type': recordset_fixture['type'],
})
invalid_names = [
'%s' % self.domain['name'],
'_udp.%s' % self.domain['name'],
'sip._udp.%s' % self.domain['name'],
'_sip.udp.%s' % self.domain['name'],
]
for invalid_name in invalid_names:
fixture['name'] = invalid_name
# Attempt to create the record
self.post('domains/%s/records' % self.domain['id'], data=fixture,
status_code=400)
def test_create_invalid_name(self):
# Prepare a record
fixture = self.get_record_fixture(self.recordset['type'])
fixture.update({
'name': self.recordset['name'],
'type': self.recordset['type'],
})
invalid_names = [
'org',
'example.org',
'$$.example.org',
'*example.org.',
'*.*.example.org.',
'abc.*.example.org.',
]
for invalid_name in invalid_names:
fixture['name'] = invalid_name
# Create a record
response = self.post('domains/%s/records' % self.domain['id'],
data=fixture, status_code=400)
self.assertNotIn('id', response.json)
def test_get_records(self):
response = self.get('domains/%s/records' % self.domain['id'])
self.assertIn('records', response.json)
self.assertEqual(0, len(response.json['records']))
# Create a record
self.create_record(self.domain, self.recordset)
response = self.get('domains/%s/records' % self.domain['id'])
self.assertIn('records', response.json)
self.assertEqual(1, len(response.json['records']))
# Create a second record
self.create_record(self.domain, self.recordset, fixture=1)
response = self.get('domains/%s/records' % self.domain['id'])
self.assertIn('records', response.json)
self.assertEqual(2, len(response.json['records']))
@patch.object(central_service.Service, 'find_records')
def test_get_records_trailing_slash(self, mock):
self.get('domains/%s/records/' % self.domain['id'])
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service, 'find_records',
side_effect=messaging.MessagingTimeout())
def test_get_records_timeout(self, _):
self.get('domains/%s/records' % self.domain['id'],
status_code=504)
def test_get_records_missing_domain(self):
self.get('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980/records',
status_code=404)
def test_get_records_invalid_domain_id(self):
self.get('domains/2fdadfb1cf964259ac6bbb7b6d2ff980/records',
status_code=404)
def test_get_record(self):
# Create a record
record = self.create_record(self.domain, self.recordset)
response = self.get('domains/%s/records/%s' % (self.domain['id'],
record['id']))
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], record['id'])
self.assertEqual(response.json['name'], self.recordset['name'])
self.assertEqual(response.json['type'], self.recordset['type'])
@patch.object(central_service.Service, 'get_recordset')
def test_get_record_trailing_slash(self, mock):
# Create a record
record = self.create_record(self.domain, self.recordset)
self.get('domains/%s/records/%s/' % (self.domain['id'],
record['id']))
# verify that the central service is called
self.assertTrue(mock.called)
def test_update_record(self):
# Create a record
record = self.create_record(self.domain, self.recordset)
# Fetch another fixture to use in the update
fixture = self.get_record_fixture(self.recordset['type'], fixture=1)
# Update the record
data = {'data': fixture['data']}
response = self.put('domains/%s/records/%s' % (self.domain['id'],
record['id']),
data=data)
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], record['id'])
self.assertEqual(response.json['data'], fixture['data'])
self.assertEqual(response.json['type'], self.recordset['type'])
def test_update_record_ttl(self):
# Create a record
record = self.create_record(self.domain, self.recordset)
# Update the record
data = {'ttl': 100}
response = self.put('domains/%s/records/%s' % (self.domain['id'],
record['id']),
data=data)
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], record['id'])
self.assertEqual(response.json['data'], record['data'])
self.assertEqual(response.json['type'], self.recordset['type'])
self.assertEqual(response.json['ttl'], 100)
@patch.object(central_service.Service, 'update_record')
def test_update_record_trailing_slash(self, mock):
# Create a record
record = self.create_record(self.domain, self.recordset)
data = {'ttl': 100}
self.put('domains/%s/records/%s/' % (self.domain['id'],
record['id']),
data=data)
# verify that the central service is called
self.assertTrue(mock.called)
def test_update_record_junk(self):
# Create a record
record = self.create_record(self.domain, self.recordset)
data = {'ttl': 100, 'junk': 'Junk Field'}
self.put('domains/%s/records/%s' % (self.domain['id'], record['id']),
data=data, status_code=400)
def test_update_record_outside_domain_fail(self):
# Create a record
record = self.create_record(self.domain, self.recordset)
data = {'name': 'test.someotherdomain.com.'}
self.put('domains/%s/records/%s' % (self.domain['id'], record['id']),
data=data, status_code=400)
@patch.object(central_service.Service, 'get_domain',
side_effect=messaging.MessagingTimeout())
def test_update_record_timeout(self, _):
# Create a record
record = self.create_record(self.domain, self.recordset)
data = {'name': 'test.example.org.'}
self.put('domains/%s/records/%s' % (self.domain['id'], record['id']),
data=data, status_code=504)
def test_update_record_missing(self):
data = {'name': 'test.example.org.'}
self.put('domains/%s/records/2fdadfb1-cf96-4259-ac6b-'
'bb7b6d2ff980' % self.domain['id'],
data=data,
status_code=404)
def test_update_record_invalid_id(self):
data = {'name': 'test.example.org.'}
self.put('domains/%s/records/2fdadfb1cf964259ac6bbb7b6d2ff980' %
self.domain['id'],
data=data,
status_code=404)
def test_update_record_missing_domain(self):
data = {'name': 'test.example.org.'}
self.put('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980/records/'
'2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
data=data,
status_code=404)
def test_update_record_invalid_domain_id(self):
data = {'name': 'test.example.org.'}
self.put('domains/2fdadfb1cf964259ac6bbb7b6d2ff980/records/'
'2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
data=data,
status_code=404)
def test_delete_record(self):
# Create a record
record = self.create_record(self.domain, self.recordset)
self.delete('domains/%s/records/%s' % (self.domain['id'],
record['id']))
# Ensure we can no longer fetch the record
self.get('domains/%s/records/%s' % (self.domain['id'],
record['id']),
status_code=404)
@patch.object(central_service.Service, 'get_domain')
def test_delete_record_trailing_slash(self, mock):
# Create a record
record = self.create_record(self.domain, self.recordset)
self.delete('domains/%s/records/%s/' % (self.domain['id'],
record['id']))
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service, 'get_domain',
side_effect=messaging.MessagingTimeout())
def test_delete_record_timeout(self, _):
# Create a record
record = self.create_record(self.domain, self.recordset)
self.delete('domains/%s/records/%s' % (self.domain['id'],
record['id']),
status_code=504)
def test_delete_record_missing(self):
self.delete('domains/%s/records/2fdadfb1-cf96-4259-ac6b-'
'bb7b6d2ff980' % self.domain['id'],
status_code=404)
def test_delete_record_missing_domain(self):
self.delete('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980/records/'
'2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
def test_delete_record_invalid_domain_id(self):
self.delete('domains/2fdadfb1cf964259ac6bbb7b6d2ff980/records/'
'2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
class ApiV2RecordSetsTest(ApiV2TestCase):
def setUp(self):
super(ApiV2RecordSetsTest, self).setUp()
# Create a domain
self.domain = self.create_domain()
def test_create_recordset(self):
# Create a zone
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], {'recordset': fixture})
# Check the headers are what we expect
self.assertEqual(201, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('recordset', response.json)
self.assertIn('links', response.json['recordset'])
self.assertIn('self', response.json['recordset']['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json['recordset'])
self.assertIn('created_at', response.json['recordset'])
self.assertIsNone(response.json['recordset']['updated_at'])
for k in fixture:
self.assertEqual(fixture[k], response.json['recordset'][k])
def test_create_recordset_invalid_id(self):
self._assert_invalid_uuid(self.client.post, '/zones/%s/recordsets')
def test_create_recordset_validation(self):
# NOTE: The schemas should be tested separatly to the API. So we
# don't need to test every variation via the API itself.
# Fetch a fixture
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
# Add a junk field to the wrapper
body = {'recordset': fixture, 'junk': 'Junk Field'}
url = '/zones/%s/recordsets' % self.domain['id']
# Ensure it fails with a 400
self._assert_exception(
'invalid_object', 400, self.client.post_json, url, body)
# Add a junk field to the body
fixture['junk'] = 'Junk Field'
body = {'recordset': fixture}
# Ensure it fails with a 400
self._assert_exception(
'invalid_object', 400, self.client.post_json, url, body)
@patch.object(central_service.Service, 'create_recordset',
side_effect=messaging.MessagingTimeout())
def test_create_recordset_timeout(self, _):
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = {'recordset': fixture}
url = '/zones/%s/recordsets' % self.domain['id']
self._assert_exception('timeout', 504, self.client.post_json, url,
body)
@patch.object(central_service.Service, 'create_recordset',
side_effect=exceptions.DuplicateRecordSet())
def test_create_recordset_duplicate(self, _):
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = {'recordset': fixture}
url = '/zones/%s/recordsets' % self.domain['id']
self._assert_exception('duplicate_recordset', 409,
self.client.post_json, url, body)
def test_create_recordset_invalid_domain(self):
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = {'recordset': fixture}
url = '/zones/ba751950-6193-11e3-949a-0800200c9a66/recordsets'
self._assert_exception('domain_not_found', 404, self.client.post_json,
url, body)
def test_recordsets_invalid_url(self):
url = '/zones/recordsets'
self._assert_exception('not_found', 404, self.client.get, url)
self._assert_exception('not_found', 404, self.client.post_json, url)
# Pecan returns a 405 for Patch and delete operations
response = self.client.patch_json(url, status=405)
self.assertEqual(405, response.status_int)
response = self.client.delete(url, status=405)
self.assertEqual(405, response.status_int)
def test_get_recordsets(self):
url = '/zones/%s/recordsets' % self.domain['id']
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('recordsets', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 0 recordsets
self.assertEqual(0, len(response.json['recordsets']))
data = [self.create_recordset(self.domain,
name='x-%s.%s' % (i, self.domain['name']))
for i in xrange(0, 10)]
self._assert_paging(data, url, key='recordsets')
self._assert_invalid_paging(data, url, key='recordsets')
def test_get_recordsets_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s/recordsets')
@patch.object(central_service.Service, 'find_recordsets',
side_effect=messaging.MessagingTimeout())
def test_get_recordsets_timeout(self, _):
url = '/zones/ba751950-6193-11e3-949a-0800200c9a66/recordsets'
self._assert_exception('timeout', 504, self.client.get, url)
def test_get_recordset(self):
# Create a recordset
recordset = self.create_recordset(self.domain)
url = '/zones/%s/recordsets/%s' % (self.domain['id'], recordset['id'])
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('recordset', response.json)
self.assertIn('links', response.json['recordset'])
self.assertIn('self', response.json['recordset']['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json['recordset'])
self.assertIn('created_at', response.json['recordset'])
self.assertIsNone(response.json['recordset']['updated_at'])
self.assertEqual(recordset['name'], response.json['recordset']['name'])
self.assertEqual(recordset['type'], response.json['recordset']['type'])
def test_get_recordset_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s/recordsets/%s')
@patch.object(central_service.Service, 'get_recordset',
side_effect=messaging.MessagingTimeout())
def test_get_recordset_timeout(self, _):
url = '/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' % (
self.domain['id'])
self._assert_exception('timeout', 504, self.client.get, url,
headers={'Accept': 'application/json'})
@patch.object(central_service.Service, 'get_recordset',
side_effect=exceptions.RecordSetNotFound())
def test_get_recordset_missing(self, _):
url = '/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' % (
self.domain['id'])
self._assert_exception('recordset_not_found', 404,
self.client.get, url,
headers={'Accept': 'application/json'})
def test_update_recordset(self):
# Create a recordset
recordset = self.create_recordset(self.domain)
# Prepare an update body
body = {'recordset': {'description': 'Tester'}}
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.patch_json(url, body, status=200)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('recordset', response.json)
self.assertIn('links', response.json['recordset'])
self.assertIn('self', response.json['recordset']['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json['recordset'])
self.assertIsNotNone(response.json['recordset']['updated_at'])
self.assertEqual('Tester', response.json['recordset']['description'])
def test_update_recordset_invalid_id(self):
self._assert_invalid_uuid(
self.client.patch_json, '/zones/%s/recordsets/%s')
def test_update_recordset_validation(self):
# NOTE: The schemas should be tested separatly to the API. So we
# don't need to test every variation via the API itself.
# Create a zone
recordset = self.create_recordset(self.domain)
# Prepare an update body with junk in the wrapper
body = {'recordset': {'description': 'Tester'}, 'junk': 'Junk Field'}
# Ensure it fails with a 400
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
# Prepare an update body with junk in the body
body = {'recordset': {'description': 'Tester', 'junk': 'Junk Field'}}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
@patch.object(central_service.Service, 'get_recordset',
side_effect=exceptions.DuplicateRecordSet())
def test_update_recordset_duplicate(self, _):
# Prepare an update body
body = {'recordset': {'description': 'Tester'}}
# Ensure it fails with a 409
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66'
% (self.domain['id']))
self._assert_exception('duplicate_recordset', 409,
self.client.patch_json, url, body)
@patch.object(central_service.Service, 'get_recordset',
side_effect=messaging.MessagingTimeout())
def test_update_recordset_timeout(self, _):
# Prepare an update body
body = {'recordset': {'description': 'Tester'}}
# Ensure it fails with a 504
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66'
% (self.domain['id']))
self._assert_exception('timeout', 504, self.client.patch_json, url,
body)
@patch.object(central_service.Service, 'get_recordset',
side_effect=exceptions.RecordSetNotFound())
def test_update_recordset_missing(self, _):
# Prepare an update body
body = {'recordset': {'description': 'Tester'}}
# Ensure it fails with a 404
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66'
% (self.domain['id']))
self._assert_exception('recordset_not_found', 404,
self.client.patch_json, url, body)
def test_delete_recordset(self):
recordset = self.create_recordset(self.domain)
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self.client.delete(url, status=204)
@patch.object(central_service.Service, 'delete_recordset',
side_effect=messaging.MessagingTimeout())
def test_delete_recordset_timeout(self, _):
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66'
% (self.domain['id']))
self._assert_exception('timeout', 504, self.client.delete, url)
@patch.object(central_service.Service, 'delete_recordset',
side_effect=exceptions.RecordSetNotFound())
def test_delete_recordset_missing(self, _):
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66'
% (self.domain['id']))
self._assert_exception('recordset_not_found', 404,
self.client.delete, url)
def test_delete_recordset_invalid_id(self):
self._assert_invalid_uuid(
self.client.delete, '/zones/%s/recordsets/%s')
class ApiV2TsigKeysTest(ApiV2TestCase):
def setUp(self):
super(ApiV2TsigKeysTest, self).setUp()
# Set the policy to accept everyone as an admin, as this is an
# admin-only API
self.policy({'admin': '@'})
def test_create_tsigkey(self):
# Create a TSIG Key
fixture = self.get_tsigkey_fixture(0)
response = self.client.post_json('/tsigkeys/', {'tsigkey': fixture})
# Check the headers are what we expect
self.assertEqual(201, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('tsigkey', response.json)
self.assertIn('links', response.json['tsigkey'])
self.assertIn('self', response.json['tsigkey']['links'])
# Check the generated values returned are what we expect
self.assertIn('id', response.json['tsigkey'])
self.assertIn('created_at', response.json['tsigkey'])
self.assertIsNone(response.json['tsigkey']['updated_at'])
# Check the supplied values returned are what we expect
self.assertDictContainsSubset(fixture, response.json['tsigkey'])
def test_create_tsigkey_validation(self):
# NOTE: The schemas should be tested separately to the API. So we
# don't need to test every variation via the API itself.
# Fetch a fixture
fixture = self.get_tsigkey_fixture(0)
# Add a junk field to the wrapper
body = {'tsigkey': fixture, 'junk': 'Junk Field'}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
'/tsigkeys', body)
# Add a junk field to the body
fixture['junk'] = 'Junk Field'
# Ensure it fails with a 400
body = {'tsigkey': fixture}
self._assert_exception('invalid_object', 400, self.client.post_json,
'/tsigkeys', body)
def test_create_tsigkey_duplicate(self):
# Prepare a TSIG Key fixture
fixture = self.get_tsigkey_fixture(0)
body = {'tsigkey': fixture}
# Create the first TSIG Key
response = self.client.post_json('/tsigkeys', body)
self.assertEqual(201, response.status_int)
self._assert_exception('duplicate_tsigkey', 409,
self.client.post_json, '/tsigkeys', body)
def test_get_tsigkeys(self):
response = self.client.get('/tsigkeys/')
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('tsigkeys', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 0 tsigkeys
self.assertEqual(0, len(response.json['tsigkeys']))
data = [self.create_tsigkey(name='tsigkey-%s' % i)
for i in range(1, 10)]
self._assert_paging(data, '/tsigkeys', key='tsigkeys')
self._assert_invalid_paging(data, '/tsigkeys', key='tsigkeys')
@patch.object(central_service.Service, 'find_tsigkeys',
side_effect=messaging.MessagingTimeout())
def test_get_tsigkeys_timeout(self, _):
self._assert_exception('timeout', 504, self.client.get, '/tsigkeys/')
def test_get_tsigkey(self):
# Create a tsigkey
tsigkey = self.create_tsigkey()
response = self.client.get('/tsigkeys/%s' % tsigkey.id,
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('tsigkey', response.json)
self.assertIn('links', response.json['tsigkey'])
self.assertIn('self', response.json['tsigkey']['links'])
# Check the generated values returned are what we expect
self.assertIn('id', response.json['tsigkey'])
self.assertIn('created_at', response.json['tsigkey'])
self.assertIsNone(response.json['tsigkey']['updated_at'])
# Check the supplied values returned are what we expect
self.assertEqual(tsigkey.name, response.json['tsigkey']['name'])
self.assertEqual(
tsigkey.algorithm, response.json['tsigkey']['algorithm'])
self.assertEqual(tsigkey.secret, response.json['tsigkey']['secret'])
self.assertEqual(tsigkey.scope, response.json['tsigkey']['scope'])
self.assertEqual(
tsigkey.resource_id, response.json['tsigkey']['resource_id'])
def test_get_tsigkey_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/tsigkeys/%s')
@patch.object(central_service.Service, 'get_tsigkey',
side_effect=messaging.MessagingTimeout())
def test_get_tsigkey_timeout(self, _):
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('timeout', 504, self.client.get, url,
headers={'Accept': 'application/json'})
@patch.object(central_service.Service, 'get_tsigkey',
side_effect=exceptions.TsigKeyNotFound())
def test_get_tsigkey_missing(self, _):
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('tsigkey_not_found', 404, self.client.get, url,
headers={'Accept': 'application/json'})
def test_update_tsigkey(self):
# Create a TSIG Key
tsigkey = self.create_tsigkey()
# Prepare an update body
body = {'tsigkey': {'secret': 'prefix-%s' % tsigkey.secret}}
response = self.client.patch_json('/tsigkeys/%s' % tsigkey.id, body)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('tsigkey', response.json)
self.assertIn('links', response.json['tsigkey'])
self.assertIn('self', response.json['tsigkey']['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json['tsigkey'])
self.assertIsNotNone(response.json['tsigkey']['updated_at'])
self.assertEqual('prefix-%s' % tsigkey['secret'],
response.json['tsigkey']['secret'])
def test_update_tsigkey_invalid_id(self):
self._assert_invalid_uuid(self.client.patch_json, '/tsigkeys/%s')
@patch.object(central_service.Service, 'get_tsigkey',
side_effect=exceptions.DuplicateTsigKey())
def test_update_tsigkey_duplicate(self, _):
# Prepare an update body
body = {'tsigkey': {'name': 'AnyOldName'}}
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 409
self._assert_exception('duplicate_tsigkey', 409,
self.client.patch_json, url, body)
@patch.object(central_service.Service, 'get_tsigkey',
side_effect=messaging.MessagingTimeout())
def test_update_tsigkey_timeout(self, _):
# Prepare an update body
body = {'tsigkey': {'name': 'AnyOldName'}}
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 504
self._assert_exception('timeout', 504, self.client.patch_json,
url, body)
@patch.object(central_service.Service, 'get_tsigkey',
side_effect=exceptions.TsigKeyNotFound())
def test_update_tsigkey_missing(self, _):
# Prepare an update body
body = {'tsigkey': {'name': 'AnyOldName'}}
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 404
self._assert_exception('tsigkey_not_found', 404,
self.client.patch_json, url, body)
def test_delete_tsigkey(self):
tsigkey = self.create_tsigkey()
self.client.delete('/tsigkeys/%s' % tsigkey['id'], status=204)
def test_delete_tsigkey_invalid_id(self):
self._assert_invalid_uuid(self.client.delete, '/tsigkeys/%s')
@patch.object(central_service.Service, 'delete_tsigkey',
side_effect=messaging.MessagingTimeout())
def test_delete_tsigkey_timeout(self, _):
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('timeout', 504, self.client.delete, url)
@patch.object(central_service.Service, 'delete_tsigkey',
side_effect=exceptions.TsigKeyNotFound())
def test_delete_tsigkey_missing(self, _):
url = '/tsigkeys/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('tsigkey_not_found', 404, self.client.delete,
url)
class ApiV2ZonesTest(ApiV2TestCase):
def setUp(self):
super(ApiV2ZonesTest, self).setUp()
# Create a server
self.create_server()
# Create the default TLDs
self.create_default_tlds()
def test_create_zone(self):
# Create a zone
fixture = self.get_domain_fixture(0)
response = self.client.post_json('/zones/', {'zone': fixture})
# Check the headers are what we expect
self.assertEqual(201, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('zone', response.json)
self.assertIn('links', response.json['zone'])
self.assertIn('self', response.json['zone']['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json['zone'])
self.assertIn('created_at', response.json['zone'])
self.assertEqual('ACTIVE', response.json['zone']['status'])
self.assertIsNone(response.json['zone']['updated_at'])
for k in fixture:
self.assertEqual(fixture[k], response.json['zone'][k])
def test_create_zone_validation(self):
# NOTE: The schemas should be tested separately to the API. So we
# don't need to test every variation via the API itself.
# Fetch a fixture
fixture = self.get_domain_fixture(0)
# Add a junk field to the wrapper
body = {'zone': fixture, 'junk': 'Junk Field'}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
# Add a junk field to the body
fixture['junk'] = 'Junk Field'
# Ensure it fails with a 400
body = {'zone': fixture}
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
def test_create_zone_body_validation(self):
fixture = self.get_domain_fixture(0)
# Add id to the body
fixture['id'] = '2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 400
body = {'zone': fixture}
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
fixture = self.get_domain_fixture(0)
# Add created_at to the body
fixture['created_at'] = '2014-03-12T19:07:53.000000'
# Ensure it fails with a 400
body = {'zone': fixture}
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
def test_create_zone_invalid_name(self):
# Try to create a zone with an invalid name
fixture = self.get_domain_fixture(-1)
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', {'zone': fixture})
@patch.object(central_service.Service,
'create_domain',
side_effect=messaging.MessagingTimeout())
def test_create_zone_timeout(self, _):
fixture = self.get_domain_fixture(0)
body = {'zone': fixture}
self._assert_exception('timeout', 504, self.client.post_json,
'/zones/', body)
@patch.object(central_service.Service,
'create_domain',
side_effect=exceptions.DuplicateDomain())
def test_create_zone_duplicate(self, _):
fixture = self.get_domain_fixture(0)
body = {'zone': fixture}
self._assert_exception('duplicate_domain', 409, self.client.post_json,
'/zones/', body)
def test_create_zone_missing_content_type(self):
self._assert_exception('unsupported_content_type', 415,
self.client.post, '/zones')
def test_create_zone_bad_content_type(self):
self._assert_exception('unsupported_content_type',
415,
self.client.post,
'/zones',
headers={'Content-type': 'test/goat'})
def test_zone_invalid_url(self):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980/invalid'
self._assert_exception('not_found',
404,
self.client.get,
url,
headers={'Accept': 'application/json'})
self._assert_exception('not_found', 404, self.client.patch_json, url)
self._assert_exception('not_found', 404, self.client.delete, url)
# Pecan returns a 405 for post
response = self.client.post(url, status=405)
self.assertEqual(405, response.status_int)
def test_get_zones(self):
response = self.client.get('/zones/')
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('zones', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 0 zones
self.assertEqual(0, len(response.json['zones']))
# We should start with 0 zones
self.assertEqual(0, len(response.json['zones']))
data = [self.create_domain(name='x-%s.com.' % i) for i in 'abcdefghij']
self._assert_paging(data, '/zones', key='zones')
self._assert_invalid_paging(data, '/zones', key='zones')
@patch.object(central_service.Service,
'find_domains',
side_effect=messaging.MessagingTimeout())
def test_get_zones_timeout(self, _):
self._assert_exception('timeout', 504, self.client.get, '/zones/')
def test_get_zone(self):
# Create a zone
zone = self.create_domain()
response = self.client.get('/zones/%s' % zone['id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('zone', response.json)
self.assertIn('links', response.json['zone'])
self.assertIn('self', response.json['zone']['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json['zone'])
self.assertIn('created_at', response.json['zone'])
self.assertEqual('ACTIVE', response.json['zone']['status'])
self.assertIsNone(response.json['zone']['updated_at'])
self.assertEqual(zone['name'], response.json['zone']['name'])
self.assertEqual(zone['email'], response.json['zone']['email'])
def test_get_zone_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s')
@patch.object(central_service.Service,
'get_domain',
side_effect=messaging.MessagingTimeout())
def test_get_zone_timeout(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('timeout',
504,
self.client.get,
url,
headers={'Accept': 'application/json'})
@patch.object(central_service.Service,
'get_domain',
side_effect=exceptions.DomainNotFound())
def test_get_zone_missing(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('domain_not_found',
404,
self.client.get,
url,
headers={'Accept': 'application/json'})
def test_get_zone_missing_accept(self):
url = '/zones/6e2146f3-87bc-4f47-adc5-4df0a5c78218'
self._assert_exception('bad_request', 400, self.client.get, url)
def test_get_zone_bad_accept(self):
url = '/zones/6e2146f3-87bc-4f47-adc5-4df0a5c78218'
self.client.get(url, headers={'Accept': 'test/goat'}, status=406)
def test_update_zone(self):
# Create a zone
zone = self.create_domain()
# Prepare an update body
body = {'zone': {'email': 'prefix-%s' % zone['email']}}
response = self.client.patch_json('/zones/%s' % zone['id'],
body,
status=200)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('zone', response.json)
self.assertIn('links', response.json['zone'])
self.assertIn('self', response.json['zone']['links'])
self.assertIn('status', response.json['zone'])
# Check the values returned are what we expect
self.assertIn('id', response.json['zone'])
self.assertIsNotNone(response.json['zone']['updated_at'])
self.assertEqual('prefix-%s' % zone['email'],
response.json['zone']['email'])
def test_update_zone_invalid_id(self):
self._assert_invalid_uuid(self.client.patch_json, '/zones/%s')
def test_update_zone_validation(self):
# NOTE: The schemas should be tested separatly to the API. So we
# don't need to test every variation via the API itself.
# Create a zone
zone = self.create_domain()
# Prepare an update body with junk in the wrapper
body = {
'zone': {
'email': 'prefix-%s' % zone['email']
},
'junk': 'Junk Field'
}
url = '/zones/%s' % zone['id']
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
# Prepare an update body with junk in the body
body = {
'zone': {
'email': 'prefix-%s' % zone['email'],
'junk': 'Junk Field'
}
}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
@patch.object(central_service.Service,
'get_domain',
side_effect=exceptions.DuplicateDomain())
def test_update_zone_duplicate(self, _):
# Prepare an update body
body = {'zone': {'email': '*****@*****.**'}}
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 409
self._assert_exception('duplicate_domain', 409, self.client.patch_json,
url, body)
@patch.object(central_service.Service,
'get_domain',
side_effect=messaging.MessagingTimeout())
def test_update_zone_timeout(self, _):
# Prepare an update body
body = {'zone': {'email': '*****@*****.**'}}
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 504
self._assert_exception('timeout', 504, self.client.patch_json, url,
body)
@patch.object(central_service.Service,
'get_domain',
side_effect=exceptions.DomainNotFound())
def test_update_zone_missing(self, _):
# Prepare an update body
body = {'zone': {'email': '*****@*****.**'}}
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 404
self._assert_exception('domain_not_found', 404, self.client.patch_json,
url, body)
def test_delete_zone(self):
zone = self.create_domain()
self.client.delete('/zones/%s' % zone['id'], status=204)
def test_delete_zone_invalid_id(self):
self._assert_invalid_uuid(self.client.delete, '/zones/%s')
@patch.object(central_service.Service,
'delete_domain',
side_effect=messaging.MessagingTimeout())
def test_delete_zone_timeout(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('timeout', 504, self.client.delete, url)
@patch.object(central_service.Service,
'delete_domain',
side_effect=exceptions.DomainNotFound())
def test_delete_zone_missing(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('domain_not_found', 404, self.client.delete,
url)
# Zone import/export
def test_missing_origin(self):
fixture = self.get_zonefile_fixture(variant='noorigin')
self._assert_exception('bad_request',
400,
self.client.post,
'/zones',
fixture,
headers={'Content-type': 'text/dns'})
def test_missing_soa(self):
fixture = self.get_zonefile_fixture(variant='nosoa')
self._assert_exception('bad_request',
400,
self.client.post,
'/zones',
fixture,
headers={'Content-type': 'text/dns'})
def test_malformed_zonefile(self):
fixture = self.get_zonefile_fixture(variant='malformed')
self._assert_exception('bad_request',
400,
self.client.post,
'/zones',
fixture,
headers={'Content-type': 'text/dns'})
def test_import_export(self):
# Since v2 doesn't support getting records, import and export the
# fixture, making sure they're the same according to dnspython
post_response = self.client.post('/zones',
self.get_zonefile_fixture(),
headers={'Content-type': 'text/dns'})
get_response = self.client.get('/zones/%s' %
post_response.json['zone']['id'],
headers={'Accept': 'text/dns'})
exported_zonefile = get_response.body
imported = dnszone.from_text(self.get_zonefile_fixture())
exported = dnszone.from_text(exported_zonefile)
# Compare SOA emails, since zone comparison takes care of origin
imported_soa = imported.get_rdataset(imported.origin, 'SOA')
imported_email = imported_soa[0].rname.to_text()
exported_soa = exported.get_rdataset(exported.origin, 'SOA')
exported_email = exported_soa[0].rname.to_text()
self.assertEqual(imported_email, exported_email)
# Delete SOAs since they have, at the very least, different serials,
# and dnspython considers that to be not equal.
imported.delete_rdataset(imported.origin, 'SOA')
exported.delete_rdataset(exported.origin, 'SOA')
# Delete non-delegation NS, since they won't be the same
imported.delete_rdataset(imported.origin, 'NS')
exported.delete_rdataset(exported.origin, 'NS')
self.assertEqual(imported, exported)
class ApiV1DomainsTest(ApiV1Test):
def test_create_domain(self):
# Create a server
self.create_server()
# Create a domain
fixture = self.get_domain_fixture(0)
response = self.post('domains', data=fixture)
self.assertIn('id', response.json)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], fixture['name'])
@patch.object(central_service.Service, 'create_domain')
def test_create_domain_trailing_slash(self, mock):
# Create a server
self.create_server()
self.post('domains/', data=self.get_domain_fixture(0))
# verify that the central service is called
self.assertTrue(mock.called)
def test_create_domain_junk(self):
# Create a server
self.create_server()
# Create a domain
fixture = self.get_domain_fixture(0)
# Add a junk property
fixture['junk'] = 'Junk Field'
# Ensure it fails with a 400
self.post('domains', data=fixture, status_code=400)
def test_create_domain_no_servers(self):
# Create a domain
fixture = self.get_domain_fixture(0)
self.post('domains', data=fixture, status_code=500)
@patch.object(central_service.Service, 'create_domain',
side_effect=messaging.MessagingTimeout())
def test_create_domain_timeout(self, _):
# Create a domain
fixture = self.get_domain_fixture(0)
self.post('domains', data=fixture, status_code=504)
@patch.object(central_service.Service, 'create_domain',
side_effect=exceptions.DuplicateDomain())
def test_create_domain_duplicate(self, _):
# Create a domain
fixture = self.get_domain_fixture(0)
self.post('domains', data=fixture, status_code=409)
def test_create_domain_null_ttl(self):
# Create a domain
fixture = self.get_domain_fixture(0)
fixture['ttl'] = None
self.post('domains', data=fixture, status_code=400)
def test_create_domain_negative_ttl(self):
# Create a domain
fixture = self.get_domain_fixture(0)
fixture['ttl'] = -1
self.post('domains', data=fixture, status_code=400)
def test_create_domain_utf_description(self):
# Create a server
self.create_server()
# Create a domain
fixture = self.get_domain_fixture(0)
# Give it a UTF-8 filled description
fixture['description'] = "utf-8:2H₂+O₂⇌2H₂O,R=4.7kΩ,⌀200mm∮E⋅da=Q,n" \
",∑f(i)=∏g(i),∀x∈ℝ:⌈x⌉"
# Create the domain, ensuring it succeeds, thus UTF-8 is supported
self.post('domains', data=fixture)
def test_create_domain_description_too_long(self):
# Create a server
self.create_server()
# Create a domain
fixture = self.get_domain_fixture(0)
fixture['description'] = "x" * 161
#Create the domain, ensuring it fails with a 400
self.post('domains', data=fixture, status_code=400)
def test_create_invalid_name(self):
# Prepare a domain
fixture = self.get_domain_fixture(0)
invalid_names = [
'org',
'example.org',
'example.321',
]
for invalid_name in invalid_names:
fixture['name'] = invalid_name
# Create a record
response = self.post('domains', data=fixture, status_code=400)
self.assertNotIn('id', response.json)
def test_create_invalid_email(self):
# Prepare a domain
fixture = self.get_domain_fixture(0)
invalid_emails = [
'org',
'example.org',
'bla.example.org',
'org.',
'example.org.',
'bla.example.org.',
'bla.example.org.',
]
for invalid_email in invalid_emails:
fixture['email'] = invalid_email
# Create a record
response = self.post('domains', data=fixture, status_code=400)
self.assertNotIn('id', response.json)
def test_get_domains(self):
response = self.get('domains')
self.assertIn('domains', response.json)
self.assertEqual(0, len(response.json['domains']))
# Create a domain
self.create_domain()
response = self.get('domains')
self.assertIn('domains', response.json)
self.assertEqual(1, len(response.json['domains']))
# Create a second domain
self.create_domain(fixture=1)
response = self.get('domains')
self.assertIn('domains', response.json)
self.assertEqual(2, len(response.json['domains']))
@patch.object(central_service.Service, 'find_domains')
def test_get_domains_trailing_slash(self, mock):
self.get('domains/')
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service, 'find_domains',
side_effect=messaging.MessagingTimeout())
def test_get_domains_timeout(self, _):
self.get('domains', status_code=504)
def test_get_domain(self):
# Create a domain
domain = self.create_domain()
response = self.get('domains/%s' % domain['id'])
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], domain['id'])
@patch.object(central_service.Service, 'get_domain')
def test_get_domain_trailing_slash(self, mock):
# Create a domain
domain = self.create_domain()
self.get('domains/%s/' % domain['id'])
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service, 'get_domain',
side_effect=messaging.MessagingTimeout())
def test_get_domain_timeout(self, _):
# Create a domain
domain = self.create_domain()
self.get('domains/%s' % domain['id'], status_code=504)
def test_get_domain_missing(self):
self.get('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
def test_get_domain_invalid_id(self):
# The letter "G" is not valid in a UUID
self.get('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff9GG',
status_code=404)
self.get('domains/2fdadfb1cf964259ac6bbb7b6d2ff980', status_code=404)
def test_update_domain(self):
# Create a domain
domain = self.create_domain()
data = {'email': 'prefix-%s' % domain['email']}
response = self.put('domains/%s' % domain['id'], data=data)
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], domain['id'])
self.assertIn('email', response.json)
self.assertEqual(response.json['email'], 'prefix-%s' % domain['email'])
@patch.object(central_service.Service, 'update_domain')
def test_update_domain_trailing_slash(self, mock):
# Create a domain
domain = self.create_domain()
data = {'email': 'prefix-%s' % domain['email']}
self.put('domains/%s/' % domain['id'], data=data)
# verify that the central service is called
self.assertTrue(mock.called)
def test_update_domain_junk(self):
# Create a domain
domain = self.create_domain()
data = {'email': 'prefix-%s' % domain['email'], 'junk': 'Junk Field'}
self.put('domains/%s' % domain['id'], data=data, status_code=400)
def test_update_domain_name_fail(self):
# Create a domain
domain = self.create_domain()
data = {'name': 'renamed.com.'}
self.put('domains/%s' % domain['id'], data=data, status_code=400)
def test_update_domain_null_ttl(self):
# Create a domain
domain = self.create_domain()
data = {'ttl': None}
self.put('domains/%s' % domain['id'], data=data, status_code=400)
@patch.object(central_service.Service, 'update_domain',
side_effect=messaging.MessagingTimeout())
def test_update_domain_timeout(self, _):
# Create a domain
domain = self.create_domain()
data = {'email': 'prefix-%s' % domain['email']}
self.put('domains/%s' % domain['id'], data=data, status_code=504)
@patch.object(central_service.Service, 'update_domain',
side_effect=exceptions.DuplicateDomain())
def test_update_domain_duplicate(self, _):
# Create a domain
domain = self.create_domain()
data = {'email': 'prefix-%s' % domain['email']}
self.put('domains/%s' % domain['id'], data=data, status_code=409)
def test_update_domain_missing(self):
data = {'email': '*****@*****.**'}
self.put('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980', data=data,
status_code=404)
def test_update_domain_invalid_id(self):
data = {'email': '*****@*****.**'}
# The letter "G" is not valid in a UUID
self.put('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff9GG', data=data,
status_code=404)
self.put('domains/2fdadfb1cf964259ac6bbb7b6d2ff980', data=data,
status_code=404)
def test_delete_domain(self):
# Create a domain
domain = self.create_domain()
self.delete('domains/%s' % domain['id'])
# Esnure we can no longer fetch the domain
self.get('domains/%s' % domain['id'], status_code=404)
@patch.object(central_service.Service, 'delete_domain')
def test_delete_domain_trailing_slash(self, mock):
# Create a domain
domain = self.create_domain()
self.delete('domains/%s/' % domain['id'])
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service, 'delete_domain',
side_effect=messaging.MessagingTimeout())
def test_delete_domain_timeout(self, _):
# Create a domain
domain = self.create_domain()
self.delete('domains/%s' % domain['id'], status_code=504)
def test_delete_domain_missing(self):
self.delete('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
def test_delete_domain_invalid_id(self):
# The letter "G" is not valid in a UUID
self.delete('domains/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff9GG',
status_code=404)
self.delete('domains/2fdadfb1cf964259ac6bbb7b6d2ff980',
status_code=404)
def _raise_timeout_exception(msg_id):
raise messaging.MessagingTimeout(
_('Timed out waiting for a reply to message ID %s.') % msg_id)
class ApiV2ZonesTest(ApiV2TestCase):
def setUp(self):
super(ApiV2ZonesTest, self).setUp()
# Create the default TLDs
self.create_default_tlds()
def test_create_zone(self):
# Create a zone
fixture = self.get_domain_fixture(fixture=0)
response = self.client.post_json('/zones/', fixture)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertEqual('PENDING', response.json['status'])
self.assertEqual('PRIMARY', response.json['type'])
self.assertEqual([], response.json['masters'])
self.assertIsNone(response.json['updated_at'])
for k in fixture:
self.assertEqual(fixture[k], response.json[k])
def test_create_zone_no_type(self):
# Create a zone
fixture = self.get_domain_fixture(fixture=0)
del fixture['type']
response = self.client.post_json('/zones/', fixture)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertEqual('PENDING', response.json['status'])
self.assertEqual('PRIMARY', response.json['type'])
self.assertEqual([], response.json['masters'])
self.assertIsNone(response.json['updated_at'])
for k in fixture:
self.assertEqual(fixture[k], response.json[k])
def test_create_zone_validation(self):
# NOTE: The schemas should be tested separately to the API. So we
# don't need to test every variation via the API itself.
# Fetch a fixture
fixture = self.get_domain_fixture(fixture=0)
# Add a junk field to the body
fixture['junk'] = 'Junk Field'
# Ensure it fails with a 400
body = fixture
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
def test_create_zone_body_validation(self):
fixture = self.get_domain_fixture(fixture=0)
# Add id to the body
fixture['id'] = '2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 400
body = fixture
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
fixture = self.get_domain_fixture(fixture=0)
# Add created_at to the body
fixture['created_at'] = '2014-03-12T19:07:53.000000'
# Ensure it fails with a 400
body = fixture
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', body)
def test_create_zone_invalid_name(self):
# Try to create a zone with an invalid name
fixture = self.get_domain_fixture(fixture=-1)
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones', fixture)
@patch.object(central_service.Service, 'create_domain',
side_effect=messaging.MessagingTimeout())
def test_create_zone_timeout(self, _):
fixture = self.get_domain_fixture(fixture=0)
body = fixture
self._assert_exception('timeout', 504, self.client.post_json,
'/zones/', body)
@patch.object(central_service.Service, 'create_domain',
side_effect=exceptions.DuplicateDomain())
def test_create_zone_duplicate(self, _):
fixture = self.get_domain_fixture(fixture=0)
body = fixture
self._assert_exception('duplicate_domain', 409, self.client.post_json,
'/zones/', body)
def test_create_zone_missing_content_type(self):
self._assert_exception('unsupported_content_type', 415,
self.client.post, '/zones')
def test_create_zone_bad_content_type(self):
self._assert_exception(
'unsupported_content_type', 415, self.client.post, '/zones',
headers={'Content-type': 'test/goat'})
def test_zone_invalid_url(self):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980/invalid'
self._assert_exception('not_found', 404, self.client.get, url,
headers={'Accept': 'application/json'})
self._assert_exception('not_found', 404, self.client.patch_json, url)
self._assert_exception('not_found', 404, self.client.delete, url)
# Pecan returns a 405 for post
response = self.client.post(url, status=405)
self.assertEqual(405, response.status_int)
def test_get_zones(self):
response = self.client.get('/zones/')
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('zones', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 0 zones
self.assertEqual(0, len(response.json['zones']))
# We should start with 0 zones
self.assertEqual(0, len(response.json['zones']))
data = [self.create_domain(name='x-%s.com.' % i)
for i in 'abcdefghij']
self._assert_paging(data, '/zones', key='zones')
self._assert_invalid_paging(data, '/zones', key='zones')
@patch.object(central_service.Service, 'find_domains',
side_effect=messaging.MessagingTimeout())
def test_get_zones_timeout(self, _):
self._assert_exception('timeout', 504, self.client.get, '/zones/')
def test_get_zone(self):
# Create a zone
zone = self.create_domain()
response = self.client.get('/zones/%s' % zone['id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertEqual('PENDING', response.json['status'])
self.assertIsNone(response.json['updated_at'])
self.assertEqual(zone['name'], response.json['name'])
self.assertEqual(zone['email'], response.json['email'])
def test_get_zone_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s')
@patch.object(central_service.Service, 'get_domain',
side_effect=messaging.MessagingTimeout())
def test_get_zone_timeout(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('timeout', 504, self.client.get, url,
headers={'Accept': 'application/json'})
@patch.object(central_service.Service, 'get_domain',
side_effect=exceptions.DomainNotFound())
def test_get_zone_missing(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('domain_not_found', 404, self.client.get, url,
headers={'Accept': 'application/json'})
def test_get_zone_bad_accept(self):
url = '/zones/6e2146f3-87bc-4f47-adc5-4df0a5c78218'
self.client.get(url, headers={'Accept': 'test/goat'}, status=406)
def test_update_zone(self):
# Create a zone
zone = self.create_domain()
# Prepare an update body
body = {'email': 'prefix-%s' % zone['email']}
response = self.client.patch_json('/zones/%s' % zone['id'], body,
status=202)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
self.assertIn('status', response.json)
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIsNotNone(response.json['updated_at'])
self.assertEqual('prefix-%s' % zone['email'],
response.json['email'])
def test_update_zone_invalid_id(self):
self._assert_invalid_uuid(self.client.patch_json, '/zones/%s')
def test_update_zone_validation(self):
# NOTE: The schemas should be tested separatly to the API. So we
# don't need to test every variation via the API itself.
# Create a zone
zone = self.create_domain()
# Prepare an update body with junk in the body
body = {'email': 'prefix-%s' % zone['email'],
'junk': 'Junk Field'}
url = '/zones/%s' % zone['id']
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
# Prepare an update body with negative ttl in the body
body = {'email': 'prefix-%s' % zone['email'],
'ttl': -20}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
# Prepare an update body with ttl > maximum (2147483647) in the body
body = {'email': 'prefix-%s' % zone['email'],
'ttl': 2147483648}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.patch_json,
url, body)
@patch.object(central_service.Service, 'get_domain',
side_effect=exceptions.DuplicateDomain())
def test_update_zone_duplicate(self, _):
# Prepare an update body
body = {'email': '*****@*****.**'}
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 409
self._assert_exception('duplicate_domain', 409, self.client.patch_json,
url, body)
@patch.object(central_service.Service, 'get_domain',
side_effect=messaging.MessagingTimeout())
def test_update_zone_timeout(self, _):
# Prepare an update body
body = {'email': '*****@*****.**'}
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 504
self._assert_exception('timeout', 504, self.client.patch_json,
url, body)
@patch.object(central_service.Service, 'get_domain',
side_effect=exceptions.DomainNotFound())
def test_update_zone_missing(self, _):
# Prepare an update body
body = {'email': '*****@*****.**'}
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
# Ensure it fails with a 404
self._assert_exception('domain_not_found', 404, self.client.patch_json,
url, body)
def test_delete_zone(self):
zone = self.create_domain()
response = self.client.delete('/zones/%s' % zone['id'], status=202)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('DELETE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_delete_zone_invalid_id(self):
self._assert_invalid_uuid(self.client.delete, '/zones/%s')
@patch.object(central_service.Service, 'delete_domain',
side_effect=messaging.MessagingTimeout())
def test_delete_zone_timeout(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('timeout', 504, self.client.delete, url)
@patch.object(central_service.Service, 'delete_domain',
side_effect=exceptions.DomainNotFound())
def test_delete_zone_missing(self, _):
url = '/zones/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980'
self._assert_exception('domain_not_found', 404, self.client.delete,
url)
def test_post_abandon_zone(self):
zone = self.create_domain()
url = '/zones/%s/tasks/abandon' % zone.id
# Ensure that we get permission denied
self._assert_exception('forbidden', 403, self.client.post_json, url)
# Ensure that abandon zone succeeds with the right policy
self.policy({'abandon_domain': '@'})
response = self.client.post_json(url)
self.assertEqual(204, response.status_int)
def test_get_abandon_zone(self):
zone = self.create_domain()
url = '/zones/%s/tasks/abandon' % zone.id
self._assert_exception('method_not_allowed', 405, self.client.get, url)
def test_get_invalid_abandon(self):
# This is an invalid endpoint - should return 404
url = '/zones/tasks/abandon'
self._assert_exception('not_found', 404, self.client.get, url)
def test_get_zone_tasks(self):
# This is an invalid endpoint - should return 404
zone = self.create_domain()
url = '/zones/%s/tasks' % zone.id
self._assert_exception('not_found', 404, self.client.get, url)
def test_create_secondary(self):
# Create a zone
fixture = self.get_domain_fixture('SECONDARY', 0)
fixture['masters'] = ["10.0.0.1"]
response = self.client.post_json('/zones/', fixture)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertEqual('PENDING', response.json['status'])
self.assertEqual(cfg.CONF['service:central'].managed_resource_email,
response.json['email'])
self.assertIsNone(response.json['updated_at'])
# Zone is not transferred yet
self.assertIsNone(response.json['transferred_at'])
# Serial defaults to 1
self.assertEqual(response.json['serial'], 1)
for k in fixture:
self.assertEqual(fixture[k], response.json[k])
def test_create_secondary_no_masters(self):
# Create a zone
fixture = self.get_domain_fixture('SECONDARY', 0)
self._assert_exception('invalid_object', 400, self.client.post_json,
'/zones/', fixture)
def test_update_secondary(self):
# Create a zone
fixture = self.get_domain_fixture('SECONDARY', 0)
fixture['email'] = cfg.CONF['service:central'].managed_resource_email
fixture['attributes'] = [{"key": "master", "value": "10.0.0.10"}]
# Create a zone
zone = self.create_domain(**fixture)
masters = ['10.0.0.1', '10.0.0.2']
# Prepare an update body
body = {'masters': masters}
response = self.client.patch_json('/zones/%s' % zone['id'], body,
status=202)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
self.assertIn('status', response.json)
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIsNotNone(response.json['updated_at'])
self.assertEqual(masters, response.json['masters'])
self.assertEqual(1, response.json['serial'])
def test_update_secondary_email_invalid_object(self):
# Create a zone
fixture = self.get_domain_fixture('SECONDARY', 0)
fixture['email'] = cfg.CONF['service:central'].managed_resource_email
# Create a zone
zone = self.create_domain(**fixture)
body = {'email': '*****@*****.**'}
self._assert_exception('invalid_object', 400, self.client.patch_json,
'/zones/%s' % zone['id'], body)
# Metadata tests
def test_metadata_exists(self):
response = self.client.get('/zones/')
# Make sure the fields exist
self.assertIn('metadata', response.json)
self.assertIn('total_count', response.json['metadata'])
def test_total_count(self):
response = self.client.get('/zones/')
# There are no zones by default
self.assertEqual(0, response.json['metadata']['total_count'])
# Create a zone
fixture = self.get_domain_fixture(fixture=0)
response = self.client.post_json('/zones/', fixture)
response = self.client.get('/zones/')
# Make sure total_count picked it up
self.assertEqual(1, response.json['metadata']['total_count'])
def test_total_count_pagination(self):
# Create two zones
fixture = self.get_domain_fixture(fixture=0)
response = self.client.post_json('/zones/', fixture)
fixture = self.get_domain_fixture(fixture=1)
response = self.client.post_json('/zones/', fixture)
# Paginate so that there is only one zone returned
response = self.client.get('/zones?limit=1')
self.assertEqual(1, len(response.json['zones']))
# The total_count should know there are two
self.assertEqual(2, response.json['metadata']['total_count'])
def test_no_update_deleting(self):
# Create a zone
zone = self.create_domain()
# Prepare an update body
body = {'zone': {'email': 'prefix-%s' % zone['email']}}
self.client.delete('/zones/%s' % zone['id'], status=202)
self._assert_exception('bad_request', 400, self.client.patch_json,
'/zones/%s' % zone['id'], body)
def test_get_nameservers(self):
# Create a zone
zone = self.create_domain()
# Prepare an update body
response = self.client.get('/zones/%s/nameservers' % zone['id'],
headers=[('Accept', 'application/json')])
self.assertIn('nameservers', response.json)
self.assertEqual(1, len(response.json['nameservers']))
self.assertIn('hostname', response.json['nameservers'][0])
self.assertIn('priority', response.json['nameservers'][0])
class ApiV2RecordSetsTest(ApiV2TestCase):
def setUp(self):
super(ApiV2RecordSetsTest, self).setUp()
# Create a domain
self.domain = self.create_domain()
def test_create_recordset(self):
# Prepare a RecordSet fixture
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], fixture)
# Check the headers are what we expect
self.assertEqual(201, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertIsNone(response.json['updated_at'])
self.assertIn('records', response.json)
# The action and status are NONE and ACTIVE as there are no records
self.assertEqual('NONE', response.json['action'])
self.assertEqual('ACTIVE', response.json['status'])
def test_create_recordset_with_records(self):
# Prepare a RecordSet fixture
fixture = self.get_recordset_fixture(
self.domain['name'],
'A',
fixture=0,
values={'records': [
'192.0.2.1',
'192.0.2.2',
]})
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], fixture)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the values returned are what we expect
self.assertIn('records', response.json)
self.assertEqual(2, len(response.json['records']))
self.assertEqual('CREATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % self.domain['id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_create_recordset_with_invalid_name(self):
# Prepare a RecordSet fixture
body = self.get_recordset_fixture(self.domain['name'],
'A',
fixture=0,
values={
'name':
'`invalid`label`.%s' %
self.domain['name'],
'records': [
'192.0.2.1',
'192.0.2.2',
]
})
url = '/zones/%s/recordsets' % self.domain['id']
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
url, body)
def test_create_recordset_with_invalid_type(self):
# Prepare a RecordSet fixture
body = self.get_recordset_fixture(self.domain['name'],
'A',
fixture=0,
values={
'name':
'name.%s' % self.domain['name'],
'records': [
'192.0.2.1',
'192.0.2.2',
]
})
del body['type']
url = '/zones/%s/recordsets' % self.domain['id']
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
url, body)
def test_create_recordset_invalid_id(self):
self._assert_invalid_uuid(self.client.post, '/zones/%s/recordsets')
def test_create_recordset_validation(self):
# NOTE: The schemas should be tested separatly to the API. So we
# don't need to test every variation via the API itself.
# Fetch a fixture
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
url = '/zones/%s/recordsets' % self.domain['id']
# Add a junk field to the body
fixture['junk'] = 'Junk Field'
body = fixture
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.post_json,
url, body)
@patch.object(central_service.Service,
'create_recordset',
side_effect=messaging.MessagingTimeout())
def test_create_recordset_timeout(self, _):
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = fixture
url = '/zones/%s/recordsets' % self.domain['id']
self._assert_exception('timeout', 504, self.client.post_json, url,
body)
@patch.object(central_service.Service,
'create_recordset',
side_effect=exceptions.DuplicateRecordSet())
def test_create_recordset_duplicate(self, _):
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = fixture
url = '/zones/%s/recordsets' % self.domain['id']
self._assert_exception('duplicate_recordset', 409,
self.client.post_json, url, body)
def test_create_recordset_invalid_domain(self):
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = fixture
url = '/zones/ba751950-6193-11e3-949a-0800200c9a66/recordsets'
self._assert_exception('domain_not_found', 404, self.client.post_json,
url, body)
def test_recordsets_invalid_url(self):
url = '/zones/recordsets'
self._assert_exception('not_found', 404, self.client.get, url)
self._assert_exception('not_found', 404, self.client.post_json, url)
# Pecan returns a 405 for Patch and delete operations
response = self.client.patch_json(url, status=405)
self.assertEqual(405, response.status_int)
response = self.client.delete(url, status=405)
self.assertEqual(405, response.status_int)
def test_get_recordsets(self):
url = '/zones/%s/recordsets' % self.domain['id']
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('recordsets', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 2 pending recordsets for SOA & NS
# pending because pool manager is not active
self.assertEqual(2, len(response.json['recordsets']))
for recordset in response.json['recordsets']:
self.assertEqual('CREATE', recordset['action'])
self.assertEqual('PENDING', recordset['status'])
soa = self.central_service.find_recordset(self.admin_context,
criterion={
'domain_id':
self.domain['id'],
'type':
'SOA'
})
ns = self.central_service.find_recordset(self.admin_context,
criterion={
'domain_id':
self.domain['id'],
'type': 'NS'
})
data = [
self.create_recordset(self.domain,
name='x-%s.%s' % (i, self.domain['name']))
for i in xrange(0, 10)
]
data.insert(0, ns)
data.insert(0, soa)
self._assert_paging(data, url, key='recordsets')
self._assert_invalid_paging(data, url, key='recordsets')
def test_get_recordsets_filter(self):
# Add recordsets for testing
fixtures = [
self.get_recordset_fixture(
self.domain['name'],
'A',
fixture=0,
values={'records': [
'192.0.2.1',
'192.0.2.2',
]}),
self.get_recordset_fixture(
self.domain['name'],
'A',
fixture=1,
values={'records': ['192.0.2.1', '192.0.2.3']}),
]
for fixture in fixtures:
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], fixture)
get_urls = [
'/zones/%s/recordsets?data=192.0.2.1' % self.domain['id'],
'/zones/%s/recordsets?data=192.0.2.2' % self.domain['id'],
'/zones/%s/recordsets?data=192.0.2.1&name=%s' %
(self.domain['id'], fixtures[0]['name'])
]
correct_results = [2, 1, 1]
for get_url, correct_result in zip(get_urls, correct_results):
response = self.client.get(get_url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check that the correct number of recordsets match
self.assertEqual(correct_result, len(response.json['recordsets']))
def test_get_recordsets_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s/recordsets')
@patch.object(central_service.Service,
'get_domain',
side_effect=messaging.MessagingTimeout())
def test_get_recordsets_timeout(self, _):
url = '/zones/ba751950-6193-11e3-949a-0800200c9a66/recordsets'
self._assert_exception('timeout', 504, self.client.get, url)
def test_get_deleted_recordsets(self):
zone = self.create_domain(fixture=1)
self.create_recordset(zone)
url = '/zones/%s/recordsets' % zone['id']
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
# now delete the domain and get the recordsets
self.client.delete('/zones/%s' % zone['id'], status=202)
# Simulate the domain having been deleted on the backend
domain_serial = self.central_service.get_domain(
self.admin_context, zone['id']).serial
self.central_service.update_status(self.admin_context, zone['id'],
"SUCCESS", domain_serial)
# Check that we get a domain_not_found error
self._assert_exception('domain_not_found', 404, self.client.get, url)
def test_get_recordset(self):
# Create a recordset
recordset = self.create_recordset(self.domain)
url = '/zones/%s/recordsets/%s' % (self.domain['id'], recordset['id'])
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertIsNone(response.json['updated_at'])
self.assertEqual(recordset['name'], response.json['name'])
self.assertEqual(recordset['type'], response.json['type'])
# The action and status are NONE and ACTIVE as there are no records
self.assertEqual('NONE', response.json['action'])
self.assertEqual('ACTIVE', response.json['status'])
def test_get_recordset_invalid_id(self):
self._assert_invalid_uuid(self.client.get, '/zones/%s/recordsets/%s')
@patch.object(central_service.Service,
'get_recordset',
side_effect=messaging.MessagingTimeout())
def test_get_recordset_timeout(self, _):
url = '/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' % (
self.domain['id'])
self._assert_exception('timeout',
504,
self.client.get,
url,
headers={'Accept': 'application/json'})
@patch.object(central_service.Service,
'get_recordset',
side_effect=exceptions.RecordSetNotFound())
def test_get_recordset_missing(self, _):
url = '/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' % (
self.domain['id'])
self._assert_exception('recordset_not_found',
404,
self.client.get,
url,
headers={'Accept': 'application/json'})
def test_update_recordset(self):
# Create a recordset
recordset = self.create_recordset(self.domain)
# Prepare an update body
body = {'description': 'Tester'}
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.put_json(url, body, status=200)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIsNotNone(response.json['updated_at'])
self.assertEqual('Tester', response.json['description'])
# The action and status are NONE and ACTIVE as there are no records
self.assertEqual('NONE', response.json['action'])
self.assertEqual('ACTIVE', response.json['status'])
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % recordset['domain_id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_update_recordset_with_record_create(self):
# Create a recordset
recordset = self.create_recordset(self.domain, 'A')
# The action and status are NONE and ACTIVE as there are no records
self.assertEqual('NONE', recordset['action'])
self.assertEqual('ACTIVE', recordset['status'])
# Prepare an update body
body = {
'description': 'Tester',
'type': 'A',
'records': ['192.0.2.1', '192.0.2.2']
}
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.put_json(url, body, status=202)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the values returned are what we expect
self.assertIn('records', response.json)
self.assertEqual(2, len(response.json['records']))
self.assertEqual(set(['192.0.2.1', '192.0.2.2']),
set(response.json['records']))
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % recordset['domain_id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_update_recordset_with_record_replace(self):
# Create a recordset with one record
recordset = self.create_recordset(self.domain, 'A')
self.create_record(self.domain, recordset)
# Prepare an update body
body = {
'description': 'Tester',
'records': ['192.0.2.201', '192.0.2.202']
}
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.put_json(url, body, status=202)
# Check the headers are what we expect
self.assertEqual(202, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the values returned are what we expect
self.assertIn('records', response.json)
self.assertEqual(2, len(response.json['records']))
self.assertEqual(set(['192.0.2.201', '192.0.2.202']),
set(response.json['records']))
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % recordset['domain_id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_update_recordset_with_record_clear(self):
# Create a recordset with one record
recordset = self.create_recordset(self.domain, 'A')
self.create_record(self.domain, recordset)
# Prepare an update body
body = {'description': 'Tester', 'records': []}
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.put_json(url, body, status=200)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the values returned are what we expect
self.assertIn('records', response.json)
self.assertEqual(0, len(response.json['records']))
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % recordset['domain_id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_update_recordset_invalid_id(self):
self._assert_invalid_uuid(self.client.put_json,
'/zones/%s/recordsets/%s')
def test_update_recordset_validation(self):
# NOTE: The schemas should be tested separatly to the API. So we
# don't need to test every variation via the API itself.
# Create a zone
recordset = self.create_recordset(self.domain)
# Prepare an update body with junk in the wrapper
body = {
'description': 'Tester',
'records': ['192.3.3.17'],
'junk': 'Junk Field'
}
# Ensure it fails with a 400
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self._assert_exception('invalid_object', 400, self.client.put_json,
url, body)
# Prepare an update body with junk in the body
body = {'description': 'Tester', 'junk': 'Junk Field'}
# Ensure it fails with a 400
self._assert_exception('invalid_object', 400, self.client.put_json,
url, body)
@patch.object(central_service.Service,
'get_recordset',
side_effect=exceptions.DuplicateRecordSet())
def test_update_recordset_duplicate(self, _):
# Prepare an update body
body = {'description': 'Tester'}
# Ensure it fails with a 409
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' %
(self.domain['id']))
self._assert_exception('duplicate_recordset', 409,
self.client.put_json, url, body)
@patch.object(central_service.Service,
'get_recordset',
side_effect=messaging.MessagingTimeout())
def test_update_recordset_timeout(self, _):
# Prepare an update body
body = {'description': 'Tester'}
# Ensure it fails with a 504
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' %
(self.domain['id']))
self._assert_exception('timeout', 504, self.client.put_json, url, body)
@patch.object(central_service.Service,
'get_recordset',
side_effect=exceptions.RecordSetNotFound())
def test_update_recordset_missing(self, _):
# Prepare an update body
body = {'description': 'Tester'}
# Ensure it fails with a 404
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' %
(self.domain['id']))
self._assert_exception('recordset_not_found', 404,
self.client.put_json, url, body)
def test_delete_recordset(self):
recordset = self.create_recordset(self.domain)
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.delete(url, status=202)
self.assertEqual('application/json', response.content_type)
# Currently recordset does not have a status field. As there are no
# records, the recordset action/status show up as 'NONE', 'ACTIVE'
self.assertEqual('NONE', response.json['action'])
self.assertEqual('ACTIVE', response.json['status'])
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % recordset['domain_id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
def test_delete_recordset_with_records(self):
# Create a recordset with one record
recordset = self.create_recordset(self.domain, 'A')
self.create_record(self.domain, recordset)
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
response = self.client.delete(url, status=202)
self.assertEqual('application/json', response.content_type)
self.assertEqual('DELETE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
# Check the zone's status is as expected
response = self.client.get('/zones/%s' % recordset['domain_id'],
headers=[('Accept', 'application/json')])
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertEqual('UPDATE', response.json['action'])
self.assertEqual('PENDING', response.json['status'])
@patch.object(central_service.Service,
'delete_recordset',
side_effect=exceptions.RecordSetNotFound())
def test_delete_recordset_missing(self, _):
url = ('/zones/%s/recordsets/ba751950-6193-11e3-949a-0800200c9a66' %
(self.domain['id']))
self._assert_exception('recordset_not_found', 404, self.client.delete,
url)
def test_delete_recordset_invalid_id(self):
self._assert_invalid_uuid(self.client.delete,
'/zones/%s/recordsets/%s')
def test_metadata_exists(self):
url = '/zones/%s/recordsets' % self.domain['id']
response = self.client.get(url)
# Make sure the fields exist
self.assertIn('metadata', response.json)
self.assertIn('total_count', response.json['metadata'])
def test_total_count(self):
url = '/zones/%s/recordsets' % self.domain['id']
response = self.client.get(url)
# The NS and SOA records are there by default
self.assertEqual(2, response.json['metadata']['total_count'])
# Create a recordset
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], fixture)
response = self.client.get(url)
# Make sure total_count picked up the change
self.assertEqual(3, response.json['metadata']['total_count'])
def test_total_count_pagination(self):
# Create two recordsets
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], fixture)
fixture = self.get_recordset_fixture(self.domain['name'], fixture=1)
response = self.client.post_json(
'/zones/%s/recordsets' % self.domain['id'], fixture)
# Paginate the recordsets to two, there should be four now
url = '/zones/%s/recordsets?limit=2' % self.domain['id']
response = self.client.get(url)
# There are two recordsets returned
self.assertEqual(2, len(response.json['recordsets']))
# But there should be four in total (NS/SOA + the created)
self.assertEqual(4, response.json['metadata']['total_count'])
# Secondary Zones specific tests
def test_get_secondary_zone_recordset(self):
fixture = self.get_domain_fixture('SECONDARY', 1)
fixture['email'] = '*****@*****.**'
secondary = self.create_domain(**fixture)
# Create a recordset
recordset = self.create_recordset(secondary)
url = '/zones/%s/recordsets/%s' % (secondary['id'], recordset['id'])
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# Check the values returned are what we expect
self.assertIn('id', response.json)
self.assertIn('created_at', response.json)
self.assertIsNone(response.json['updated_at'])
self.assertEqual(recordset['name'], response.json['name'])
self.assertEqual(recordset['type'], response.json['type'])
def test_get_secondary_zone_recordsets(self):
fixture = self.get_domain_fixture('SECONDARY', 1)
fixture['email'] = '*****@*****.**'
secondary = self.create_domain(**fixture)
url = '/zones/%s/recordsets' % secondary['id']
response = self.client.get(url)
# Check the headers are what we expect
self.assertEqual(200, response.status_int)
self.assertEqual('application/json', response.content_type)
# Check the body structure is what we expect
self.assertIn('recordsets', response.json)
self.assertIn('links', response.json)
self.assertIn('self', response.json['links'])
# We should start with 2 recordsets for SOA & NS
self.assertEqual(1, len(response.json['recordsets']))
soa = self.central_service.find_recordset(self.admin_context,
criterion={
'domain_id':
secondary['id'],
'type': 'SOA'
})
data = [
self.create_recordset(secondary,
name='x-%s.%s' % (i, secondary['name']))
for i in xrange(0, 10)
]
data.insert(0, soa)
self._assert_paging(data, url, key='recordsets')
self._assert_invalid_paging(data, url, key='recordsets')
def test_create_secondary_zone_recordset(self):
fixture = self.get_domain_fixture('SECONDARY', 1)
fixture['email'] = '*****@*****.**'
secondary = self.create_domain(**fixture)
fixture = self.get_recordset_fixture(secondary['name'], fixture=0)
url = '/zones/%s/recordsets' % secondary['id']
self._assert_exception('forbidden', 403, self.client.post_json, url,
fixture)
def test_update_secondary_zone_recordset(self):
fixture = self.get_domain_fixture('SECONDARY', 1)
fixture['email'] = '*****@*****.**'
secondary = self.create_domain(**fixture)
# Set the context so that we can create a RRSet
recordset = self.create_recordset(secondary)
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self._assert_exception('forbidden', 403, self.client.put_json, url,
{'ttl': 100})
def test_delete_secondary_zone_recordset(self):
fixture = self.get_domain_fixture('SECONDARY', 1)
fixture['email'] = '*****@*****.**'
secondary = self.create_domain(**fixture)
# Set the context so that we can create a RRSet
recordset = self.create_recordset(secondary)
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self._assert_exception('forbidden', 403, self.client.delete, url)
def test_no_create_rs_deleting_zone(self):
# Prepare a create
fixture = self.get_recordset_fixture(self.domain['name'], fixture=0)
body = fixture
self.client.delete('/zones/%s' % self.domain['id'], status=202)
self._assert_exception('bad_request', 400, self.client.post_json,
'/zones/%s/recordsets' % self.domain['id'],
body)
def test_no_update_rs_deleting_zone(self):
# Create a recordset
recordset = self.create_recordset(self.domain)
# Prepare an update body
body = {'description': 'Tester'}
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self.client.delete('/zones/%s' % self.domain['id'], status=202)
self._assert_exception('bad_request', 400, self.client.put_json, url,
body)
def test_no_delete_rs_deleting_zone(self):
# Create a recordset
recordset = self.create_recordset(self.domain)
url = '/zones/%s/recordsets/%s' % (recordset['domain_id'],
recordset['id'])
self.client.delete('/zones/%s' % self.domain['id'], status=202)
self._assert_exception('bad_request', 400, self.client.delete, url)
class ApiV1ServersTest(ApiV1Test):
def setUp(self):
super(ApiV1ServersTest, self).setUp()
# All Server Checks should be performed as an admin, so..
# Override to policy to make everyone an admin.
self.policy({'admin': '@'})
def test_create_server(self):
# Create a server
fixture = self.get_server_fixture(0)
response = self.post('servers', data=fixture)
self.assertIn('id', response.json)
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], fixture['name'])
@patch.object(central_service.Service, 'create_server')
def test_create_server_trailing_slash(self, mock):
# Create a server with a trailing slash
self.post('servers/', data=self.get_server_fixture(0))
# verify that the central service is called
self.assertTrue(mock.called)
def test_create_server_junk(self):
# Create a server
fixture = self.get_server_fixture(0)
# Add a junk property
fixture['junk'] = 'Junk Field'
# Ensure it fails with a 400
self.post('servers', data=fixture, status_code=400)
@patch.object(central_service.Service,
'create_server',
side_effect=messaging.MessagingTimeout())
def test_create_server_timeout(self, _):
# Create a server
fixture = self.get_server_fixture(0)
self.post('servers', data=fixture, status_code=504)
@patch.object(central_service.Service,
'create_server',
side_effect=exceptions.DuplicateServer())
def test_create_server_duplicate(self, _):
# Create a server
fixture = self.get_server_fixture(0)
self.post('servers', data=fixture, status_code=409)
def test_get_servers(self):
response = self.get('servers')
self.assertIn('servers', response.json)
self.assertEqual(0, len(response.json['servers']))
# Create a server
self.create_server()
response = self.get('servers')
self.assertIn('servers', response.json)
self.assertEqual(1, len(response.json['servers']))
# Create a second server
self.create_server(fixture=1)
response = self.get('servers')
self.assertIn('servers', response.json)
self.assertEqual(2, len(response.json['servers']))
@patch.object(central_service.Service, 'find_servers')
def test_get_servers_trailing_slash(self, mock):
self.get('servers/')
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service,
'find_servers',
side_effect=messaging.MessagingTimeout())
def test_get_servers_timeout(self, _):
self.get('servers', status_code=504)
def test_get_server(self):
# Create a server
server = self.create_server()
response = self.get('servers/%s' % server['id'])
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], server['id'])
@patch.object(central_service.Service, 'get_server')
def test_get_server_trailing_slash(self, mock):
# Create a server
server = self.create_server()
self.get('servers/%s/' % server['id'])
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service,
'get_server',
side_effect=messaging.MessagingTimeout())
def test_get_server_timeout(self, _):
# Create a server
server = self.create_server()
self.get('servers/%s' % server['id'], status_code=504)
def test_get_server_missing(self):
self.get('servers/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
def test_update_server(self):
# Create a server
server = self.create_server()
data = {'name': 'test.example.org.'}
response = self.put('servers/%s' % server['id'], data=data)
self.assertIn('id', response.json)
self.assertEqual(response.json['id'], server['id'])
self.assertIn('name', response.json)
self.assertEqual(response.json['name'], 'test.example.org.')
@patch.object(central_service.Service, 'update_server')
def test_update_server_trailing_slash(self, mock):
# Create a server
server = self.create_server()
data = {'name': 'test.example.org.'}
self.put('servers/%s/' % server['id'], data=data)
# verify that the central service is called
self.assertTrue(mock.called)
def test_update_server_junk(self):
# Create a server
server = self.create_server()
data = {'name': 'test.example.org.', 'junk': 'Junk Field'}
self.put('servers/%s' % server['id'], data=data, status_code=400)
@patch.object(central_service.Service,
'update_server',
side_effect=messaging.MessagingTimeout())
def test_update_server_timeout(self, _):
# Create a server
server = self.create_server()
data = {'name': 'test.example.org.'}
self.put('servers/%s' % server['id'], data=data, status_code=504)
@patch.object(central_service.Service,
'update_server',
side_effect=exceptions.DuplicateServer())
def test_update_server_duplicate(self, _):
server = self.create_server()
data = {'name': 'test.example.org.'}
self.put('servers/%s' % server['id'], data=data, status_code=409)
def test_update_server_missing(self):
data = {'name': 'test.example.org.'}
self.get('servers/2fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
data=data,
status_code=404)
def test_delete_server(self):
# Create a server
server = self.create_server()
# Create a second server so that we can delete the first
# because the last remaining server is not allowed to be deleted
server2 = self.create_server(fixture=1)
# Now delete the server
self.delete('servers/%s' % server['id'])
# Ensure we can no longer fetch the deleted server
self.get('servers/%s' % server['id'], status_code=404)
# Also, verify we cannot delete last remaining server
self.delete('servers/%s' % server2['id'], status_code=400)
@patch.object(central_service.Service, 'delete_server')
def test_delete_server_trailing_slash(self, mock):
# Create a server
server = self.create_server()
self.delete('servers/%s/' % server['id'])
# verify that the central service is called
self.assertTrue(mock.called)
@patch.object(central_service.Service,
'delete_server',
side_effect=messaging.MessagingTimeout())
def test_delete_server_timeout(self, _):
# Create a server
server = self.create_server()
self.delete('servers/%s' % server['id'], status_code=504)
def test_delete_server_missing(self):
self.delete('servers/9fdadfb1-cf96-4259-ac6b-bb7b6d2ff980',
status_code=404)
