def test_crud_recordset(self, make_recordset):
post_model = make_recordset(self.zone)
resp, post_resp_model = RecordsetClient.as_user("default").post_recordset(self.zone.id, post_model)
self.assertEqual(resp.status, 202, "on post response")
self.assertEqual(post_resp_model.status, "PENDING")
self.assertEqual(post_resp_model.name, post_model.name)
self.assertEqual(post_resp_model.records, post_model.records)
self.assertEqual(post_resp_model.ttl, post_model.ttl)
recordset_id = post_resp_model.id
RecordsetClient.as_user("default").wait_for_recordset(self.zone.id, recordset_id)
put_model = make_recordset(self.zone)
del put_model.name # don't try to update the name
resp, put_resp_model = RecordsetClient.as_user("default").put_recordset(self.zone.id, recordset_id, put_model)
self.assertEqual(resp.status, 202, "on put response")
self.assertEqual(put_resp_model.status, "PENDING")
self.assertEqual(put_resp_model.name, post_model.name)
self.assertEqual(put_resp_model.records, put_model.records)
self.assertEqual(put_resp_model.ttl, put_model.ttl)
RecordsetClient.as_user("default").wait_for_recordset(self.zone.id, recordset_id)
resp, delete_resp_model = RecordsetClient.as_user("default").delete_recordset(self.zone.id, recordset_id)
self.assertEqual(resp.status, 202, "on delete response")
RecordsetClient.as_user("default").wait_for_404(self.zone.id, recordset_id)
def test_crud_recordset(self, make_recordset):
post_model = make_recordset(self.zone)
resp, post_resp_model = RecordsetClient.as_user('default') \
.post_recordset(self.zone.id, post_model)
self.assertEqual(resp.status, 202, "on post response")
self.assertEqual(post_resp_model.status, "PENDING")
self.assertEqual(post_resp_model.name, post_model.name)
self.assertEqual(post_resp_model.records, post_model.records)
self.assertEqual(post_resp_model.ttl, post_model.ttl)
recordset_id = post_resp_model.id
RecordsetClient.as_user('default').wait_for_recordset(
self.zone.id, recordset_id)
put_model = make_recordset(self.zone)
del put_model.name # don't try to update the name
resp, put_resp_model = RecordsetClient.as_user('default') \
.put_recordset(self.zone.id, recordset_id, put_model)
self.assertEqual(resp.status, 202, "on put response")
self.assertEqual(put_resp_model.status, "PENDING")
self.assertEqual(put_resp_model.name, post_model.name)
self.assertEqual(put_resp_model.records, put_model.records)
self.assertEqual(put_resp_model.ttl, put_model.ttl)
RecordsetClient.as_user('default').wait_for_recordset(
self.zone.id, recordset_id)
resp, delete_resp_model = RecordsetClient.as_user('default') \
.delete_recordset(self.zone.id, recordset_id)
self.assertEqual(resp.status, 202, "on delete response")
RecordsetClient.as_user('default').wait_for_404(
self.zone.id, recordset_id)
def test_no_create_recordset_via_alt_domain(self):
zone = self.useFixture(ZoneFixture(user='******')).created_zone
alt_zone = self.useFixture(ZoneFixture(user='******')).created_zone
# alt attempts to create record with name A12345.{zone}
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(zone.id, recordset))
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(alt_zone.id, recordset))
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_no_create_recordset_via_alt_domain(self):
zone = self.useFixture(ZoneFixture(user='******')).created_zone
alt_zone = self.useFixture(ZoneFixture(user='******')).created_zone
# alt attempts to create record with name A12345.{zone}
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(zone.id, recordset))
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(alt_zone.id, recordset))
def test_get_single_recordset(self):
post_model = datagen.random_a_recordset(self.zone.name)
_, resp_model = RecordsetClient.as_user('default').post_recordset(
self.zone.id, post_model)
rrset_id = resp_model.id
resp, model = RecordsetClient.as_user('default').get_recordset(
self.zone.id, rrset_id, cross_zone=True)
self.assertEqual(200, resp.status)
# clean up
RecordsetClient.as_user('default').delete_recordset(self.zone.id,
rrset_id)
def test_no_create_recordset_by_alt_tenant(self):
zone = self.useFixture(ZoneFixture(user='******')).created_zone
# try with name=A123456.zone.com.
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(zone.id, recordset))
# try with name=zone.com.
recordset.name = zone.name
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(zone.id, recordset))
def test_no_create_recordset_by_alt_tenant(self):
zone = self.useFixture(ZoneFixture(user='******')).created_zone
# try with name=A123456.zone.com.
recordset = datagen.random_a_recordset(zone_name=zone.name)
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(zone.id, recordset))
# try with name=zone.com.
recordset.name = zone.name
self.assertRaises(exceptions.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 _create_recordset(self):
client = RecordsetClient.as_user(self.user)
self.post_resp, self.created_recordset = client.post_recordset(
self.zone_id, self.post_model)
assert self.post_resp.status == 202
self.addCleanup(self.cleanup_recordset, client, self.zone_id,
self.created_recordset.id)
assert self.created_recordset.status == "PENDING"
assert self.created_recordset.name == self.post_model.name
assert self.created_recordset.ttl == self.post_model.ttl
assert self.created_recordset.records == self.post_model.records
RecordsetClient.as_user('default').wait_for_recordset(
self.zone_id, self.created_recordset.id)
def _create_recordset(self):
client = RecordsetClient.as_user(self.user)
self.post_resp, self.created_recordset = client.post_recordset(
self.zone_id, self.post_model)
assert self.post_resp.status == 202
self.addCleanup(self.cleanup_recordset, client, self.zone_id,
self.created_recordset.id)
assert self.created_recordset.status == "PENDING"
assert self.created_recordset.name == self.post_model.name
assert self.created_recordset.ttl == self.post_model.ttl
assert self.created_recordset.records == self.post_model.records
RecordsetClient.as_user('default').wait_for_recordset(
self.zone_id, self.created_recordset.id)
def test_delete_existing_recordset(self):
post_model = datagen.random_a_recordset(self.zone.name)
resp, resp_model = RecordsetClient.as_user('default') \
.post_recordset(self.zone.id, post_model)
self.assertRaises(
exceptions.Unauthorized, self.client.delete_recordset,
self.zone.id, resp_model.id)
def test_export_domain(self):
user = '******'
zone_fixture = self.useFixture(ZoneFixture(user=user))
zone = zone_fixture.created_zone
export_fixture = self.useFixture(ZoneExportFixture(zone.id, user=user))
export_id = export_fixture.zone_export.id
export_client = ZoneExportClient.as_user(user)
resp, model = export_client.get_zone_export(export_id)
self.assertEqual(200, resp.status)
self.assertEqual('COMPLETE', model.status)
# fetch the zone file
resp, zone_file = export_client.get_exported_zone(export_id)
self.assertEqual(200, resp.status)
self.assertEqual(zone.name, zone_file.origin)
self.assertEqual(zone.ttl, zone_file.ttl)
# the list of records in the zone file must match the zone's recordsets
# (in this case there should be only two records - a SOA and an NS?)
recordset_client = RecordsetClient.as_user(user)
resp, model = recordset_client.list_recordsets(zone.id)
records = []
for recordset in model.recordsets:
records.extend(ZoneFileRecord.records_from_recordset(recordset))
self.assertEqual(set(records), set(zone_file.records))
export_client.delete_zone_export(export_id)
self.assertRaises(NotFound,
lambda: export_client.get_zone_export(export_id))
def test_delete_existing_recordset(self):
post_model = datagen.random_a_recordset(self.zone.name)
resp, resp_model = RecordsetClient.as_user('default') \
.post_recordset(self.zone.id, post_model)
self.assertRaises(exceptions.Unauthorized,
self.client.delete_recordset, self.zone.id,
resp_model.id)
def test_list_recordsets(self):
post_model = datagen.random_a_recordset(self.zone.name)
self.useFixture(RecordsetFixture(self.zone.id, post_model))
resp, model = RecordsetClient.as_user('default') \
.list_recordsets(self.zone.id)
self.assertEqual(200, resp.status)
self.assertGreater(len(model.recordsets), 0)
def test_export_domain(self):
user = '******'
zone_fixture = self.useFixture(ZoneFixture(user=user))
zone = zone_fixture.created_zone
export_fixture = self.useFixture(ZoneExportFixture(zone.id, user=user))
export_id = export_fixture.zone_export.id
export_client = ZoneExportClient.as_user(user)
resp, model = export_client.get_zone_export(export_id)
self.assertEqual(200, resp.status)
self.assertEqual('COMPLETE', model.status)
# fetch the zone file
resp, zone_file = export_client.get_exported_zone(export_id)
self.assertEqual(200, resp.status)
self.assertEqual(zone.name, zone_file.origin)
self.assertEqual(zone.ttl, zone_file.ttl)
# the list of records in the zone file must match the zone's recordsets
# (in this case there should be only two records - a SOA and an NS?)
recordset_client = RecordsetClient.as_user(user)
resp, model = recordset_client.list_recordsets(zone.id)
records = []
for recordset in model.recordsets:
records.extend(ZoneFileRecord.records_from_recordset(recordset))
self.assertEqual(set(records), set(zone_file.records))
export_client.delete_zone_export(export_id)
self.assertRaises(NotFound,
lambda: export_client.get_zone_export(export_id))
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_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_list_recordsets(self):
post_model = datagen.random_a_recordset(self.zone.name)
self.useFixture(RecordsetFixture(self.zone.id, post_model))
resp, model = RecordsetClient.as_user('default') \
.list_recordsets(self.zone.id)
self.assertEqual(200, resp.status)
self.assertGreater(len(model.recordsets), 0)
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 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_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_cname_recordsets_cannot_have_more_than_one_record(self):
post_model = datagen.random_cname_recordset(zone_name=self.zone.name)
post_model.records = [
"a.{0}".format(self.zone.name),
"b.{0}".format(self.zone.name),
]
client = RecordsetClient.as_user('default')
self.assertRaises(exceptions.BadRequest, client.post_recordset,
self.zone.id, post_model)
def test_cname_recordsets_cannot_have_more_than_one_record(self):
post_model = datagen.random_cname_recordset(zone_name=self.zone.name)
post_model.records = [
"a.{0}".format(self.zone.name),
"b.{0}".format(self.zone.name),
]
client = RecordsetClient.as_user('default')
self.assertRaises(exceptions.BadRequest,
client.post_recordset, self.zone.id, post_model)
def test_create_invalid(self, make_recordset, data=None):
data = data or ["b0rk"]
client = RecordsetClient.as_user('default')
for i in data:
model = make_recordset(self.zone)
model.data = i
self._assert_exception(
exceptions.BadRequest, 'invalid_object', 400,
client.post_recordset, self.zone.id, model)
def test_create_invalid(self, make_recordset, data=None):
data = data or ["b0rk"]
client = RecordsetClient.as_user('default')
for i in data:
model = make_recordset(self.zone)
model.data = i
self._assert_exception(exceptions.BadRequest, 'invalid_object',
400, client.post_recordset, self.zone.id,
model)
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
fixture = self.useFixture(ZoneFixture(zone_data, user='******'))
self.assertRaises(exceptions.RestClientException,
lambda: RecordsetClient.as_user('alt')
.post_recordset(fixture.created_zone.id, recordset))
def test_crud_recordset(self, make_recordset):
post_model = make_recordset(self.zone)
fixture = self.useFixture(RecordsetFixture(self.zone.id, post_model))
recordset_id = fixture.created_recordset.id
self.assert_dns(fixture.post_model)
put_model = make_recordset(self.zone)
del put_model.name # don't try to update the name
resp, put_resp_model = RecordsetClient.as_user('default') \
.put_recordset(self.zone.id, recordset_id, put_model)
self.assertEqual(202, resp.status, "on put response")
self.assertEqual("PENDING", put_resp_model.status)
self.assertEqual(post_model.name, put_resp_model.name)
self.assertEqual(put_model.records, put_resp_model.records)
self.assertEqual(put_model.ttl, put_resp_model.ttl)
RecordsetClient.as_user('default').wait_for_recordset(
self.zone.id, recordset_id)
put_model.name = post_model.name
self.assert_dns(put_model)
resp, delete_resp_model = RecordsetClient.as_user('default') \
.delete_recordset(self.zone.id, recordset_id)
self.assertEqual(202, resp.status, "on delete response")
RecordsetClient.as_user('default').wait_for_404(
self.zone.id, recordset_id)
def test_crud_recordset(self, make_recordset):
post_model = make_recordset(self.zone)
fixture = self.useFixture(RecordsetFixture(self.zone.id, post_model))
recordset_id = fixture.created_recordset.id
self.assert_dns(fixture.post_model)
put_model = make_recordset(self.zone)
del put_model.name # don't try to update the name
resp, put_resp_model = RecordsetClient.as_user('default') \
.put_recordset(self.zone.id, recordset_id, put_model)
self.assertEqual(202, resp.status, "on put response")
self.assertEqual("PENDING", put_resp_model.status)
self.assertEqual(post_model.name, put_resp_model.name)
self.assertEqual(put_model.records, put_resp_model.records)
self.assertEqual(put_model.ttl, put_resp_model.ttl)
RecordsetClient.as_user('default').wait_for_recordset(
self.zone.id, recordset_id)
put_model.name = post_model.name
self.assert_dns(put_model)
resp, delete_resp_model = RecordsetClient.as_user('default') \
.delete_recordset(self.zone.id, recordset_id)
self.assertEqual(202, resp.status, "on delete response")
RecordsetClient.as_user('default').wait_for_404(
self.zone.id, recordset_id)
def test_list_recordsets(self):
post_model = datagen.random_a_recordset(self.zone.name)
self.useFixture(RecordsetFixture(self.zone.id, post_model))
post_model = datagen.random_a_recordset(self.alt_zone.name)
self.useFixture(RecordsetFixture(self.alt_zone.id, post_model))
resp, model = RecordsetClient.as_user('default').list_recordsets(
'zone_id', cross_zone=True)
self.assertEqual(200, resp.status)
zone_names = set()
for r in model.recordsets:
zone_names.add(r.zone_name)
self.assertGreaterEqual(len(zone_names), 2)
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_update_invalid(self, make_recordset, data=None):
data = data or ["b0rk"]
post_model = make_recordset(self.zone)
fixture = self.useFixture(RecordsetFixture(self.zone.id, post_model))
recordset_id = fixture.created_recordset.id
client = RecordsetClient.as_user('default')
for i in data:
model = make_recordset(self.zone)
model.data = i
self._assert_exception(
exceptions.BadRequest, 'invalid_object', 400,
client.put_recordset, self.zone.id, recordset_id, model)
def test_update_invalid(self, make_recordset, data=None):
data = data or ["b0rk"]
post_model = make_recordset(self.zone)
fixture = self.useFixture(RecordsetFixture(self.zone.id, post_model))
recordset_id = fixture.created_recordset.id
client = RecordsetClient.as_user('default')
for i in data:
model = make_recordset(self.zone)
model.data = i
self._assert_exception(exceptions.BadRequest, 'invalid_object',
400, client.put_recordset, self.zone.id,
recordset_id, model)
def test_update_invalid(self, make_recordset, data=None):
data = data or ["b0rk"]
post_model = make_recordset(self.zone)
client = RecordsetClient.as_user('default')
resp, post_resp_model = client.post_recordset(self.zone.id, post_model)
recordset_id = post_resp_model.id
client.wait_for_recordset(self.zone.id, recordset_id)
for i in data:
model = make_recordset(self.zone)
model.data = i
self._assert_exception(exceptions.BadRequest, 'invalid_object',
400, client.put_recordset, self.zone.id,
recordset_id, model)
def test_list_recordsets_with_filtering(self):
# This test ensures the behavior in bug #1561746 won't happen
post_model = datagen.random_a_recordset(self.zone.name,
ip='192.168.1.2')
self.useFixture(RecordsetFixture(self.zone.id, post_model))
for i in range(1, 3):
post_model = datagen.random_a_recordset(self.zone.name,
ip='10.0.1.{}'.format(i))
self.useFixture(RecordsetFixture(self.zone.id, post_model))
# Add limit in filter to make response paginated
filters = {"data": "10.*", "limit": 2}
resp, model = RecordsetClient.as_user('default') \
.list_recordsets(self.zone.id, filters=filters)
self.assertEqual(200, resp.status)
self.assertEqual(2, model.metadata.total_count)
self.assertEqual(len(model.recordsets), 2)
self.assertIsNotNone(model.links.next)
def test_can_create_and_query_wildcard_recordset(self, make_recordset):
client = RecordsetClient.as_user('default')
post_model = make_recordset(self.zone)
resp, post_resp_model = client.post_recordset(self.zone.id, post_model)
self.assertEqual(resp.status, 202)
recordset_id = post_resp_model.id
client.wait_for_recordset(self.zone.id, recordset_id)
verify_models = [
post_model.from_dict(post_model.to_dict()) for x in range(3)
]
verify_models[0].name = "abc.{0}".format(self.zone.name)
verify_models[1].name = "abc.def.{0}".format(self.zone.name)
verify_models[2].name = "abc.def.hij.{0}".format(self.zone.name)
for m in verify_models:
self.assert_dns(m)
def test_update_invalid(self, make_recordset, data=None):
data = data or ["b0rk"]
post_model = make_recordset(self.zone)
client = RecordsetClient.as_user('default')
resp, post_resp_model = client.post_recordset(
self.zone.id, post_model)
recordset_id = post_resp_model.id
client.wait_for_recordset(
self.zone.id, recordset_id)
for i in data:
model = make_recordset(self.zone)
model.data = i
self._assert_exception(
exceptions.BadRequest, 'invalid_object', 400,
client.put_recordset, self.zone.id, recordset_id, model)
def test_filter_recordsets(self):
# create one A recordset in 'zone'
post_model = datagen.random_a_recordset(self.zone.name,
ip='123.201.99.1')
self.useFixture(RecordsetFixture(self.zone.id, post_model))
# create two A recordsets in 'alt_zone'
post_model = datagen.random_a_recordset(self.alt_zone.name,
ip='10.0.1.1')
self.useFixture(RecordsetFixture(self.alt_zone.id, post_model))
post_model = datagen.random_a_recordset(self.alt_zone.name,
ip='123.201.99.2')
self.useFixture(RecordsetFixture(self.alt_zone.id, post_model))
# Add limit in filter to make response paginated
filters = {"data": "123.201.99.*", "limit": 2}
resp, model = RecordsetClient.as_user('default') \
.list_recordsets('zone_id', cross_zone=True, filters=filters)
self.assertEqual(200, resp.status)
self.assertEqual(2, model.metadata.total_count)
self.assertEqual(len(model.recordsets), 2)
self.assertIsNotNone(model.links.next)
def setUp(self):
super(RecordsetValidationTest, self).setUp()
self.increase_quotas(user='******')
self.ensure_tld_exists('com')
self.zone = self.useFixture(ZoneFixture()).created_zone
self.client = RecordsetClient.as_user('default')
def test_list_recordsets(self):
resp, model = RecordsetClient.as_user('default') \
.list_recordsets(self.zone.id)
self.assertEqual(resp.status, 200)
def test_list_recordsets(self):
resp, model = RecordsetClient.as_user('default') \
.list_recordsets(self.zone.id)
self.assertEqual(resp.status, 200)
def setUp(self):
super(RecordsetValidationTest, self).setUp()
self.increase_quotas(user='******')
self.ensure_tld_exists('com')
self.zone = self.useFixture(ZoneFixture()).created_zone
self.client = RecordsetClient.as_user('default')
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)
