def test_import_domain(self):
user = '******'
resp, zone = ZoneClient.as_user(user).post_zone(
datagen.random_zone_data())
ZoneClient.as_user(user).wait_for_zone(zone.id)
export_client = ZoneExportClient.as_user(user)
resp, model = export_client.post_zone_export(zone.id)
export_id = model.id
self.assertEqual(resp.status, 202)
self.assertEqual(model.status, 'PENDING')
export_client.wait_for_zone_export(export_id)
resp, model = export_client.get_zone_export(export_id)
self.assertEqual(resp.status, 200)
self.assertEqual(model.status, 'COMPLETE')
resp, body = export_client.get_exported_zone(export_id)
self.assertEqual(resp.status, 200)
export_client.delete_zone_export(export_id)
self.assertRaises(NotFound,
lambda: export_client.get_zone_export(model.id))
def setUp(self):
super(ZoneTest, self).setUp()
self.increase_quotas(user='******')
self.authed_client = ZoneClient.as_user('default')
self.client = ZoneClient.as_user('default', with_token=False)
self.fixture = self.useFixture(ZoneFixture(user='******'))
self.zone = None
def setUp(self):
super(TransferZoneOwnerShipTest, self).setUp()
self.increase_quotas(user='******')
self.increase_quotas(user='******')
resp, self.zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
ZoneClient.as_user('default').wait_for_zone(self.zone.id)
def test_do_zone_transfer_scoped(self):
target_project_id = TransferRequestClient.as_user('alt').tenant_id
resp, transfer_request = TransferRequestClient.as_user('default')\
.post_transfer_request(self.zone.id,
datagen.random_transfer_request_data(
target_project_id=target_project_id))
self.assertEqual(resp.status, 201)
resp, retrived_transfer_request = TransferRequestClient.\
as_user('alt').get_transfer_request(transfer_request.id)
self.assertEqual(resp.status, 200)
resp, transfer_accept = TransferAcceptClient.as_user('alt')\
.post_transfer_accept(
datagen.random_transfer_accept_data(
key=transfer_request.key,
zone_transfer_request_id=transfer_request.id
))
self.assertEqual(resp.status, 201)
client = ZoneClient.as_user('default')
self._assert_exception(exceptions.NotFound, 'domain_not_found', 404,
client.get_zone, self.zone.id)
resp, zone = ZoneClient.as_user('alt').get_zone(self.zone.id)
self.assertEqual(resp.status, 200)
def setUp(self):
super(RecordsetTest, self).setUp()
self.increase_quotas(user='******')
resp, self.zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
ZoneClient.as_user('default').wait_for_zone(self.zone.id)
self.client = RecordsetClient.as_user('default', with_token=False)
def test_no_create_duplicate_domain(self):
post_model = self.useFixture(ZoneFixture(user='******')).post_model
self.assertRaises(
Conflict,
lambda: ZoneClient.as_user('default').post_zone(post_model))
self.assertRaises(
Conflict, lambda: ZoneClient.as_user('alt').post_zone(post_model))
def setUp(self):
super(RecordsetTest, self).setUp()
self.increase_quotas(user='******')
resp, self.zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
ZoneClient.as_user('default').wait_for_zone(self.zone.id)
self.client = RecordsetClient.as_user('default', with_token=False)
def test_do_zone_transfer_scoped(self):
target_project_id = TransferRequestClient.as_user('alt').tenant_id
post_model = datagen.random_transfer_request_data(
target_project_id=target_project_id)
fixture = self.useFixture(
TransferRequestFixture(
zone=self.zone,
post_model=post_model,
user='******',
target_user='******',
))
transfer_request = fixture.transfer_request
resp, retrived_transfer_request = TransferRequestClient.\
as_user('alt').get_transfer_request(transfer_request.id)
self.assertEqual(200, resp.status)
resp, transfer_accept = TransferAcceptClient.as_user('alt')\
.post_transfer_accept(
datagen.random_transfer_accept_data(
key=transfer_request.key,
zone_transfer_request_id=transfer_request.id
))
self.assertEqual(201, resp.status)
client = ZoneClient.as_user('default')
self._assert_exception(exceptions.NotFound, 'zone_not_found', 404,
client.get_zone, self.zone.id)
resp, zone = ZoneClient.as_user('alt').get_zone(self.zone.id)
self.assertEqual(200, resp.status)
def test_do_zone_transfer_scoped(self):
target_project_id = TransferRequestClient.as_user('alt').tenant_id
post_model = datagen.random_transfer_request_data(
target_project_id=target_project_id)
fixture = self.useFixture(TransferRequestFixture(
zone=self.zone,
post_model=post_model,
user='******',
target_user='******',
))
transfer_request = fixture.transfer_request
resp, retrived_transfer_request = TransferRequestClient.\
as_user('alt').get_transfer_request(transfer_request.id)
self.assertEqual(200, resp.status)
resp, transfer_accept = TransferAcceptClient.as_user('alt')\
.post_transfer_accept(
datagen.random_transfer_accept_data(
key=transfer_request.key,
zone_transfer_request_id=transfer_request.id
))
self.assertEqual(201, resp.status)
client = ZoneClient.as_user('default')
self._assert_exception(
exceptions.NotFound, 'domain_not_found', 404,
client.get_zone, self.zone.id)
resp, zone = ZoneClient.as_user('alt').get_zone(self.zone.id)
self.assertEqual(200, resp.status)
def setUp(self):
super(TransferZoneOwnerShipTest, self).setUp()
self.increase_quotas(user='******')
self.increase_quotas(user='******')
resp, self.zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
ZoneClient.as_user('default').wait_for_zone(self.zone.id)
def test_do_zone_transfer_scoped(self):
target_project_id = TransferRequestClient.as_user('alt').tenant_id
resp, transfer_request = TransferRequestClient.as_user('default')\
.post_transfer_request(self.zone.id,
datagen.random_transfer_request_data(
target_project_id=target_project_id))
self.assertEqual(resp.status, 201)
resp, retrived_transfer_request = TransferRequestClient.\
as_user('alt').get_transfer_request(transfer_request.id)
self.assertEqual(resp.status, 200)
resp, transfer_accept = TransferAcceptClient.as_user('alt')\
.post_transfer_accept(
datagen.random_transfer_accept_data(
key=transfer_request.key,
zone_transfer_request_id=transfer_request.id
))
self.assertEqual(resp.status, 201)
client = ZoneClient.as_user('default')
self._assert_exception(
exceptions.NotFound, 'domain_not_found', 404,
client.get_zone, self.zone.id)
resp, zone = ZoneClient.as_user('alt').get_zone(self.zone.id)
self.assertEqual(resp.status, 200)
def test_no_create_subdomain_by_alt_user(self):
zone = self.useFixture(ZoneFixture(user='******')).post_model
subzone = datagen.random_zone_data(name='sub.' + zone.name)
subsubzone = datagen.random_zone_data(name='sub.sub.' + zone.name)
self.assertRaises(Forbidden,
lambda: ZoneClient.as_user('alt').post_zone(subzone))
self.assertRaises(Forbidden,
lambda: ZoneClient.as_user('alt').post_zone(subsubzone))
def test_no_create_subdomain_by_alt_user(self):
zone = self.useFixture(ZoneFixture(user='******')).post_model
subzone = datagen.random_zone_data(name='sub.' + zone.name)
subsubzone = datagen.random_zone_data(name='sub.sub.' + zone.name)
self.assertRaises(Forbidden,
lambda: ZoneClient.as_user('alt').post_zone(subzone))
self.assertRaises(
Forbidden, lambda: ZoneClient.as_user('alt').post_zone(subsubzone))
def _create_transfer_request(self):
client = TransferRequestClient.as_user(self.user)
self.post_resp, self.transfer_request = client \
.post_transfer_request(self.zone.id, self.post_model)
assert self.post_resp.status == 201
self.addCleanup(self.cleanup_transfer_request, client,
self.transfer_request.id)
self.addCleanup(ZoneFixture.cleanup_zone,
ZoneClient.as_user(self.user), self.zone.id)
self.addCleanup(ZoneFixture.cleanup_zone,
ZoneClient.as_user(self.target_user), self.zone.id)
def _create_transfer_request(self):
client = TransferRequestClient.as_user(self.user)
self.post_resp, self.transfer_request = client \
.post_transfer_request(self.zone.id, self.post_model)
assert self.post_resp.status == 201
self.addCleanup(self.cleanup_transfer_request, client,
self.transfer_request.id)
self.addCleanup(ZoneFixture.cleanup_zone,
ZoneClient.as_user(self.user), self.zone.id)
self.addCleanup(ZoneFixture.cleanup_zone,
ZoneClient.as_user(self.target_user), self.zone.id)
def test_no_create_recordset_via_alt_domain(self):
resp, zone = ZoneClient.as_user("default").post_zone(datagen.random_zone_data())
resp, alt_zone = ZoneClient.as_user("alt").post_zone(datagen.random_zone_data())
# alt attempts to create record with name A12345.{zone}
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(
RestClientException, lambda: RecordsetClient.as_user("alt").post_recordset(zone.id, recordset)
)
self.assertRaises(
RestClientException, lambda: RecordsetClient.as_user("alt").post_recordset(alt_zone.id, recordset)
)
def test_update_zone(self):
old_model = self.fixture.created_zone
patch_model = datagen.random_zone_data()
del patch_model.name # don't try to override the zone name
resp, new_model = ZoneClient.as_user("default").patch_zone(old_model.id, patch_model)
self.assertEqual(resp.status, 202)
ZoneClient.as_user("default").wait_for_zone(new_model.id)
resp, model = ZoneClient.as_user("default").get_zone(new_model.id)
self.assertEqual(resp.status, 200)
self.assertEqual(new_model.id, old_model.id)
self.assertEqual(new_model.name, old_model.name)
self.assertEqual(new_model.ttl, patch_model.ttl)
self.assertEqual(new_model.email, patch_model.email)
def test_import_domain(self):
user = '******'
import_client = ZoneImportClient.as_user(user)
zone_client = ZoneClient.as_user(user)
zonefile = datagen.random_zonefile_data()
resp, model = import_client.post_zone_import(
zonefile)
import_id = model.id
self.assertEqual(resp.status, 202)
self.assertEqual(model.status, 'PENDING')
import_client.wait_for_zone_import(import_id)
resp, model = import_client.get_zone_import(
model.id)
self.assertEqual(resp.status, 200)
self.assertEqual(model.status, 'COMPLETE')
# Wait for the zone to become 'ACTIVE'
zone_client.wait_for_zone(model.zone_id)
resp, zone_model = zone_client.get_zone(model.zone_id)
# Now make sure we can delete the zone_import
import_client.delete_zone_import(import_id)
self.assertRaises(NotFound,
lambda: import_client.get_zone_import(model.id))
def setUp(self):
super(RecordsetFuzzTest, self).setUp()
# self.increase_quotas(user='******')
resp, self.zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
# ZoneClient.as_user('default').wait_for_zone(self.zone.id)
self.client = RecordsetClient.as_user('default')
def test_no_create_recordset_via_alt_domain(self):
resp, zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
resp, alt_zone = ZoneClient.as_user('alt').post_zone(
datagen.random_zone_data())
# alt attempts to create record with name A12345.{zone}
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(
RestClientException,
lambda: RecordsetClient.as_user('alt').post_recordset(
zone.id, recordset))
self.assertRaises(
RestClientException,
lambda: RecordsetClient.as_user('alt').post_recordset(
alt_zone.id, recordset))
def test_update_zone(self):
old_model = self.fixture.created_zone
patch_model = datagen.random_zone_data()
del patch_model.name # don't try to override the zone name
resp, new_model = ZoneClient.as_user('default').patch_zone(
old_model.id, patch_model)
self.assertEqual(202, resp.status)
ZoneClient.as_user('default').wait_for_zone(new_model.id)
resp, model = ZoneClient.as_user('default').get_zone(new_model.id)
self.assertEqual(200, resp.status)
self.assertEqual(old_model.id, new_model.id)
self.assertEqual(old_model.name, new_model.name)
self.assertEqual(patch_model.ttl, new_model.ttl)
self.assertEqual(patch_model.email, new_model.email)
def test_update_zone(self):
post_model = datagen.random_zone_data()
resp, old_model = self._create_zone(post_model)
patch_model = datagen.random_zone_data()
del patch_model.name # don't try to override the zone name
resp, new_model = ZoneClient.as_user('default').patch_zone(
old_model.id, patch_model)
self.assertEqual(resp.status, 202)
ZoneClient.as_user('default').wait_for_zone(new_model.id)
resp, model = ZoneClient.as_user('default').get_zone(new_model.id)
self.assertEqual(resp.status, 200)
self.assertEqual(new_model.id, old_model.id)
self.assertEqual(new_model.name, old_model.name)
self.assertEqual(new_model.ttl, patch_model.ttl)
self.assertEqual(new_model.email, patch_model.email)
class DesignateV2Test(BaseDesignateTest):
def __init__(self, *args, **kwargs):
super(DesignateV2Test, self).__init__(*args, **kwargs)
self.zone_client = ZoneClient(self.base_client)
self.quotas_client = QuotasClient(self.base_client)
self.recordset_client = RecordsetClient(self.base_client)
def wait_for_zone(self, zone_id):
self.wait_for_condition(lambda: self.is_zone_active(zone_id))
def wait_for_zone_404(self, zone_id):
self.wait_for_condition(lambda: self.is_zone_404(zone_id))
def is_zone_active(self, zone_id):
resp, model = self.zone_client.get_zone(zone_id)
self.assertEqual(resp.status, 200)
if model.status == 'ACTIVE':
return True
elif model.status == 'ERROR':
raise Exception("Saw ERROR status")
return False
def is_zone_404(self, zone_id):
try:
# tempest_lib rest client raises exceptions on bad status codes
resp, model = self.zone_client.get_zone(zone_id)
except NotFound:
return True
return False
def increase_quotas(self):
self.quotas_client.patch_quotas(
self.quotas_client.client.tenant_id,
QuotasModel.from_dict({
'quota': {
'zones': 9999999,
'recordset_records': 9999999,
'zone_records': 9999999,
'zone_recordsets': 9999999
}
}))
def test_no_create_super_recordsets(self):
# default creates zone a.b.c.example.com.
# alt fails to create record with name b.c.example.com
zone_data = datagen.random_zone_data()
recordset = datagen.random_a_recordset(zone_name=zone_data.name)
recordset.name = 'b.c.' + zone_data.name
zone_data.name = 'a.b.c.' + zone_data.name
resp, zone = ZoneClient.as_user('default').post_zone(zone_data)
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(zone.id, recordset))
def test_no_create_super_recordsets(self):
# default creates zone a.b.c.example.com.
# alt fails to create record with name b.c.example.com
zone_data = datagen.random_zone_data()
recordset = datagen.random_a_recordset(zone_name=zone_data.name)
recordset.name = 'b.c.' + zone_data.name
zone_data.name = 'a.b.c.' + zone_data.name
resp, zone = ZoneClient.as_user('default').post_zone(zone_data)
self.assertRaises(
RestClientException,
lambda: RecordsetClient.as_user('alt').post_recordset(
zone.id, recordset))
def test_no_create_recordset_by_alt_tenant(self):
resp, zone = ZoneClient.as_user("default").post_zone(datagen.random_zone_data())
# try with name=A123456.zone.com.
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(
RestClientException, lambda: RecordsetClient.as_user("alt").post_recordset(zone.id, recordset)
)
# try with name=zone.com.
recordset.name = zone.name
self.assertRaises(
RestClientException, lambda: RecordsetClient.as_user("alt").post_recordset(zone.id, recordset)
)
def test_no_create_recordset_by_alt_tenant(self):
resp, zone = ZoneClient.as_user('default').post_zone(
datagen.random_zone_data())
# try with name=A123456.zone.com.
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(
RestClientException,
lambda: RecordsetClient.as_user('alt').post_recordset(
zone.id, recordset))
# try with name=zone.com.
recordset.name = zone.name
self.assertRaises(
RestClientException,
lambda: RecordsetClient.as_user('alt').post_recordset(
zone.id, recordset))
def test_import_domain(self):
user = "******"
import_client = ZoneImportClient.as_user(user)
zone_client = ZoneClient.as_user(user)
fixture = self.useFixture(ZoneImportFixture(user=user))
import_id = fixture.zone_import.id
resp, model = import_client.get_zone_import(import_id)
self.assertEqual(resp.status, 200)
self.assertEqual(model.status, "COMPLETE")
self.addCleanup(ZoneFixture.cleanup_zone, zone_client, model.zone_id)
# Wait for the zone to become 'ACTIVE'
zone_client.wait_for_zone(model.zone_id)
resp, zone_model = zone_client.get_zone(model.zone_id)
# Now make sure we can delete the zone_import
import_client.delete_zone_import(import_id)
self.assertRaises(NotFound, lambda: import_client.get_zone_import(model.id))
def test_import_domain(self):
user = '******'
import_client = ZoneImportClient.as_user(user)
zone_client = ZoneClient.as_user(user)
fixture = self.useFixture(ZoneImportFixture(user=user))
import_id = fixture.zone_import.id
resp, model = import_client.get_zone_import(import_id)
self.assertEqual(200, resp.status)
self.assertEqual('COMPLETE', model.status)
self.addCleanup(ZoneFixture.cleanup_zone, zone_client, model.zone_id)
# Wait for the zone to become 'ACTIVE'
zone_client.wait_for_zone(model.zone_id)
resp, zone_model = zone_client.get_zone(model.zone_id)
# Now make sure we can delete the zone_import
import_client.delete_zone_import(import_id)
self.assertRaises(NotFound,
lambda: import_client.get_zone_import(model.id))
def test_import_domain(self):
user = '******'
import_client = ZoneImportClient.as_user(user)
zone_client = ZoneClient.as_user(user)
zonefile = datagen.random_zonefile_data()
resp, model = import_client.post_zone_import(zonefile)
import_id = model.id
self.assertEqual(resp.status, 202)
self.assertEqual(model.status, 'PENDING')
import_client.wait_for_zone_import(import_id)
resp, model = import_client.get_zone_import(model.id)
self.assertEqual(resp.status, 200)
self.assertEqual(model.status, 'COMPLETE')
# Wait for the zone to become 'ACTIVE'
zone_client.wait_for_zone(model.zone_id)
resp, zone_model = zone_client.get_zone(model.zone_id)
# Now make sure we can delete the zone_import
import_client.delete_zone_import(import_id)
self.assertRaises(NotFound,
lambda: import_client.get_zone_import(model.id))
def tearDown(self):
super(RecordsetTest, self).tearDown()
resp, self.zone = ZoneClient.as_user('default').delete_zone(
self.zone.id)
def __init__(self, *args, **kwargs):
super(ZoneTest, self).__init__(*args, **kwargs)
self.client = ZoneClient(self.base_client)
self.quotas_client = QuotasClient(self.base_client)
class ZoneTest(BaseDesignateTest):
def __init__(self, *args, **kwargs):
super(ZoneTest, self).__init__(*args, **kwargs)
self.client = ZoneClient(self.base_client)
self.quotas_client = QuotasClient(self.base_client)
def setUp(self):
super(ZoneTest, self).setUp()
self.quotas_client.patch_quotas(
self.quotas_client.client.tenant_id,
QuotasModel.from_dict({
'quota': {
'zones': 9999999,
'recordset_records': 9999999,
'zone_records': 9999999,
'zone_recordsets': 9999999
}
}))
def wait_for_zone(self, zone_id):
self.wait_for_condition(lambda: self.is_zone_active(zone_id))
def wait_for_404(self, zone_id):
self.wait_for_condition(lambda: self.is_zone_404(zone_id))
def _create_zone(self, zone_model):
resp, model = self.client.post_zone(zone_model)
self.assertEqual(resp.status, 202)
self.wait_for_zone(model.zone.id)
return resp, model
def test_list_zones(self):
self._create_zone(datagen.random_zone_data())
resp, model = self.client.list_zones()
self.assertEqual(resp.status, 200)
self.assertGreater(len(model.zones), 0)
def test_create_zone(self):
self._create_zone(datagen.random_zone_data())
def test_update_zone(self):
post_model = datagen.random_zone_data()
resp, old_model = self._create_zone(post_model)
patch_model = datagen.random_zone_data()
del patch_model.zone.name # don't try to override the zone name
resp, new_model = self.client.patch_zone(old_model.zone.id,
patch_model)
self.assertEqual(resp.status, 202)
self.wait_for_zone(new_model.zone.id)
resp, model = self.client.get_zone(new_model.zone.id)
self.assertEqual(resp.status, 200)
self.assertEqual(new_model.zone.id, old_model.zone.id)
self.assertEqual(new_model.zone.name, old_model.zone.name)
self.assertEqual(new_model.zone.ttl, patch_model.zone.ttl)
self.assertEqual(new_model.zone.email, patch_model.zone.email)
def test_delete_zone(self):
resp, model = self._create_zone(datagen.random_zone_data())
resp, model = self.client.delete_zone(model.zone.id)
self.assertEqual(resp.status, 202)
self.wait_for_404(model.zone.id)
def test_no_create_superdomain_by_alt_user(self):
superzone = datagen.random_zone_data()
zone = datagen.random_zone_data(name="a.b." + superzone.name)
self.useFixture(ZoneFixture(zone, user='******'))
self.assertRaises(
Forbidden, lambda: ZoneClient.as_user('alt').post_zone(superzone))
def test_list_zones(self):
self._create_zone(datagen.random_zone_data())
resp, model = ZoneClient.as_user('default').list_zones()
self.assertEqual(resp.status, 200)
self.assertGreater(len(model.zones), 0)
def _create_zone(self):
client = ZoneClient.as_user(self.user)
self.post_resp, self.created_zone = client.post_zone(self.post_model)
assert self.post_resp.status == 202
self.addCleanup(self.cleanup_zone, client, self.created_zone.id)
client.wait_for_zone(self.created_zone.id)
def __init__(self, *args, **kwargs):
super(DesignateV2Test, self).__init__(*args, **kwargs)
self.zone_client = ZoneClient(self.base_client)
self.quotas_client = QuotasClient(self.base_client)
self.recordset_client = RecordsetClient(self.base_client)
def _create_zone(self, zone_model, user):
resp, model = ZoneClient.as_user(user).post_zone(zone_model)
self.assertEqual(resp.status, 202)
ZoneClient.as_user(user).wait_for_zone(model.id)
return resp, model
def test_delete_zone(self):
client = ZoneClient.as_user('default')
resp, model = client.delete_zone(self.fixture.created_zone.id)
self.assertEqual(202, resp.status)
client.wait_for_zone_404(model.id)
def test_delete_zone(self):
resp, model = self._create_zone(datagen.random_zone_data())
resp, model = ZoneClient.as_user('default').delete_zone(model.id)
self.assertEqual(resp.status, 202)
ZoneClient.as_user('default').wait_for_zone_404(model.id)
def test_list_zones(self):
resp, model = ZoneClient.as_user("default").list_zones()
self.assertEqual(resp.status, 200)
self.assertGreater(len(model.zones), 0)
def test_list_zones(self):
self._create_zone(datagen.random_zone_data())
resp, model = ZoneClient.as_user('default').list_zones()
self.assertEqual(resp.status, 200)
self.assertGreater(len(model.zones), 0)
def test_list_zones_dot_json_fails(self):
self.assertRaises(NotFound,
lambda: ZoneClient.as_user('default').zones_dot_json())
def _create_zone(self, zone_model, user='******'):
resp, model = ZoneClient.as_user(user).post_zone(zone_model)
self.assertEqual(resp.status, 202)
# ZoneClient.as_user(user).wait_for_zone(model.id)
return resp, model
def setUp(self):
super(ZoneTest, self).setUp()
self.increase_quotas(user='******')
self.client = ZoneClient.as_user('default', with_token=False)
self.fixture = self.useFixture(ZoneFixture(user='******'))
def test_list_zones_dot_json_fails(self):
self.assertRaises(
NotFound, lambda: ZoneClient.as_user('default').zones_dot_json())
def setUp(self):
super(RecordsetTest, self).setUp()
self.increase_quotas(user="******")
resp, self.zone = ZoneClient.as_user("default").post_zone(datagen.random_zone_data())
ZoneClient.as_user("default").wait_for_zone(self.zone.id)
def test_delete_zone(self):
resp, model = self._create_zone(datagen.random_zone_data())
resp, model = ZoneClient.as_user('default').delete_zone(model.id)
self.assertEqual(resp.status, 202)
ZoneClient.as_user('default').wait_for_zone_404(model.id)
def tearDown(self):
super(RecordsetTest, self).tearDown()
resp, self.zone = ZoneClient.as_user('default').delete_zone(
self.zone.id)
def test_list_zones(self):
resp, model = ZoneClient.as_user('default').list_zones()
self.assertEqual(200, resp.status)
self.assertGreater(len(model.zones), 0)
def test_list_zones(self):
resp, model = ZoneClient.as_user('default').list_zones()
self.assertEqual(200, resp.status)
self.assertGreater(len(model.zones), 0)
def test_delete_zone(self):
client = ZoneClient.as_user('default')
resp, model = client.delete_zone(self.fixture.created_zone.id)
self.assertEqual(202, resp.status)
client.wait_for_zone_404(model.id)
def test_no_create_duplicate_domain(self):
post_model = self.useFixture(ZoneFixture(user='******')).post_model
self.assertRaises(Conflict,
lambda: ZoneClient.as_user('default').post_zone(post_model))
self.assertRaises(Conflict,
lambda: ZoneClient.as_user('alt').post_zone(post_model))
def setUp(self):
super(ZoneFuzzTest, self).setUp()
self.client = ZoneClient.as_user('default')
self.increase_quotas(user='******')
def test_no_create_superdomain_by_alt_user(self):
superzone = datagen.random_zone_data()
zone = datagen.random_zone_data(name="a.b." + superzone.name)
self.useFixture(ZoneFixture(zone, user='******'))
self.assertRaises(Forbidden,
lambda: ZoneClient.as_user('alt').post_zone(superzone))
def _create_zone(self):
client = ZoneClient.as_user(self.user)
self.post_resp, self.created_zone = client.post_zone(self.post_model)
assert self.post_resp.status == 202
self.addCleanup(self.cleanup_zone, client, self.created_zone.id)
client.wait_for_zone(self.created_zone.id)
