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_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_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_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_fuzzed_record(self, parameter, fuzz_type, payload):
"""Create A RRSet, fuzzing each param"""
model = datagen.random_a_recordset(self.zone.name)
model.__dict__[parameter] = payload
result = fuzzer.verify_tempest_exception(
self.client.post_recordset, fuzz_type, self.zone.id, model
)
self.assertTrue(result['status'])
if result['exception']:
self.assertIsInstance(result['exception'], exceptions.BadRequest)
def test_get_records_fuzzed(self, parameter, fuzz_type, payload):
"""Get RRSet list, fuzzing each filter param"""
model = datagen.random_a_recordset(self.zone.name)
resp, post_resp_model = self.client.post_recordset(self.zone.id, model)
result = fuzzer.verify_tempest_exception(
self.client.list_recordsets, fuzz_type, self.zone.id,
filters={parameter: payload}
)
self.assertTrue(result['status'])
if result['exception']:
self.assertIsInstance(result['exception'], exceptions.BadRequest)
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_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_fuzzed_header(self, parameter, fuzz_type, payload):
"""Create A RRSet, fuzzing Accept & Content-Type headers"""
model = datagen.random_a_recordset(self.zone.name)
headers = {
'content-type': 'application/json',
'accept': ''
}
headers[parameter] = payload.encode('utf-8')
result = fuzzer.verify_tempest_exception(
self.client.post_recordset, fuzz_type, self.zone.id, model,
headers=headers)
self.assertTrue(result['status'])
self.assertNotIn(result['resp'].status, range(500, 600))
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 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):
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):
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_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_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))
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)
limitations under the License.
"""
import dns.rdatatype
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)),
}
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import dns.rdatatype
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(
def test_create_a_recordset(self):
post_model = datagen.random_a_recordset(self.zone.name)
self.assertRaises(
exceptions.Unauthorized, self.client.post_recordset, self.zone.id,
post_model)
def test_update_fake_recordset(self):
put_model = datagen.random_a_recordset(self.zone.name)
self.assertRaises(
exceptions.Unauthorized, self.client.put_recordset, self.zone.id,
'junk', put_model)
def test_create_a_recordset(self):
post_model = datagen.random_a_recordset(self.zone.name)
self.assertRaises(exceptions.Unauthorized, self.client.post_recordset,
self.zone.id, post_model)
def test_update_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.put_recordset,
self.zone.id, resp_model.id, post_model)
def test_update_fake_recordset(self):
put_model = datagen.random_a_recordset(self.zone.name)
self.assertRaises(exceptions.Unauthorized, self.client.put_recordset,
self.zone.id, 'junk', put_model)
