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)