def test_cannot_create_MX_with(self, pref):
post_model = datagen.random_mx_recordset(self.zone.name, pref=pref)
self._assert_exception(
exceptions.BadRequest,
'invalid_object',
400,
self.client.post_recordset,
self.zone.id,
post_model,
)
class RecordsetTest(DesignateV2Test):
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_list_recordsets(self):
resp, model = RecordsetClient.as_user('default') \
.list_recordsets(self.zone.id)
self.assertEqual(resp.status, 200)
@utils.parameterized({
'A':
dict(make_recordset=lambda z: datagen.random_a_recordset(z.name)),
'AAAA':
dict(make_recordset=lambda z: datagen.random_aaaa_recordset(z.name)),
'CNAME':
dict(make_recordset=lambda z: datagen.random_cname_recordset(z.name)),
'MX':
dict(make_recordset=lambda z: datagen.random_mx_recordset(z.name)),
})
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)
from functionaltests.common import dnsclient
from functionaltests.common import utils
from functionaltests.api.v2.base import DesignateV2Test
from functionaltests.api.v2.clients.recordset_client import RecordsetClient
from functionaltests.api.v2.clients.zone_client import ZoneClient
RECORDSETS_DATASET = {
'A': dict(
make_recordset=lambda z: datagen.random_a_recordset(z.name)),
'AAAA': dict(
make_recordset=lambda z: datagen.random_aaaa_recordset(z.name)),
'CNAME': dict(
make_recordset=lambda z: datagen.random_cname_recordset(z.name)),
'MX': dict(
make_recordset=lambda z: datagen.random_mx_recordset(z.name)),
'SPF': dict(
make_recordset=lambda z: datagen.random_spf_recordset(z.name)),
'SRV': dict(
make_recordset=lambda z: datagen.random_srv_recordset(z.name)),
'SSHFP': dict(
make_recordset=lambda z: datagen.random_sshfp_recordset(z.name)),
'TXT': dict(
make_recordset=lambda z: datagen.random_txt_recordset(z.name)),
}
WILDCARD_RECORDSETS_DATASET = {
'A': dict(make_recordset=lambda z:
datagen.random_a_recordset(zone_name=z.name,
name="*.{0}".format(z.name))),
'AAAA': dict(make_recordset=lambda z:
from tempest_lib import exceptions
from functionaltests.common import datagen
from functionaltests.common import dnsclient
from functionaltests.common import utils
from functionaltests.api.v2.base import DesignateV2Test
from functionaltests.api.v2.clients.recordset_client import RecordsetClient
from functionaltests.api.v2.clients.zone_client import ZoneClient
RECORDSETS_DATASET = {
'A': dict(make_recordset=lambda z: datagen.random_a_recordset(z.name)),
'AAAA':
dict(make_recordset=lambda z: datagen.random_aaaa_recordset(z.name)),
'CNAME':
dict(make_recordset=lambda z: datagen.random_cname_recordset(z.name)),
'MX': dict(make_recordset=lambda z: datagen.random_mx_recordset(z.name)),
'SPF': dict(make_recordset=lambda z: datagen.random_spf_recordset(z.name)),
'SRV': dict(make_recordset=lambda z: datagen.random_srv_recordset(z.name)),
'SSHFP':
dict(make_recordset=lambda z: datagen.random_sshfp_recordset(z.name)),
'TXT': dict(make_recordset=lambda z: datagen.random_txt_recordset(z.name)),
}
WILDCARD_RECORDSETS_DATASET = {
'wildcard_A':
dict(make_recordset=lambda z: datagen.random_a_recordset(
zone_name=z.name, name="*.{0}".format(z.name))),
'wildcard_AAAA':
dict(make_recordset=lambda z: datagen.random_aaaa_recordset(
zone_name=z.name, name="*.{0}".format(z.name))),
'wildcard_CNAME':
def test_cannot_create_MX_with(self, pref):
post_model = datagen.random_mx_recordset(self.zone.name, pref=pref)
self._assert_exception(
exceptions.BadRequest, 'invalid_object', 400,
self.client.post_recordset, self.zone.id, post_model,
)
class RecordsetTest(DesignateV2Test):
def setUp(self):
super(RecordsetTest, self).setUp()
self.increase_quotas()
resp, self.zone = self.zone_client.post_zone(
datagen.random_zone_data())
self.wait_for_zone(self.zone.id)
def wait_for_recordset(self, zone_id, recordset_id):
self.wait_for_condition(
lambda: self.is_recordset_active(zone_id, recordset_id))
def wait_for_404(self, zone_id, recordset_id):
self.wait_for_condition(
lambda: self.is_recordset_404(zone_id, recordset_id))
def is_recordset_active(self, zone_id, recordset_id):
resp, model = self.recordset_client.get_recordset(
zone_id, recordset_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_recordset_404(self, zone_id, recordset_id):
try:
self.recordset_client.get_recordset(zone_id, recordset_id)
except NotFound:
return True
return False
def test_list_recordsets(self):
resp, model = self.recordset_client.list_recordsets(self.zone.id)
self.assertEqual(resp.status, 200)
@utils.parameterized({
'A':
dict(make_recordset=lambda z: datagen.random_a_recordset(z.name)),
'AAAA':
dict(make_recordset=lambda z: datagen.random_aaaa_recordset(z.name)),
'CNAME':
dict(make_recordset=lambda z: datagen.random_cname_recordset(z.name)),
'MX':
dict(make_recordset=lambda z: datagen.random_mx_recordset(z.name)),
})
def test_crud_recordset(self, make_recordset):
post_model = make_recordset(self.zone)
resp, post_resp_model = self.recordset_client.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
self.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 = self.recordset_client.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)
self.wait_for_recordset(self.zone.id, recordset_id)
resp, delete_resp_model = self.recordset_client.delete_recordset(
self.zone.id, recordset_id)
self.assertEqual(resp.status, 202, "on delete response")
self.wait_for_404(self.zone.id, recordset_id)
