def test_network_properties(self): label = 'cb-propnetwork-{0}'.format(helpers.get_uuid()) subnet_label = 'cb-propsubnet-{0}'.format(helpers.get_uuid()) net = self.provider.networking.networks.create( label=label, cidr_block=BaseNetwork.CB_DEFAULT_IPV4RANGE) with helpers.cleanup_action(lambda: net.delete()): net.wait_till_ready() self.assertEqual( net.state, 'available', "Network in state '%s', yet should be 'available'" % net.state) sit.check_repr(self, net) self.assertIn( net.cidr_block, ['', BaseNetwork.CB_DEFAULT_IPV4RANGE], "Network CIDR %s does not contain the expected value %s." % (net.cidr_block, BaseNetwork.CB_DEFAULT_IPV4RANGE)) cidr = '10.0.20.0/24' sn = net.create_subnet(label=subnet_label, cidr_block=cidr, zone=helpers.get_provider_test_data( self.provider, 'placement')) with helpers.cleanup_action(lambda: sn.delete()): self.assertTrue( sn in net.subnets, "Subnet ID %s should be listed in network subnets %s." % (sn.id, net.subnets)) self.assertTrue( sn in self.provider.networking.subnets.list(network=net), "Subnet ID %s should be included in the subnets list %s." % (sn.id, self.provider.networking.subnets.list(net))) self.assertListEqual( net.subnets, [sn], "Network should have exactly one subnet: %s." % sn.id) self.assertEqual( net.id, sn.network_id, "Network ID %s and subnet's network id %s should be" " equal." % (net.id, sn.network_id)) self.assertEqual( net, sn.network, "Network obj %s and subnet's parent net obj %s" " should be equal." % (net, sn.network)) self.assertEqual( cidr, sn.cidr_block, "Should be exact cidr block that was requested") self.assertTrue( BaseNetwork.cidr_blocks_overlap(cidr, sn.cidr_block), "Subnet's CIDR %s should overlap the specified one %s." % (sn.cidr_block, cidr))
def test_upload_download_bucket_content_with_large_file(self): """ Creates a 6 Gig file in the temp directory, then uploads it to Swift. Once uploaded, then downloads to a new file in the temp directory and compares the two files to see if they match. """ temp_dir = tempfile.gettempdir() file_name = '6GigTest.tmp' six_gig_file = os.path.join(temp_dir, file_name) with open(six_gig_file, "wb") as out: out.truncate(6 * 1024 * 1024 * 1024) # 6 Gig... with helpers.cleanup_action(lambda: os.remove(six_gig_file)): download_file = "{0}/cbtestfile-{1}".format(temp_dir, file_name) bucket_name = "cbtestbucketlargeobjs-{0}".format( helpers.get_uuid()) test_bucket = self.provider.storage.buckets.create(bucket_name) with helpers.cleanup_action(lambda: test_bucket.delete()): test_obj = test_bucket.objects.create(file_name) with helpers.cleanup_action(lambda: test_obj.delete()): file_uploaded = test_obj.upload_from_file(six_gig_file) self.assertTrue(file_uploaded, "Could not upload object?") with helpers.cleanup_action( lambda: os.remove(download_file)): with open(download_file, 'wb') as f: test_obj.save_content(f) self.assertTrue( filecmp.cmp(six_gig_file, download_file), "Uploaded file != downloaded")
def test_vm_firewall_rule_add_twice(self): name = 'cb_fwruletwice-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None fw = None with helpers.cleanup_action(lambda: helpers.cleanup_test_resources( network=net, vm_firewall=fw)): net, _ = helpers.create_test_network(self.provider, name) fw = self.provider.security.vm_firewalls.create(name=name, description=name, network_id=net.id) rule = fw.rules.create(direction=TrafficDirection.INBOUND, protocol='tcp', from_port=1111, to_port=1111, cidr='0.0.0.0/0') # attempting to add the same rule twice should succeed same_rule = fw.rules.create(direction=TrafficDirection.INBOUND, protocol='tcp', from_port=1111, to_port=1111, cidr='0.0.0.0/0') self.assertEqual(rule, same_rule)
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 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_instance(self): name = "cb_instcrud-{0}".format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None subnet = None def create_inst(name): return helpers.get_test_instance(self.provider, name, subnet=subnet) def cleanup_inst(inst): inst.terminate() inst.wait_for([InstanceState.TERMINATED, InstanceState.UNKNOWN]) 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.TERMINATED, InstanceState.UNKNOWN), "Instance %s should have been deleted but still exists." % name) with helpers.cleanup_action( lambda: helpers.cleanup_test_resources(network=net)): net, subnet = helpers.create_test_network(self.provider, name) sit.check_crud(self, self.provider.compute.instances, Instance, "cb_instcrud", create_inst, cleanup_inst, custom_check_delete=check_deleted)
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. """ name = "cb_crudsnap-{0}".format(helpers.get_uuid()) test_vol = self.provider.storage.volumes.create( name, 1, helpers.get_provider_test_data(self.provider, "placement")) with helpers.cleanup_action(lambda: test_vol.delete()): test_vol.wait_till_ready() def create_snap(name): return test_vol.create_snapshot(name=name, description=name) def cleanup_snap(snap): snap.delete() snap.wait_for([SnapshotState.UNKNOWN], terminal_states=[SnapshotState.ERROR]) 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(name): return self.provider.storage.snapshots.create(name=name, volume=test_vol, description=name) 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_attach_detach_volume(self): """ Create a new volume, and attempt to attach it to an instance """ name = "cb_attachvol-{0}".format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None test_instance = None with helpers.cleanup_action( lambda: helpers.cleanup_test_resources(test_instance, net)): net, subnet = helpers.create_test_network(self.provider, name) test_instance = helpers.get_test_instance(self.provider, name, subnet=subnet) test_vol = self.provider.storage.volumes.create( name, 1, test_instance.zone_id) with helpers.cleanup_action(lambda: test_vol.delete()): test_vol.wait_till_ready() test_vol.attach(test_instance, '/dev/sda2') test_vol.wait_for( [VolumeState.IN_USE], terminal_states=[VolumeState.ERROR, VolumeState.DELETED]) test_vol.detach() test_vol.wait_for( [VolumeState.AVAILABLE], terminal_states=[VolumeState.ERROR, VolumeState.DELETED])
def test_object_life_cycle(self): """ Test object life cycle methods by using a volume. """ name = "cb_objlifecycle-{0}".format(helpers.get_uuid()) test_vol = self.provider.storage.volumes.create( name, 1, helpers.get_provider_test_data(self.provider, "placement")) # Waiting for an invalid timeout should raise an exception with self.assertRaises(AssertionError): test_vol.wait_for([VolumeState.ERROR], timeout=-1, interval=1) with self.assertRaises(AssertionError): test_vol.wait_for([VolumeState.ERROR], timeout=1, interval=-1) # If interval < timeout, an exception should be raised with self.assertRaises(AssertionError): test_vol.wait_for([VolumeState.ERROR], timeout=10, interval=20) with helpers.cleanup_action(lambda: test_vol.delete()): test_vol.wait_till_ready() # Hitting a terminal state should raise an exception with self.assertRaises(WaitStateException): test_vol.wait_for([VolumeState.ERROR], terminal_states=[VolumeState.AVAILABLE]) # Hitting the timeout should raise an exception with self.assertRaises(WaitStateException): test_vol.wait_for([VolumeState.ERROR], timeout=0, interval=0)
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 helpers.cleanup_action(lambda: fw.delete()): fw = self.provider.security.vm_firewalls.create(label=label, description=label, network_id=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_vm_firewall_group_rule(self): label = 'cb-fwrule-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values fw = None with helpers.cleanup_action(lambda: helpers.cleanup_test_resources( vm_firewall=fw)): subnet = helpers.get_or_create_default_subnet(self.provider) net = subnet.network fw = self.provider.security.vm_firewalls.create( label=label, description=label, network=net.id) rule = fw.rules.create( direction=TrafficDirection.INBOUND, src_dest_fw=fw, protocol='tcp', from_port=1, to_port=65535) self.assertTrue( rule.src_dest_fw.label == fw.label, "Expected VM firewall rule label {0}. Got {1}." .format(fw.label, rule.src_dest_fw.label)) for r in fw.rules: r.delete() fw = self.provider.security.vm_firewalls.get(fw.id) # update self.assertTrue( len(list(fw.rules)) == 0, "Deleting VMFirewallRule should delete it: {0}".format( fw.rules)) fwl = self.provider.security.vm_firewalls.list() found_fw = [f for f in fwl if f.label == label] self.assertTrue( len(found_fw) == 0, "VM firewall {0} should have been deleted but still exists." .format(label))
def test_crud_vm_firewall_rules(self): name = 'cb_crudfw_rules-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None with helpers.cleanup_action( lambda: helpers.cleanup_test_resources(network=net)): net, _ = helpers.create_test_network(self.provider, name) fw = None with helpers.cleanup_action(lambda: fw.delete()): fw = self.provider.security.vm_firewalls.create( name=name, description=name, network_id=net.id) def create_fw_rule(name): 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): rule.delete() sit.check_crud(self, fw.rules, VMFirewallRule, "cb_crudfwrule", create_fw_rule, cleanup_fw_rule, skip_name_check=True)
def test_network_properties(self): name = 'cb_propnetwork-{0}'.format(helpers.get_uuid()) subnet_name = 'cb_propsubnet-{0}'.format(helpers.get_uuid()) net = self.provider.networking.networks.create( name=name, cidr_block='10.0.0.0/16') with helpers.cleanup_action(lambda: net.delete()): net.wait_till_ready() self.assertEqual( net.state, 'available', "Network in state '%s', yet should be 'available'" % net.state) sit.check_repr(self, net) self.assertIn( net.cidr_block, ['', '10.0.0.0/16'], "Network CIDR %s does not contain the expected value." % net.cidr_block) cidr = '10.0.1.0/24' sn = net.create_subnet(name=subnet_name, cidr_block=cidr, zone=helpers.get_provider_test_data( self.provider, 'placement')) with helpers.cleanup_action(lambda: sn.delete()): self.assertTrue( sn in net.subnets, "Subnet ID %s should be listed in network subnets %s." % (sn.id, net.subnets)) self.assertTrue( sn in self.provider.networking.subnets.list(network=net), "Subnet ID %s should be included in the subnets list %s." % (sn.id, self.provider.networking.subnets.list(net))) self.assertListEqual( net.subnets, [sn], "Network should have exactly one subnet: %s." % sn.id) self.assertIn( net.id, sn.network_id, "Network ID %s should be specified in the subnet's network" " id %s." % (net.id, sn.network_id)) self.assertEqual( cidr, sn.cidr_block, "Subnet's CIDR %s should match the specified one %s." % (sn.cidr_block, cidr))
def test_crud_bucket_object_properties(self): # Create a new bucket, upload some contents into the bucket, and # check whether list properly detects the new content. # Delete everything afterwards. name = "cbtestbucketobjs-{0}".format(helpers.get_uuid()) test_bucket = self.provider.storage.buckets.create(name) # ensure that the bucket is empty objects = test_bucket.objects.list() self.assertEqual([], objects) with cb_helpers.cleanup_action(lambda: test_bucket.delete()): obj_name_prefix = "hello" obj_name = obj_name_prefix + "_world.txt" obj = test_bucket.objects.create(obj_name) with cb_helpers.cleanup_action(lambda: obj.delete()): # 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") objs = test_bucket.objects.list() self.assertTrue( isinstance(objs[0].size, int), "Object size property needs to be a int, not {0}".format( type(objs[0].size))) # GET an object as the size property implementation differs # for objects returned by LIST and GET. obj = test_bucket.objects.get(objs[0].id) self.assertTrue( isinstance(objs[0].size, int), "Object size property needs to be an int, not {0}".format( type(obj.size))) self.assertTrue( datetime.strptime(objs[0].last_modified[:23], "%Y-%m-%dT%H:%M:%S.%f"), "Object's last_modified field format {0} not matching.". format(objs[0].last_modified)) # check iteration iter_objs = list(test_bucket.objects) self.assertListEqual(iter_objs, objs) obj_too = test_bucket.objects.get(obj_name) self.assertTrue( isinstance(obj_too, BucketObject), "Did not get object {0} of expected type.".format(obj_too)) prefix_filtered_list = test_bucket.objects.list( prefix=obj_name_prefix) self.assertTrue( len(objs) == len(prefix_filtered_list) == 1, 'The number of objects returned by list function, ' 'with and without a prefix, are expected to be equal, ' 'but its detected otherwise.') sit.check_delete(self, test_bucket.objects, obj)
def test_volume_properties(self): """ Test volume properties """ name = "cb_volprops-{0}".format(helpers.get_uuid()) vol_desc = 'newvoldesc1' # Declare these variables and late binding will allow # the cleanup method access to the most current values test_instance = None net = None with helpers.cleanup_action( lambda: helpers.cleanup_test_resources(test_instance, net)): net, subnet = helpers.create_test_network(self.provider, name) test_instance = helpers.get_test_instance(self.provider, name, subnet=subnet) test_vol = self.provider.storage.volumes.create( name, 1, test_instance.zone_id, description=vol_desc) with helpers.cleanup_action(lambda: test_vol.delete()): test_vol.wait_till_ready() self.assertTrue( isinstance(test_vol.size, six.integer_types) and test_vol.size >= 0, "Volume.size must be a positive number, but got %s" % test_vol.size) self.assertTrue( test_vol.description is None or isinstance(test_vol.description, six.string_types), "Volume.description must be None or a string. Got: %s" % test_vol.description) self.assertIsNone(test_vol.source) self.assertIsNone(test_vol.source) self.assertIsNotNone(test_vol.create_time) self.assertIsNotNone(test_vol.zone_id) self.assertIsNone(test_vol.attachments) test_vol.attach(test_instance, '/dev/sda2') test_vol.wait_for( [VolumeState.IN_USE], terminal_states=[VolumeState.ERROR, VolumeState.DELETED]) self.assertIsNotNone(test_vol.attachments) self.assertIsInstance(test_vol.attachments, AttachmentInfo) self.assertEqual(test_vol.attachments.volume, test_vol) self.assertEqual(test_vol.attachments.instance_id, test_instance.id) if not self.provider.PROVIDER_ID == 'azure': self.assertEqual(test_vol.attachments.device, "/dev/sda2") test_vol.detach() test_vol.name = 'newvolname1' test_vol.wait_for( [VolumeState.AVAILABLE], terminal_states=[VolumeState.ERROR, VolumeState.DELETED]) self.assertEqual(test_vol.name, 'newvolname1') self.assertEqual(test_vol.description, vol_desc) self.assertIsNone(test_vol.attachments) test_vol.wait_for( [VolumeState.AVAILABLE], terminal_states=[VolumeState.ERROR, VolumeState.DELETED])
def test_import_key_pair(self): name = 'cb-kpimport-{0}'.format(helpers.get_uuid()) public_key, _ = cb_helpers.generate_key_pair() kp = self.provider.security.key_pairs.create( name=name, public_key_material=public_key) with helpers.cleanup_action(lambda: kp.delete()): self.assertIsNone(kp.material, "Private KeyPair material should" " be None when key is imported.")
def test_key_pair_properties(self): name = 'cb_kpprops-{0}'.format(helpers.get_uuid()) kp = self.provider.security.key_pairs.create(name=name) with helpers.cleanup_action(lambda: kp.delete()): self.assertIsNotNone( kp.material, "KeyPair material is empty but it should not be.") # get the keypair again - keypair material should now be empty kp = self.provider.security.key_pairs.get(kp.id) self.assertIsNone(kp.material, "Keypair material should now be empty")
def test_snapshot_properties(self): """ Test snapshot properties """ label = "cb-snapprop-{0}".format(helpers.get_uuid()) test_vol = self.provider.storage.volumes.create( label, 1, helpers.get_provider_test_data(self.provider, "placement")) with helpers.cleanup_action(lambda: test_vol.delete()): test_vol.wait_till_ready() snap_label = "cb-snap-{0}".format(label) test_snap = test_vol.create_snapshot(label=snap_label, description=snap_label) def cleanup_snap(snap): if snap: snap.delete() snap.wait_for([SnapshotState.UNKNOWN], terminal_states=[SnapshotState.ERROR]) with helpers.cleanup_action(lambda: cleanup_snap(test_snap)): test_snap.wait_till_ready() self.assertTrue(isinstance(test_vol.size, six.integer_types)) self.assertEqual( test_snap.size, test_vol.size, "Snapshot.size must match original volume's size: %s" " but is: %s" % (test_vol.size, test_snap.size)) self.assertTrue( test_vol.description is None or isinstance(test_vol.description, six.string_types), "Snapshot.description must be None or a string. Got: %s" % test_vol.description) self.assertEqual(test_vol.id, test_snap.volume_id) self.assertIsNotNone(test_vol.create_time) test_snap.label = 'snapnewname1' test_snap.description = 'snapnewdescription1' test_snap.refresh() self.assertEqual(test_snap.label, 'snapnewname1') self.assertEqual(test_snap.description, 'snapnewdescription1') # Test volume creation from a snapshot (via VolumeService) sv_label = "cb-snapvol-{0}".format(test_snap.name) snap_vol = self.provider.storage.volumes.create( sv_label, 1, helpers.get_provider_test_data(self.provider, "placement"), snapshot=test_snap) with helpers.cleanup_action(lambda: snap_vol.delete()): snap_vol.wait_till_ready() # Test volume creation from a snapshot (via Snapshot) snap_vol2 = test_snap.create_volume( helpers.get_provider_test_data(self.provider, "placement")) with helpers.cleanup_action(lambda: snap_vol2.delete()): snap_vol2.wait_till_ready()
def test_crud_router(self): def _cleanup(net, subnet, router, gateway): with helpers.cleanup_action(lambda: net.delete()): with helpers.cleanup_action(lambda: router.delete()): with helpers.cleanup_action(lambda: subnet.delete()): with helpers.cleanup_action(lambda: gateway.delete()): router.detach_subnet(subnet) router.detach_gateway(gateway) label = 'cb-crudrouter-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None sn = None router = None gteway = None with helpers.cleanup_action(lambda: _cleanup(net, sn, router, gteway)): net = self.provider.networking.networks.create( label=label, cidr_block=BaseNetwork.CB_DEFAULT_IPV4RANGE) router = self.provider.networking.routers.create(label=label, network=net) cidr = '10.0.15.0/24' sn = net.create_subnet(label=label, cidr_block=cidr, zone=helpers.get_provider_test_data( self.provider, 'placement')) # Check basic router properties sit.check_standard_behaviour(self, self.provider.networking.routers, router) if (self.provider.PROVIDER_ID != 'gce'): self.assertEqual( router.state, RouterState.DETACHED, "Router {0} state {1} should be {2}.".format( router.id, router.state, RouterState.DETACHED)) self.assertFalse( router.network_id, "Router {0} should not be assoc. with network {1}".format( router.id, router.network_id)) self.assertTrue( len(router.subnets) == 0, "No subnet should be attached to router {1}".format( sn, router)) router.attach_subnet(sn) self.assertTrue( len(router.subnets) == 1, "Subnet {0} not attached to router {1}".format(sn, router)) gteway = net.gateways.get_or_create_inet_gateway() router.attach_gateway(gteway) # TODO: add a check for routes after that's been implemented sit.check_delete(self, self.provider.networking.routers, router)
def test_vm_firewall_properties(self): label = 'cb-propfw-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values fw = None with helpers.cleanup_action(lambda: helpers.cleanup_test_resources( vm_firewall=fw)): subnet = helpers.get_or_create_default_subnet(self.provider) net = subnet.network fw = self.provider.security.vm_firewalls.create( label=label, description=label, network=net.id) self.assertEqual(label, fw.description)
def test_vm_firewall_properties(self): name = 'cb_propfw-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None fw = None with helpers.cleanup_action(lambda: helpers.cleanup_test_resources( network=net, vm_firewall=fw)): net, _ = helpers.create_test_network(self.provider, name) fw = self.provider.security.vm_firewalls.create(name=name, description=name, network_id=net.id) self.assertEqual(name, fw.description)
def test_crud_router(self): def _cleanup(net, subnet, router, gateway): with helpers.cleanup_action(lambda: net.delete()): with helpers.cleanup_action(lambda: subnet.delete()): with helpers.cleanup_action(lambda: gateway.delete()): with helpers.cleanup_action(lambda: router.delete()): router.detach_subnet(subnet) router.detach_gateway(gateway) name = 'cb_crudrouter-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None sn = None router = None gteway = None with helpers.cleanup_action(lambda: _cleanup(net, sn, router, gteway)): net = self.provider.networking.networks.create( name=name, cidr_block='10.0.0.0/16') router = self.provider.networking.routers.create(network=net, name=name) cidr = '10.0.1.0/24' sn = net.create_subnet(name=name, cidr_block=cidr, zone=helpers.get_provider_test_data( self.provider, 'placement')) # Check basic router properties sit.check_standard_behaviour(self, self.provider.networking.routers, router) self.assertEqual( router.state, RouterState.DETACHED, "Router {0} state {1} should be {2}.".format( router.id, router.state, RouterState.DETACHED)) # self.assertFalse( # router.network_id, # "Router {0} should not be assoc. with a network {1}".format( # router.id, router.network_id)) router.attach_subnet(sn) gteway = (self.provider.networking.gateways. get_or_create_inet_gateway(name)) router.attach_gateway(gteway) # TODO: add a check for routes after that's been implemented sit.check_delete(self, self.provider.networking.routers, router)
def test_upload_download_bucket_content_from_file(self): name = "cbtestbucketobjs-{0}".format(helpers.get_uuid()) test_bucket = self.provider.storage.buckets.create(name) with helpers.cleanup_action(lambda: test_bucket.delete()): obj_name = "hello_upload_download.txt" obj = test_bucket.objects.create(obj_name) with helpers.cleanup_action(lambda: obj.delete()): test_file = os.path.join(helpers.get_test_fixtures_folder(), 'logo.jpg') obj.upload_from_file(test_file) target_stream = BytesIO() obj.save_content(target_stream) with open(test_file, 'rb') as f: self.assertEqual(target_stream.getvalue(), f.read())
def test_vm_firewall_group_rule(self): name = 'cb_fwrule-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None fw = None with helpers.cleanup_action(lambda: helpers.cleanup_test_resources( network=net, vm_firewall=fw)): net, _ = helpers.create_test_network(self.provider, name) fw = self.provider.security.vm_firewalls.create(name=name, description=name, network_id=net.id) rules = list(fw.rules) self.assertTrue( # TODO: This should be made consistent across all providers. # Currently, OpenStack creates two rules, one for IPV6 and # another for IPV4 len(rules) >= 1, "Expected a single VM firewall rule allowing" " all outbound traffic. Got {0}.".format(rules)) self.assertEqual( rules[0].direction, TrafficDirection.OUTBOUND, "Expected rule to be outbound. Got {0}.".format(rules)) rule = fw.rules.create(direction=TrafficDirection.INBOUND, src_dest_fw=fw, protocol='tcp', from_port=1, to_port=65535) self.assertTrue( rule.src_dest_fw.name == name, "Expected VM firewall rule name {0}. Got {1}.".format( name, rule.src_dest_fw.name)) for r in fw.rules: r.delete() fw = self.provider.security.vm_firewalls.get(fw.id) # update self.assertTrue( len(list(fw.rules)) == 0, "Deleting VMFirewallRule should delete it: {0}".format( fw.rules)) fwl = self.provider.security.vm_firewalls.list() found_fw = [f for f in fwl if f.name == name] self.assertTrue( len(found_fw) == 0, "VM firewall {0} should have been deleted but still exists.". format(name))
def test_create_and_list_image(self): """ Create a new image and check whether that image can be listed. This covers waiting till the image is ready, checking that the image name is the expected one and whether list_images is functional. """ instance_name = "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 net = None def create_img(name): return test_instance.create_image(name) def cleanup_img(img): img.delete() img.wait_for([MachineImageState.UNKNOWN, MachineImageState.ERROR]) def extra_tests(img): # TODO: Fix moto so that the BDM is populated correctly if not isinstance(self.provider, TestMockHelperMixin): # check image size img.refresh() self.assertGreater( img.min_disk, 0, "Minimum disk" " size required by image is invalid") with helpers.cleanup_action( lambda: helpers.cleanup_test_resources(test_instance, net)): net, subnet = helpers.create_test_network(self.provider, instance_name) test_instance = helpers.get_test_instance(self.provider, instance_name, subnet=subnet) sit.check_crud(self, self.provider.compute.images, MachineImage, "cb_listimg", create_img, cleanup_img, extra_test_func=extra_tests)
def test_crud_subnet(self): # Late binding will make sure that create_subnet gets the # correct value net = None def create_subnet(name): return self.provider.networking.subnets.create( network=net, cidr_block="10.0.0.0/24", name=name) def cleanup_subnet(subnet): self.provider.networking.subnets.delete(subnet=subnet) net_name = 'cb_crudsubnet-{0}'.format(helpers.get_uuid()) net = self.provider.networking.networks.create( name=net_name, cidr_block='10.0.0.0/16') with helpers.cleanup_action(lambda: self.provider.networking.networks. delete(network_id=net.id)): sit.check_crud(self, self.provider.networking.subnets, Subnet, "cb_crudsubnet", create_subnet, cleanup_subnet)
def test_crud_floating_ip(self): net, gw = helpers.get_test_gateway( self.provider, 'cb_crudfipgw-{0}'.format(helpers.get_uuid())) def create_fip(name): fip = gw.floating_ips.create() return fip def cleanup_fip(fip): gw.floating_ips.delete(fip.id) with helpers.cleanup_action( lambda: helpers.delete_test_gateway(net, gw)): sit.check_crud(self, gw.floating_ips, FloatingIP, "cb_crudfip", create_fip, cleanup_fip, skip_name_check=True)
def test_generate_url(self): name = "cbtestbucketobjs-{0}".format(helpers.get_uuid()) test_bucket = self.provider.storage.buckets.create(name) with helpers.cleanup_action(lambda: test_bucket.delete()): obj_name = "hello_upload_download.txt" obj = test_bucket.objects.create(obj_name) with helpers.cleanup_action(lambda: obj.delete()): content = b"Hello World. Generate a url." obj.upload(content) target_stream = BytesIO() obj.save_content(target_stream) url = obj.generate_url(100) if isinstance(self.provider, TestMockHelperMixin): raise self.skipTest( "Skipping rest of test - mock providers can't" " access generated url") self.assertEqual(requests.get(url).content, content)
def test_crud_vm_firewall(self): name = 'cb_crudfw-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values net = None def create_fw(name): return self.provider.security.vm_firewalls.create( name=name, description=name, network_id=net.id) def cleanup_fw(fw): fw.delete() with helpers.cleanup_action( lambda: helpers.cleanup_test_resources(network=net)): net, _ = helpers.create_test_network(self.provider, name) sit.check_crud(self, self.provider.security.vm_firewalls, VMFirewall, "cb_crudfw", create_fw, cleanup_fw)
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_vm_firewall_rule_properties(self): label = 'cb-propfwrule-{0}'.format(helpers.get_uuid()) # Declare these variables and late binding will allow # the cleanup method access to the most current values fw = None with helpers.cleanup_action(lambda: helpers.cleanup_test_resources( vm_firewall=fw)): subnet = helpers.get_or_create_default_subnet(self.provider) net = subnet.network fw = self.provider.security.vm_firewalls.create( label=label, description=label, network=net.id) rule = fw.rules.create( direction=TrafficDirection.INBOUND, protocol='tcp', from_port=1111, to_port=1111, cidr='0.0.0.0/0') self.assertEqual(rule.direction, TrafficDirection.INBOUND) self.assertEqual(rule.protocol, 'tcp') self.assertEqual(rule.from_port, 1111) self.assertEqual(rule.to_port, 1111) self.assertEqual(rule.cidr, '0.0.0.0/0')