def volume_types_with_restore_control( cls, max_datasets=None, randomize=False, model_filter=None, filter_mode=BlockstorageDatasets.INCLUSION_MODE): """Returns a DatasetList of all VolumeTypes Filters should be dictionaries with model attributes as keys and lists of attributes as key values. """ volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list( volume_type_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() is_enabled = \ cls._volumes.config.allow_snapshot_restore_to_different_type for vol_type in volume_type_list: data = {'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_, 'restore_to_different_type_enabled': is_enabled} test_name = "{0}_to_other_is_{1}".format( vol_type.name, "allowed" if is_enabled else "disabled") dataset_list.append_new_dataset(test_name, data) # Apply modifiers return cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize)
def volume_types(cls, max_datasets=None, randomize=None, model_filter=None, filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, tags=None): """Returns a DatasetList of all VolumeTypes Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list(volume_type_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() for vol_type in volume_type_list: data = { 'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_ } dataset_list.append_new_dataset(vol_type.name, data) # Apply modifiers dataset_list = cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize) # Apply Tags if tags: dataset_list.apply_test_tags(*tags) return dataset_list
def volume_types_with_restore_control( cls, max_datasets=None, randomize=False, model_filter=None, filter_mode=BlockstorageDatasets.INCLUSION_MODE): """Returns a DatasetList of all VolumeTypes Filters should be dictionaries with model attributes as keys and lists of attributes as key values. """ volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list(volume_type_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() is_enabled = \ cls._volumes.config.allow_snapshot_restore_to_different_type for vol_type in volume_type_list: data = { 'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_, 'restore_to_different_type_enabled': is_enabled } test_name = "{0}_to_other_is_{1}".format( vol_type.name, "allowed" if is_enabled else "disabled") dataset_list.append_new_dataset(test_name, data) # Apply modifiers return cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize)
def images_by_volume_type(cls, max_datasets=None, randomize=False, image_filter=None, volume_type_filter=None): """Returns a DatasetList of permuations of Volume Types and Images. Requests all available images and volume types from API, and applies image_filter and volume_type_filter if provided. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._filter_model_list(cls._images(), image_filter) volume_type_list = cls._filter_model_list(cls._volume_types(), volume_type_filter) # Create dataset from all combinations of all images and volume types dataset_list = DatasetList() for vol_type in volume_type_list: for img in image_list: data = {'volume_type': vol_type, 'image': img} testname = "{0}_volume_from_{1}_image".format( vol_type.name, str(img.name).replace(" ", "_")) dataset_list.append_new_dataset(testname, data) # Apply modifiers if randomize: shuffle(dataset_list) if max_datasets: dataset_list = dataset_list[:max_datasets] return dataset_list
def images_by_volume_type( cls, max_datasets=None, randomize=False, image_filter=None, volume_type_filter=None, image_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, volume_type_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all combinations of Images and Volume Types. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list( image_list, model_filter=image_filter, filter_mode=image_filter_mode) volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list( volume_type_list, model_filter=volume_type_filter, filter_mode=volume_type_filter_mode) # Create dataset from all combinations of all images and volume types dataset_list = DatasetList() for vtype in volume_type_list: for image in image_list: data = {'volume_type': vtype, 'image': image} testname = \ "{0}_and_{1}".format( str(vtype.name).replace(" ", "_"), str(image.name).replace(" ", "_")) dataset_list.append_new_dataset(testname, data) # Apply modifiers return cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize)
def images_by_flavor( cls, max_datasets=None, randomize=False, image_filter=None, flavor_filter=None, image_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, flavor_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all combinations of Flavors and Images. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list( image_list, model_filter=image_filter, filter_mode=image_filter_mode) flavor_list = cls._get_flavors() flavor_list = cls._filter_model_list( flavor_list, model_filter=flavor_filter, filter_mode=flavor_filter_mode) dataset_list = DatasetList() for image in image_list: for flavor in flavor_list: data = {'flavor': flavor, 'image': image} testname = \ "image_{0}_and_flavor_{1}".format( str(image.name).replace(" ", "_").replace("/", "-"), str(flavor.name).replace(" ", "_").replace("/", "-")) dataset_list.append_new_dataset(testname, data) # Apply modifiers return cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize)
def volume_types( cls, max_datasets=None, randomize=None, model_filter=None, filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, tags=None): """Returns a DatasetList of all VolumeTypes Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list( volume_type_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() for vol_type in volume_type_list: data = {'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_} dataset_list.append_new_dataset(vol_type.name, data) # Apply modifiers dataset_list = cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize) # Apply Tags if tags: dataset_list.apply_test_tags(*tags) return dataset_list
def images_by_volume_type( cls, max_datasets=None, randomize=False, image_filter=None, volume_type_filter=None): """Returns a DatasetList of permuations of Volume Types and Images. Requests all available images and volume types from API, and applies image_filter and volume_type_filter if provided. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._filter_model_list(cls._images(), image_filter) volume_type_list = cls._filter_model_list( cls._volume_types(), volume_type_filter) # Create dataset from all combinations of all images and volume types dataset_list = DatasetList() for vol_type in volume_type_list: for img in image_list: data = {'volume_type': vol_type, 'image': img} testname = "{0}_volume_from_{1}_image".format( vol_type.name, str(img.name).replace(" ", "_")) dataset_list.append_new_dataset(testname, data) # Apply modifiers if randomize: shuffle(dataset_list) if max_datasets: dataset_list = dataset_list[:max_datasets] return dataset_list
def volume_types(cls): """Returns a DatasetList of Volume Type names and id's""" cinder_cli = CinderCLI_Composite() volume_type_list = cinder_cli.behaviors.list_volume_types() dataset_list = DatasetList() for vol_type in volume_type_list: data = {'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_} dataset_list.append_new_dataset(vol_type.name, data) return dataset_list
def flavors_by_images_by_volume_type( cls, max_datasets=None, randomize=None, flavor_filter=None, volume_type_filter=None, image_filter=None, flavor_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, volume_type_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, image_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, ): """Returns a DatasetList of all combinations of Flavors and Volume Types. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list(image_list, model_filter=image_filter, filter_mode=image_filter_mode) flavor_list = cls._get_flavors() flavor_list = cls._filter_model_list(flavor_list, model_filter=flavor_filter, filter_mode=flavor_filter_mode) volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list( volume_type_list, model_filter=volume_type_filter, filter_mode=volume_type_filter_mode) # Create dataset from all combinations of all images, flavors, and # volume types dataset_list = DatasetList() for vtype in volume_type_list: for flavor in flavor_list: for image in image_list: data = { 'volume_type': vtype, 'flavor': flavor, 'image': image } testname = \ "{flavor}_{image}_on_{vtype}".format( flavor=str(flavor.name), image=str(image.name), vtype=str(vtype.name)).replace(' ', '_').replace( '.', '_').replace('(', '').replace(')', '') dataset_list.append_new_dataset(testname, data) # Apply modifiers return cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize)
def volume_types( cls, max_datasets=None, randomize=False, volume_type_filter=None): """Returns a DatasetList of Volume Type names and id's""" volume_type_list = cls._filter_model_list( cls._volume_types(), volume_type_filter) dataset_list = DatasetList() for vol_type in volume_type_list: data = {'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_} dataset_list.append_new_dataset(vol_type.name, data) return dataset_list
def volume_types(cls): """Returns a DatasetList of Volume Type names and id's""" cinder_cli = CinderCLI_Composite() volume_type_list = cinder_cli.behaviors.list_volume_types() dataset_list = DatasetList() for vol_type in volume_type_list: data = { 'volume_type_name': vol_type.name, 'volume_type_id': vol_type.id_ } dataset_list.append_new_dataset(vol_type.name, data) return dataset_list
def flavors_by_images_by_volume_type( cls, max_datasets=None, randomize=None, flavor_filter=None, volume_type_filter=None, image_filter=None, flavor_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, volume_type_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, image_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE,): """Returns a DatasetList of all combinations of Flavors and Volume Types. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list( image_list, model_filter=image_filter, filter_mode=image_filter_mode) flavor_list = cls._get_flavors() flavor_list = cls._filter_model_list( flavor_list, model_filter=flavor_filter, filter_mode=flavor_filter_mode) volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list( volume_type_list, model_filter=volume_type_filter, filter_mode=volume_type_filter_mode) # Create dataset from all combinations of all images, flavors, and # volume types dataset_list = DatasetList() for vtype in volume_type_list: for flavor in flavor_list: for image in image_list: data = {'volume_type': vtype, 'flavor': flavor, 'image': image} testname = \ "{flavor}_{image}_on_{vtype}".format( flavor=str(flavor.name), image=str(image.name), vtype=str(vtype.name)).replace(' ', '_').replace( '.', '_').replace('(', '').replace( ')', '').replace('/', '-') dataset_list.append_new_dataset(testname, data) # Apply modifiers return cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize)
def valid_quota_names(cls): """Creates a list of expected resource names""" quota_test_dataset = DatasetList() resources = ["snapshots", "volumes", "gigabytes"] vol_types = cls._get_volume_type_names() for resource in resources: quota_test_dataset.append_new_dataset(resource, {"quota_name": resource}) for vol_name in vol_types: resource_key = "{resource}_{vol_name}".format(resource=resource, vol_name=vol_name) quota_test_dataset.append_new_dataset(resource_key, {"quota_name": resource_key}) return quota_test_dataset
def valid_quota_names(cls): """Creates a list of expected resource names""" quota_test_dataset = DatasetList() resources = ["snapshots", "volumes", "gigabytes"] vol_types = cls._get_volume_type_names() for resource in resources: quota_test_dataset.append_new_dataset(resource, {"quota_name": resource}) for vol_name in vol_types: resource_key = "{resource}_{vol_name}".format( resource=resource, vol_name=vol_name) quota_test_dataset.append_new_dataset( resource_key, {"quota_name": resource_key}) return quota_test_dataset
def build_basic_dataset(data_dict, name): """ @summary: Builds a dataset list from a dictionary of key-value pairs @param data_dict: Url amendments and values for the dataset list @type data_dict: Dictionary @param name: Name of the test parameter @type name: String @return: Dataset_List @rtype: DatasetList """ dataset_list = DatasetList() for key, value in data_dict.iteritems(): dataset_list.append_new_dataset(key, {name: value}) return dataset_list
def flavors( cls, max_datasets=None, randomize=False, model_filter=None, filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all Flavors Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ flavor_list = cls._get_flavors() flavor_list = cls._filter_model_list( flavor_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() for flavor in flavor_list: data = {'flavor': flavor} dataset_list.append_new_dataset( str(flavor.name).replace(" ", "_").replace("/", "-"), data) # Apply modifiers return cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize)
def images( cls, max_datasets=None, randomize=False, model_filter=None, filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all Images. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list( image_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() for img in image_list: data = {'image': img} dataset_list.append_new_dataset( str(img.name).replace(" ", "_").replace("/", "-"), data) # Apply modifiers return cls._modify_dataset_list( dataset_list, max_datasets=max_datasets, randomize=randomize)
def images_by_volume_type( cls, max_datasets=None, randomize=False, image_filter=None, volume_type_filter=None, image_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, volume_type_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all combinations of Images and Volume Types. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list(image_list, model_filter=image_filter, filter_mode=image_filter_mode) volume_type_list = cls._get_volume_types() volume_type_list = cls._filter_model_list( volume_type_list, model_filter=volume_type_filter, filter_mode=volume_type_filter_mode) # Create dataset from all combinations of all images and volume types dataset_list = DatasetList() for vtype in volume_type_list: for image in image_list: data = {'volume_type': vtype, 'image': image} testname = \ "{0}_and_{1}".format( str(vtype.name).replace(" ", "_"), str(image.name).replace(" ", "_")) dataset_list.append_new_dataset(testname, data) # Apply modifiers return cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize)
def images_by_flavor( cls, max_datasets=None, randomize=False, image_filter=None, flavor_filter=None, image_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE, flavor_filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all combinations of Flavors and Images. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list(image_list, model_filter=image_filter, filter_mode=image_filter_mode) flavor_list = cls._get_flavors() flavor_list = cls._filter_model_list(flavor_list, model_filter=flavor_filter, filter_mode=flavor_filter_mode) dataset_list = DatasetList() for image in image_list: for flavor in flavor_list: data = {'flavor': flavor, 'image': image} testname = \ "image_{0}_and_flavor_{1}".format( str(image.name).replace(" ", "_").replace("/", "-"), str(flavor.name).replace(" ", "_").replace("/", "-")) dataset_list.append_new_dataset(testname, data) # Apply modifiers return cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize)
def flavors(cls, max_datasets=None, randomize=False, model_filter=None, filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all Flavors Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ flavor_list = cls._get_flavors() flavor_list = cls._filter_model_list(flavor_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() for flavor in flavor_list: data = {'flavor': flavor} dataset_list.append_new_dataset( str(flavor.name).replace(" ", "_").replace("/", "-"), data) # Apply modifiers return cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize)
def images(cls, max_datasets=None, randomize=False, model_filter=None, filter_mode=ModelBasedDatasetToolkit.INCLUSION_MODE): """Returns a DatasetList of all Images. Filters should be dictionaries with model attributes as keys and lists of attributes as key values """ image_list = cls._get_images() image_list = cls._filter_model_list(image_list, model_filter=model_filter, filter_mode=filter_mode) dataset_list = DatasetList() for img in image_list: data = {'image': img} dataset_list.append_new_dataset( str(img.name).replace(" ", "_").replace("/", "-"), data) # Apply modifiers return cls._modify_dataset_list(dataset_list, max_datasets=max_datasets, randomize=randomize)
data_driven_test) from cafe.engine.http.client import HTTPClient from cloudcafe.common.tools.check_dict import get_value from cloudcafe.objectstorage.objectstorage_api.common.constants import \ Constants from cloudroast.objectstorage.fixtures import ObjectStorageFixture BASE_CONTAINER_NAME = 'tempurl' CONTENT_TYPE_TEXT = 'text/plain; charset=UTF-8' TEMPURL_KEY_LIFE = 20 EXPECTED_DISPOSITION = ("attachment; filename=\"{filename}\";" " filename*=UTF-8\'\'{filename}") sha_type = DatasetList() sha_type.append_new_dataset("with_sha1", {"sha_type": "sha1"}) sha_type.append_new_dataset("with_sha2", {"sha_type": "sha2"}) @DataDrivenFixture class TempUrlTest(ObjectStorageFixture): def _reset_default_key(self): response = None headers = {'X-Account-Meta-Temp-URL-Key': self.tempurl_key} response = self.client.set_temp_url_key(headers=headers) time.sleep(self.objectstorage_api_config.tempurl_key_cache_time) return response @classmethod def setUpClass(cls): super(TempUrlTest, cls).setUpClass()
limitations under the License. """ from cafe.drivers.unittest.decorators import data_driven_test from cafe.drivers.unittest.decorators import DataDrivenFixture from cloudroast.objectstorage.fixtures import ObjectStorageFixture from cafe.drivers.unittest.datasets import DatasetList CONTENT_TYPE_TEXT = "text/plain; charset=utf-8" CONTENT_TYPE_XML = "application/xml; charset=utf-8" CONTENT_TYPE_JSON = "application/json; charset=utf-8" CONTAINER_NAME = "list_format_test_container" data_set_list = DatasetList() data_set_list.append_new_dataset("text", { "content_type": CONTENT_TYPE_TEXT, "headers": {} }) data_set_list.append_new_dataset("json_header", { "content_type": CONTENT_TYPE_JSON, "headers": { "Accept": CONTENT_TYPE_JSON } }) data_set_list.append_new_dataset("json_param", { "content_type": CONTENT_TYPE_JSON, "params": { "format": "json" } })
from cafe.drivers.unittest.decorators import DataDrivenFixture, \ data_driven_test from cloudroast.networking.networks.fixtures \ import NetworkingSecurityGroupsFixture from cloudcafe.networking.networks.extensions.security_groups_api.constants \ import SecurityGroupsErrorTypes, SecurityGroupsResponseCodes LONG_DESCRIPTION_DATA = 'Long Security Group Test text description' * 10 LONG_NAME_DATA = 'Long Security Group Test text name name name' * 10 # Creating data sets for data driven testing data_set_list = DatasetList() data_set_list.append_new_dataset( name='w_name', data_dict={"name": 'test_secgroup_name_update'}, tags=['sec_group', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_description', data_dict={"description": 'Security Group updated description'}, tags=['sec_group', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_name_and_description', data_dict={"name": 'test_secgroup_name_update', "description": 'Security Group updated description'}, tags=['sec_group', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_blank_name_and_description', data_dict={"name": '', "expected_name": '', "description": '', "expected_description": '', "use_false_values": True}, tags=['sec_group', 'post', 'positive', 'rbac_creator'])
from cafe.drivers.unittest.decorators import DataDrivenFixture, data_driven_test from cloudroast.networking.networks.fixtures import NetworkingSecurityGroupsFixture from cloudcafe.networking.networks.extensions.security_groups_api.constants import ( SecurityGroupsErrorTypes, SecurityGroupsResponseCodes, ) LONG_DESCRIPTION_DATA = "Long Security Group Test text description" * 10 LONG_NAME_DATA = "Long Security Group Test text name name name" * 10 # Creating data sets for data driven testing data_set_list = DatasetList() data_set_list.append_new_dataset( name="w_name", data_dict={"name": "test_secgroup_create"}, tags=["sec_group", "post", "positive", "rbac_creator"] ) data_set_list.append_new_dataset( name="w_long_name", data_dict={"name": "1234567890123456789012345678901234567890"}, tags=["sec_group", "post", "positive", "rbac_creator"], ) data_set_list.append_new_dataset( name="w_none_name_and_description", data_dict={ "name": None, "expected_name": "", "description": None, "expected_description": "", "tenant_id": None, "use_false_values": True,
from cloudcafe.common.tools import randomstring as randstring from cloudcafe.objectstorage.objectstorage_api.common.constants import Constants from cloudroast.objectstorage.fixtures import ObjectStorageFixture BASE_NAME = "extract_archive" HTTP_OK = 200 supported_formats = ["tar", "tar.gz", "tar.bz2"] archive_formats = DatasetList() for archive_format in supported_formats: for wrong_format in supported_formats: if archive_format == wrong_format: continue name = "{}-{}".format(archive_format, wrong_format) archive_formats.append_new_dataset( name, {"name": name, "archive_format": archive_format, "wrong_format": wrong_format} ) @DataDrivenFixture class ExtractArchiveFormatParameterTest(ObjectStorageFixture): """ Tests Swfit expand archive operations: """ @classmethod def setUpClass(cls): super(ExtractArchiveFormatParameterTest, cls).setUpClass() cls.default_obj_name = Constants.VALID_OBJECT_NAME cls.data_dir = EngineConfig().data_directory cls.no_compression = None
from cafe.drivers.unittest.datasets import DatasetList from cafe.drivers.unittest.decorators import DataDrivenFixture, \ data_driven_test from cloudroast.networking.networks.fixtures \ import NetworkingSecurityGroupsFixture from cloudcafe.networking.networks.extensions.security_groups_api.constants \ import SecurityGroupsErrorTypes, SecurityGroupsResponseCodes LONG_DESCRIPTION_DATA = 'Long Security Group Test text description' * 10 LONG_NAME_DATA = 'Long Security Group Test text name name name' * 10 # Creating data sets for data driven testing data_set_list = DatasetList() data_set_list.append_new_dataset( name='w_name', data_dict={"name": 'test_secgroup_create'}, tags=['sec_group', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_long_name', data_dict={"name": '1234567890123456789012345678901234567890'}, tags=['sec_group', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_none_name_and_description', data_dict={ "name": None, "expected_name": '', "description": None, "expected_description": '', "tenant_id": None, "use_false_values": True },
limitations under the License. """ from cafe.drivers.unittest.decorators import data_driven_test from cafe.drivers.unittest.decorators import DataDrivenFixture from cloudroast.objectstorage.fixtures import ObjectStorageFixture from cafe.drivers.unittest.datasets import DatasetList CONTENT_TYPE_TEXT = "text/plain; charset=utf-8" CONTENT_TYPE_XML = "application/xml; charset=utf-8" CONTENT_TYPE_JSON = "application/json; charset=utf-8" CONTAINER_NAME = "list_format_test_container" data_set_list = DatasetList() data_set_list.append_new_dataset("text", {"content_type": CONTENT_TYPE_TEXT, "headers": {}}) data_set_list.append_new_dataset( "json_header", {"content_type": CONTENT_TYPE_JSON, "headers": {"Accept": CONTENT_TYPE_JSON}} ) data_set_list.append_new_dataset("json_param", {"content_type": CONTENT_TYPE_JSON, "params": {"format": "json"}}) data_set_list.append_new_dataset( "xml_header", {"content_type": CONTENT_TYPE_XML, "headers": {"Accept": CONTENT_TYPE_XML}} ) data_set_list.append_new_dataset("xml_param", {"content_type": CONTENT_TYPE_XML, "params": {"format": "xml"}}) @DataDrivenFixture
from cloudroast.objectstorage.fixtures import ObjectStorageFixture from cloudcafe.common.tools import randomstring as randstring BASE_NAME = "extract_archive" HTTP_OK = 200 supported_formats = ['tar', 'tar.gz', 'tar.bz2'] archive_formats = DatasetList() for archive_format in supported_formats: for wrong_format in supported_formats: if archive_format == wrong_format: continue name = '{}-{}'.format(archive_format, wrong_format) archive_formats.append_new_dataset( name, {'name': name, 'archive_format': archive_format, 'wrong_format': wrong_format}) @DataDrivenFixture class ExtractArchiveFormatParameterTest(ObjectStorageFixture): """ Tests Swfit expand archive operations: """ @classmethod def setUpClass(cls): super(ExtractArchiveFormatParameterTest, cls).setUpClass() cls.default_obj_name = cls.behaviors.VALID_OBJECT_NAME cls.data_dir = EngineConfig().data_directory cls.no_compression = None cls.storage_url = cls.client.storage_url
from cafe.drivers.unittest.decorators import DataDrivenFixture, \ data_driven_test, tags from vnc_api import vnc_api from cloudcafe.networking.networks.config import ContrailConfig from cloudcafe.networking.networks.extensions.security_groups_api.composites \ import SecurityGroupsComposite CONF = ContrailConfig() # Creating data sets for data driven test data_set_list_lls = DatasetList() data_set_list_lls.append_new_dataset( name='with_fabric_dns', data_dict={'lls_name': 'cloudroast-lls-%s' % randint(1, 9), 'lls_ip': '169.254.%s.%s' % (randint(0, 254), randint(1, 254)), 'lls_port': int(CONF.fabric_service_port), 'fabric_port': int(CONF.fabric_service_port), 'fabric_dns': CONF.fabric_service_name}, tags=['scenario', 'sdn']) data_set_list_lls.append_new_dataset( name='with_fabric_ip', data_dict={'lls_name': 'cloudroast-lls-%s' % randint(1, 9), 'lls_ip': '169.254.%s.%s' % (randint(0, 254), randint(1, 254)), 'lls_port': int(CONF.fabric_service_port), 'fabric_port': int(CONF.fabric_service_port), 'fabric_ip': CONF.fabric_service_ip, }, tags=['scenario', 'sdn'])
""" import unittest from cafe.drivers.unittest.datasets import DatasetList from cafe.drivers.unittest.decorators import DataDrivenFixture, \ data_driven_test, tags from cloudcafe.networking.networks.config import NetworkingSecondUserConfig from cloudroast.networking.networks.fixtures \ import NetworkingSecurityGroupsFixture from cloudcafe.networking.networks.extensions.security_groups_api.constants \ import SecurityGroupsErrorTypes, SecurityGroupsResponseCodes # Creating data sets for data driven testing data_set_list = DatasetList() data_set_list.append_new_dataset( name='', data_dict={'direction': 'egress'}, tags=['sec_group_egress', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_protocol_icmp', data_dict={ 'protocol': 'icmp', 'direction': 'egress' }, tags=['sec_group_egress', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_protocol_tcp', data_dict={ 'protocol': 'tcp', 'direction': 'egress' }, tags=['sec_group_egress', 'post', 'positive', 'rbac_creator'])
limitations under the License. """ import os from cafe.drivers.unittest.datasets import DatasetList from cafe.drivers.unittest.decorators import ( DataDrivenFixture, data_driven_test) from cafe.engine.config import EngineConfig from cloudcafe.common.tools.md5hash import get_md5_hash from cloudroast.objectstorage.fixtures import ObjectStorageFixture BASE_NAME = "extract_archive" HTTP_OK = 200 archive_formats = DatasetList() archive_formats.append_new_dataset( 'tar', {'name': 'tar', 'archive_format': 'tar'}) archive_formats.append_new_dataset( 'tar.gz', {'name': 'tar.gz', 'archive_format': 'tar.gz'}) archive_formats.append_new_dataset( 'tar.bz2', {'name': 'tar.bz2', 'archive_format': 'tar.bz2'}) @DataDrivenFixture class ExtractArchiveTest(ObjectStorageFixture): """ Tests Swfit expand archive operations Notes: The initial response status code is for initial the request. The object extraction status code is sent in the body of the response. """
import unittest from cafe.drivers.unittest.datasets import DatasetList from cafe.drivers.unittest.decorators import DataDrivenFixture, \ data_driven_test, tags from cloudcafe.networking.networks.config import NetworkingSecondUserConfig from cloudroast.networking.networks.fixtures \ import NetworkingSecurityGroupsFixture from cloudcafe.networking.networks.extensions.security_groups_api.constants \ import SecurityGroupsErrorTypes, SecurityGroupsResponseCodes # Creating data sets for data driven testing data_set_list = DatasetList() data_set_list.append_new_dataset( name='', data_dict={}, tags=['sdn', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_protocol_icmp', data_dict={'protocol': 'icmp'}, tags=['periodic', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_protocol_tcp', data_dict={'protocol': 'tcp'}, tags=['periodic', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_protocol_udp', data_dict={'protocol': 'udp'}, tags=['periodic', 'post', 'positive', 'rbac_creator']) data_set_list.append_new_dataset( name='w_ethertype_ipv4',
Constants from cloudroast.objectstorage.fixtures import ObjectStorageFixture BASE_NAME = "extract_archive" HTTP_OK = 200 supported_formats = ['tar', 'tar.gz', 'tar.bz2'] archive_formats = DatasetList() for archive_format in supported_formats: for wrong_format in supported_formats: if archive_format == wrong_format: continue name = '{}-{}'.format(archive_format, wrong_format) archive_formats.append_new_dataset( name, { 'name': name, 'archive_format': archive_format, 'wrong_format': wrong_format }) @DataDrivenFixture class ExtractArchiveFormatParameterTest(ObjectStorageFixture): """ Tests Swfit expand archive operations: """ @classmethod def setUpClass(cls): super(ExtractArchiveFormatParameterTest, cls).setUpClass() cls.default_obj_name = Constants.VALID_OBJECT_NAME cls.data_dir = EngineConfig().data_directory cls.no_compression = None
from cafe.drivers.unittest.datasets import DatasetList from cafe.drivers.unittest.decorators import (DataDrivenFixture, data_driven_test) from cafe.engine.config import EngineConfig from cloudcafe.common.tools.md5hash import get_md5_hash from cloudcafe.objectstorage.objectstorage_api.common.constants import \ Constants from cloudroast.objectstorage.fixtures import ObjectStorageFixture BASE_NAME = "extract_archive" HTTP_OK = 200 archive_formats = DatasetList() archive_formats.append_new_dataset('tar', { 'name': 'tar', 'archive_format': 'tar' }) archive_formats.append_new_dataset('tar.gz', { 'name': 'tar.gz', 'archive_format': 'tar.gz' }) archive_formats.append_new_dataset('tar.bz2', { 'name': 'tar.bz2', 'archive_format': 'tar.bz2' }) @DataDrivenFixture class ExtractArchiveTest(ObjectStorageFixture): """ Tests Swfit expand archive operations