def test_crud_bucket_object(self): test_bucket = None def create_bucket_obj(name): obj = test_bucket.objects.create(name) # TODO: This is wrong. We shouldn't have to have a separate # call to upload some content before being able to delete # the content. Maybe the create_object method should accept # the file content as a parameter. obj.upload("dummy content") return obj def cleanup_bucket_obj(bucket_obj): if bucket_obj: bucket_obj.delete() with cb_helpers.cleanup_action(lambda: test_bucket.delete()): name = "cb-crudbucketobj-{0}".format(helpers.get_uuid()) test_bucket = self.provider.storage.buckets.create(name) sit.check_crud(self, test_bucket.objects, BucketObject, "cb-bucketobj", create_bucket_obj, cleanup_bucket_obj, skip_name_check=True)
def test_crud_subnet(self): # Late binding will make sure that create_subnet gets the # correct value net = self.provider.networking.networks.create( label="cb-crudsubnet", cidr_block=BaseNetwork.CB_DEFAULT_IPV4RANGE) def create_subnet(label): return self.provider.networking.subnets.create( label=label, network=net, cidr_block="10.0.10.0/24") def cleanup_subnet(subnet): if subnet: net = subnet.network subnet.delete() subnet.wait_for([SubnetState.UNKNOWN], terminal_states=[SubnetState.ERROR]) self.assertTrue( subnet.state == SubnetState.UNKNOWN, "Subnet.state must be unknown after " "a delete but got %s" % subnet.state) net.delete() net.wait_for([NetworkState.UNKNOWN], terminal_states=[NetworkState.ERROR]) self.assertTrue( net.state == NetworkState.UNKNOWN, "Network.state must be unknown after " "a delete but got %s" % net.state) sit.check_crud(self, self.provider.networking.subnets, Subnet, "cb-crudsubnet", create_subnet, cleanup_subnet)
def test_crud_dns_record(self): test_zone = None zone_name = "cb-dnsrec-{0}.com.".format(helpers.get_uuid()) def create_dns_rec(name): if name: name = name + "." + zone_name else: name = zone_name return test_zone.records.create(name, DnsRecordType.A, data='10.1.1.1') def cleanup_dns_rec(dns_rec): if dns_rec: dns_rec.delete() with cb_helpers.cleanup_action(lambda: test_zone.delete()): test_zone = self.provider.dns.host_zones.create( zone_name, "*****@*****.**") sit.check_crud(self, test_zone.records, DnsRecord, "cb-dnsrec", create_dns_rec, cleanup_dns_rec, skip_name_check=True)
def test_crud_vm_firewall_rules(self): label = 'cb-crudfw-rules-{0}'.format(helpers.get_uuid()) subnet = helpers.get_or_create_default_subnet(self.provider) net = subnet.network fw = None with cb_helpers.cleanup_action(lambda: fw.delete()): fw = self.provider.security.vm_firewalls.create(label=label, description=label, network=net.id) def create_fw_rule(label): return fw.rules.create(direction=TrafficDirection.INBOUND, protocol='tcp', from_port=1111, to_port=1111, cidr='0.0.0.0/0') def cleanup_fw_rule(rule): if rule: rule.delete() sit.check_crud(self, fw.rules, VMFirewallRule, "cb-crudfwrule", create_fw_rule, cleanup_fw_rule, skip_name_check=True)
def test_crud_network(self): def create_net(label): return self.provider.networking.networks.create( label=label, cidr_block=BaseNetwork.CB_DEFAULT_IPV4RANGE) def cleanup_net(net): if net: net.delete() net.wait_for([NetworkState.UNKNOWN], terminal_states=[NetworkState.ERROR]) self.assertTrue( net.state == NetworkState.UNKNOWN, "Network.state must be unknown after " "a delete but got %s" % net.state) sit.check_crud(self, self.provider.networking.networks, Network, "cb-crudnetwork", create_net, cleanup_net)
def test_crud_volume(self): def create_vol(label): return self.provider.storage.volumes.create(label, 1) def cleanup_vol(vol): if vol: vol.delete() vol.wait_for([VolumeState.DELETED, VolumeState.UNKNOWN], terminal_states=[VolumeState.ERROR]) vol.refresh() self.assertTrue( vol.state == VolumeState.UNKNOWN, "Volume.state must be unknown when refreshing after a " "delete but got %s" % vol.state) sit.check_crud(self, self.provider.storage.volumes, Volume, "cb-createvol", create_vol, cleanup_vol)
def test_crud_dns_zones(self): def create_dns_zone(name): if name: name = name + ".com." return self.provider.dns.host_zones.create( name, "*****@*****.**") def cleanup_dns_zone(dns_zone): if dns_zone: dns_zone.delete() def test_zone_props(dns_zone): self.assertEqual(dns_zone.admin_email, "*****@*****.**") sit.check_crud(self, self.provider.dns.host_zones, DnsZone, "cb-crudzone", create_dns_zone, cleanup_dns_zone, skip_name_check=True, extra_test_func=test_zone_props)
def test_crud_floating_ip(self): gw = helpers.get_test_gateway(self.provider) def create_fip(label): fip = gw.floating_ips.create() return fip def cleanup_fip(fip): if fip: gw.floating_ips.delete(fip.id) with cb_helpers.cleanup_action(lambda: helpers.cleanup_gateway(gw)): sit.check_crud(self, gw.floating_ips, FloatingIP, "cb-crudfip", create_fip, cleanup_fip, skip_name_check=True)
def test_crud_bucket(self): def create_bucket(name): return self.provider.storage.buckets.create(name) def cleanup_bucket(bucket): if bucket: bucket.delete() def extra_tests(bucket): # Recreating existing bucket should raise an exception with self.assertRaises(DuplicateResourceException): self.provider.storage.buckets.create(name=bucket.name) sit.check_crud(self, self.provider.storage.buckets, Bucket, "cb-crudbucket", create_bucket, cleanup_bucket, extra_test_func=extra_tests)
def test_crud_key_pair_service(self): def create_kp(name): return self.provider.security.key_pairs.create(name=name) def cleanup_kp(kp): if kp: self.provider.security.key_pairs.delete(kp.id) def extra_tests(kp): # Recreating existing keypair should raise an exception with self.assertRaises(DuplicateResourceException): self.provider.security.key_pairs.create(name=kp.name) sit.check_crud(self, self.provider.security.key_pairs, KeyPair, "cb-crudkp", create_kp, cleanup_kp, extra_test_func=extra_tests)
def test_crud_instance(self): label = "cb-instcrud-{0}".format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values subnet = None def create_inst(label): # Also test whether sending in an empty_dict for user_data # results in an automatic conversion to string. return helpers.get_test_instance(self.provider, label, subnet=subnet, user_data={}) def cleanup_inst(inst): if inst: inst.delete() inst.wait_for([InstanceState.DELETED, InstanceState.UNKNOWN]) inst.refresh() self.assertTrue( inst.state == InstanceState.UNKNOWN, "Instance.state must be unknown when refreshing after a " "delete but got %s" % inst.state) def check_deleted(inst): deleted_inst = self.provider.compute.instances.get(inst.id) self.assertTrue( deleted_inst is None or deleted_inst.state in (InstanceState.DELETED, InstanceState.UNKNOWN), "Instance %s should have been deleted but still exists." % label) subnet = helpers.get_or_create_default_subnet(self.provider) sit.check_crud(self, self.provider.compute.instances, Instance, "cb-instcrud", create_inst, cleanup_inst, custom_check_delete=check_deleted)
def test_crud_vm_firewall(self): subnet = helpers.get_or_create_default_subnet(self.provider) net = subnet.network def create_fw(label): return self.provider.security.vm_firewalls.create( label=label, description=label, network=net.id) def cleanup_fw(fw): if fw: fw.delete() def network_id_test(fw): # Checking that the network ID is returned correctly self.assertEqual(fw.network_id, net.id) sit.check_crud(self, self.provider.security.vm_firewalls, VMFirewall, "cb-crudfw", create_fw, cleanup_fw, extra_test_func=network_id_test)
def test_crud_snapshot(self): # Create a new volume, create a snapshot of the volume, and check # whether list_snapshots properly detects the new snapshot. # Delete everything afterwards. label = "cb-crudsnap-{0}".format(helpers.get_uuid()) test_vol = self.provider.storage.volumes.create(label, 1) with cb_helpers.cleanup_action(lambda: test_vol.delete()): test_vol.wait_till_ready() def create_snap(label): return test_vol.create_snapshot(label=label, description=label) def cleanup_snap(snap): if snap: snap.delete() snap.wait_for([SnapshotState.UNKNOWN], terminal_states=[SnapshotState.ERROR]) snap.refresh() self.assertTrue( snap.state == SnapshotState.UNKNOWN, "Snapshot.state must be unknown when refreshing after " "a delete but got %s" % snap.state) sit.check_crud(self, self.provider.storage.snapshots, Snapshot, "cb-snap", create_snap, cleanup_snap) # Test creation of a snap via SnapshotService def create_snap2(label): return self.provider.storage.snapshots.create( label=label, volume=test_vol, description=label) if (self.provider.PROVIDER_ID == ProviderList.AWS and not isinstance(self.provider, TestMockHelperMixin)): time.sleep(15) # Or get SnapshotCreationPerVolumeRateExceeded sit.check_crud(self, self.provider.storage.snapshots, Snapshot, "cb-snaptwo", create_snap2, cleanup_snap)
def test_create_and_list_image(self): instance_label = "cb-crudimage-{0}".format(helpers.get_uuid()) img_inst_label = "cb-crudimage-{0}".format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values test_instance = None subnet = None def create_img(label): return test_instance.create_image(label=label) def cleanup_img(img): if img: img.delete() img.wait_for( [MachineImageState.UNKNOWN, MachineImageState.ERROR]) img.refresh() self.assertTrue( img.state == MachineImageState.UNKNOWN, "MachineImage.state must be unknown when refreshing after " "a delete but got %s" % img.state) def extra_tests(img): # check image size img.refresh() self.assertGreater( img.min_disk, 0, "Minimum disk" " size required by image is invalid") create_instance_from_image(img) def create_instance_from_image(img): img_instance = None with cb_helpers.cleanup_action( lambda: helpers.cleanup_test_resources(img_instance)): img_instance = self.provider.compute.instances.create( img_inst_label, img, helpers.get_provider_test_data(self.provider, 'vm_type'), subnet=subnet) img_instance.wait_till_ready() self.assertIsInstance(img_instance, Instance) self.assertEqual( img_instance.label, img_inst_label, "Instance label {0} is not equal to the expected label" " {1}".format(img_instance.label, img_inst_label)) image_id = img.id self.assertEqual( img_instance.image_id, image_id, "Image id {0} is not equal to the expected id" " {1}".format(img_instance.image_id, image_id)) self.assertIsInstance(img_instance.public_ips, list) if img_instance.public_ips: self.assertTrue( img_instance.public_ips[0], "public ip should contain a" " valid value if a list of public_ips exist") self.assertIsInstance(img_instance.private_ips, list) self.assertTrue(img_instance.private_ips[0], "private ip should" " contain a valid value") with cb_helpers.cleanup_action( lambda: helpers.cleanup_test_resources(test_instance)): subnet = helpers.get_or_create_default_subnet(self.provider) test_instance = helpers.get_test_instance(self.provider, instance_label, subnet=subnet) sit.check_crud(self, self.provider.compute.images, MachineImage, "cb-listimg", create_img, cleanup_img, extra_test_func=extra_tests)