def data(TEST):
database = instances.Instance(instances.Instances(None), DATABASE_DATA)
bkup1 = backups.Backup(backups.Backups(None), BACKUP_ONE)
bkup2 = backups.Backup(backups.Backups(None), BACKUP_TWO)
TEST.databases = utils.TestDataContainer()
TEST.database_backups = utils.TestDataContainer()
TEST.databases.add(database)
TEST.database_backups.add(bkup1)
TEST.database_backups.add(bkup2)
def data(TEST):
cluster1 = clusters.Cluster(clusters.Clusters(None), CLUSTER_DATA_ONE)
cluster2 = clusters.Cluster(clusters.Clusters(None), CLUSTER_DATA_TWO)
database1 = instances.Instance(instances.Instances(None),
DATABASE_DATA_ONE)
database2 = instances.Instance(instances.Instances(None),
DATABASE_DATA_TWO)
bkup1 = backups.Backup(backups.Backups(None), BACKUP_ONE)
bkup2 = backups.Backup(backups.Backups(None), BACKUP_TWO)
bkup3 = backups.Backup(backups.Backups(None), BACKUP_TWO_INC)
user1 = users.User(users.Users(None), USER_ONE)
user_db1 = databases.Database(databases.Databases(None), USER_DB_ONE)
datastore1 = datastores.Datastore(datastores.Datastores(None),
DATASTORE_ONE)
version1 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_ONE)
flavor1 = flavors.Flavor(flavors.Flavors(None), FLAVOR_ONE)
flavor2 = flavors.Flavor(flavors.Flavors(None), FLAVOR_TWO)
flavor3 = flavors.Flavor(flavors.Flavors(None), FLAVOR_THREE)
datastore_mongodb = datastores.Datastore(datastores.Datastores(None),
DATASTORE_MONGODB)
version_mongodb_2_6 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_MONGODB_2_6)
TEST.trove_clusters = utils.TestDataContainer()
TEST.trove_clusters.add(cluster1)
TEST.trove_clusters.add(cluster2)
TEST.databases = utils.TestDataContainer()
TEST.database_backups = utils.TestDataContainer()
TEST.database_users = utils.TestDataContainer()
TEST.database_user_dbs = utils.TestDataContainer()
TEST.database_flavors = utils.TestDataContainer()
TEST.databases.add(database1)
TEST.databases.add(database2)
TEST.database_backups.add(bkup1)
TEST.database_backups.add(bkup2)
TEST.database_backups.add(bkup3)
TEST.database_users.add(user1)
TEST.database_user_dbs.add(user_db1)
TEST.datastores = utils.TestDataContainer()
TEST.datastores.add(datastore1)
TEST.datastores.add(datastore_mongodb)
TEST.database_flavors.add(flavor1, flavor2, flavor3)
TEST.datastore_versions = utils.TestDataContainer()
TEST.datastore_versions.add(version_mongodb_2_6)
TEST.datastore_versions.add(version1)
def setUp(self):
super(BackupTest, self).setUp()
self.backup_id = str(uuid.uuid4())
self.info = {'name': 'my backup', 'id': self.backup_id}
self.api = mock.Mock()
self.manager = backups.Backups(self.api)
self.backup = backups.Backup(self.manager, self.info)
def data(TEST):
database1 = instances.Instance(instances.Instances(None),
DATABASE_DATA_ONE)
database2 = instances.Instance(instances.Instances(None),
DATABASE_DATA_TWO)
bkup1 = backups.Backup(backups.Backups(None), BACKUP_ONE)
bkup2 = backups.Backup(backups.Backups(None), BACKUP_TWO)
bkup3 = backups.Backup(backups.Backups(None), BACKUP_TWO_INC)
user1 = users.User(users.Users(None), USER_ONE)
user_db1 = databases.Database(databases.Databases(None), USER_DB_ONE)
datastore1 = datastores.Datastore(datastores.Datastores(None),
DATASTORE_ONE)
version1 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_ONE)
version2 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_TWO)
flavor1 = flavors.Flavor(flavors.Flavors(None), FLAVOR_ONE)
flavor2 = flavors.Flavor(flavors.Flavors(None), FLAVOR_TWO)
flavor3 = flavors.Flavor(flavors.Flavors(None), FLAVOR_THREE)
TEST.databases = utils.TestDataContainer()
TEST.database_backups = utils.TestDataContainer()
TEST.database_users = utils.TestDataContainer()
TEST.database_user_dbs = utils.TestDataContainer()
TEST.database_flavors = utils.TestDataContainer()
TEST.databases.add(database1)
TEST.databases.add(database2)
TEST.database_backups.add(bkup1)
TEST.database_backups.add(bkup2)
TEST.database_backups.add(bkup3)
TEST.database_users.add(user1)
TEST.database_user_dbs.add(user_db1)
TEST.datastores = utils.TestDataContainer()
TEST.datastores.add(datastore1)
TEST.datastore_versions = utils.TestDataContainer()
TEST.datastore_versions.add(version1)
TEST.datastore_versions.add(version2)
TEST.database_flavors.add(flavor1, flavor2, flavor3)
def __init__(self,
username,
api_key,
tenant=None,
auth_url=None,
service_type='database',
service_name=None,
service_url=None,
insecure=False,
auth_strategy='keystone',
region_name=None,
client_cls=TroveHTTPClient):
from troveclient.compat import versions
from troveclient.v1 import accounts
from troveclient.v1 import backups
from troveclient.v1 import clusters
from troveclient.v1 import configurations
from troveclient.v1 import databases
from troveclient.v1 import datastores
from troveclient.v1 import diagnostics
from troveclient.v1 import flavors
from troveclient.v1 import hosts
from troveclient.v1 import instances
from troveclient.v1 import limits
from troveclient.v1 import management
from troveclient.v1 import metadata
from troveclient.v1 import modules
from troveclient.v1 import quota
from troveclient.v1 import root
from troveclient.v1 import security_groups
from troveclient.v1 import storage
from troveclient.v1 import users
self.client = client_cls(username,
api_key,
tenant,
auth_url,
service_type=service_type,
service_name=service_name,
service_url=service_url,
insecure=insecure,
auth_strategy=auth_strategy,
region_name=region_name)
self.versions = versions.Versions(self)
self.databases = databases.Databases(self)
self.flavors = flavors.Flavors(self)
self.instances = instances.Instances(self)
self.limits = limits.Limits(self)
self.users = users.Users(self)
self.root = root.Root(self)
self.hosts = hosts.Hosts(self)
self.quota = quota.Quotas(self)
self.backups = backups.Backups(self)
self.clusters = clusters.Clusters(self)
self.security_groups = security_groups.SecurityGroups(self)
self.security_group_rules = security_groups.SecurityGroupRules(self)
self.datastores = datastores.Datastores(self)
self.datastore_versions = datastores.DatastoreVersions(self)
self.datastore_version_members = (
datastores.DatastoreVersionMembers(self))
self.storage = storage.StorageInfo(self)
self.management = management.Management(self)
self.mgmt_cluster = management.MgmtClusters(self)
self.mgmt_flavor = management.MgmtFlavors(self)
self.accounts = accounts.Accounts(self)
self.diagnostics = diagnostics.DiagnosticsInterrogator(self)
self.hwinfo = diagnostics.HwInfoInterrogator(self)
self.configurations = configurations.Configurations(self)
config_parameters = configurations.ConfigurationParameters(self)
self.configuration_parameters = config_parameters
self.metadata = metadata.Metadata(self)
self.modules = modules.Modules(self)
self.mgmt_configs = management.MgmtConfigurationParameters(self)
self.mgmt_datastore_versions = management.MgmtDatastoreVersions(self)
class Mgmt(object):
def __init__(self, dbaas):
self.instances = dbaas.management
self.hosts = dbaas.hosts
self.accounts = dbaas.accounts
self.storage = dbaas.storage
self.datastore_version = dbaas.mgmt_datastore_versions
self.mgmt = Mgmt(self)
def setUp(self):
super(BackupManagerTest, self).setUp()
self.backups = backups.Backups(mock.Mock())
self.instance_with_id = mock.Mock()
self.instance_with_id.id = 215
def data(TEST):
cluster1 = clusters.Cluster(clusters.Clusters(None), CLUSTER_DATA_ONE)
cluster2 = clusters.Cluster(clusters.Clusters(None), CLUSTER_DATA_TWO)
database1 = instances.Instance(instances.Instances(None),
DATABASE_DATA_ONE)
database2 = instances.Instance(instances.Instances(None),
DATABASE_DATA_TWO)
database3 = instances.Instance(instances.Instances(None),
DATABASE_DATA_THREE)
bkup1 = backups.Backup(backups.Backups(None), BACKUP_ONE)
bkup2 = backups.Backup(backups.Backups(None), BACKUP_TWO)
bkup3 = backups.Backup(backups.Backups(None), BACKUP_TWO_INC)
cfg1 = configurations.Configuration(configurations.Configurations(None),
CONFIG_ONE)
cfg2 = configurations.Configuration(configurations.Configurations(None),
CONFIG_TWO)
user1 = users.User(users.Users(None), USER_ONE)
user_db1 = databases.Database(databases.Databases(None), USER_DB_ONE)
user_root1 = databases.Database(databases.Databases(None), USER_ROOT_ONE)
datastore1 = datastores.Datastore(datastores.Datastores(None),
DATASTORE_ONE)
version1 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_ONE)
version2 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_TWO)
flavor1 = flavors.Flavor(flavors.Flavors(None), FLAVOR_ONE)
flavor2 = flavors.Flavor(flavors.Flavors(None), FLAVOR_TWO)
flavor3 = flavors.Flavor(flavors.Flavors(None), FLAVOR_THREE)
datastore_mongodb = datastores.Datastore(datastores.Datastores(None),
DATASTORE_MONGODB)
version_mongodb_2_6 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_MONGODB_2_6)
datastore_redis = datastores.Datastore(datastores.Datastores(None),
DATASTORE_REDIS)
version_redis_3_0 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_REDIS_3_0)
datastore_vertica = datastores.Datastore(datastores.Datastores(None),
DATASTORE_VERTICA)
version_vertica_7_1 = datastores.\
DatastoreVersion(datastores.DatastoreVersions(None),
VERSION_VERTICA_7_1)
log1 = instances.DatastoreLog(instances.Instances(None), LOG_1)
log2 = instances.DatastoreLog(instances.Instances(None), LOG_2)
log3 = instances.DatastoreLog(instances.Instances(None), LOG_3)
log4 = instances.DatastoreLog(instances.Instances(None), LOG_4)
TEST.trove_clusters = utils.TestDataContainer()
TEST.trove_clusters.add(cluster1)
TEST.trove_clusters.add(cluster2)
TEST.databases = utils.TestDataContainer()
TEST.database_backups = utils.TestDataContainer()
TEST.database_configurations = utils.TestDataContainer()
TEST.database_users = utils.TestDataContainer()
TEST.database_user_dbs = utils.TestDataContainer()
TEST.database_user_roots = utils.TestDataContainer()
TEST.database_flavors = utils.TestDataContainer()
TEST.databases.add(database1)
TEST.databases.add(database2)
TEST.databases.add(database3)
TEST.database_backups.add(bkup1)
TEST.database_backups.add(bkup2)
TEST.database_backups.add(bkup3)
TEST.database_configurations.add(cfg1)
TEST.database_configurations.add(cfg2)
TEST.configuration_parameters = utils.TestDataContainer()
for parameter in CONFIG_PARAMS_ONE:
TEST.configuration_parameters.add(
configurations.ConfigurationParameter(
configurations.ConfigurationParameters(None), parameter))
TEST.configuration_instances = utils.TestDataContainer()
TEST.configuration_instances.add(
configurations.Configuration(configurations.Configurations(None),
CONFIG_INSTANCE_ONE))
TEST.database_users.add(user1)
TEST.database_user_dbs.add(user_db1)
TEST.database_user_roots.add(user_root1)
TEST.datastores = utils.TestDataContainer()
TEST.datastores.add(datastore_mongodb)
TEST.datastores.add(datastore_redis)
TEST.datastores.add(datastore_vertica)
TEST.datastores.add(datastore1)
TEST.database_flavors.add(flavor1, flavor2, flavor3)
TEST.datastore_versions = utils.TestDataContainer()
TEST.datastore_versions.add(version_vertica_7_1)
TEST.datastore_versions.add(version_redis_3_0)
TEST.datastore_versions.add(version_mongodb_2_6)
TEST.datastore_versions.add(version1)
TEST.datastore_versions.add(version2)
TEST.logs = utils.TestDataContainer()
TEST.logs.add(log1, log2, log3, log4)
def __init__(self,
username=None,
password=None,
project_id=None,
auth_url='',
insecure=False,
timeout=None,
tenant_id=None,
proxy_tenant_id=None,
proxy_token=None,
region_name=None,
endpoint_type='publicURL',
extensions=None,
service_type='database',
service_name=None,
database_service_name=None,
retries=None,
http_log_debug=False,
cacert=None,
bypass_url=None,
auth_system='keystone',
auth_plugin=None,
session=None,
auth=None,
**kwargs):
# self.limits = limits.LimitsManager(self)
# extensions
self.flavors = flavors.Flavors(self)
self.volume_types = volume_types.VolumeTypes(self)
self.users = users.Users(self)
self.databases = databases.Databases(self)
self.backups = backups.Backups(self)
self.clusters = clusters.Clusters(self)
self.instances = instances.Instances(self)
self.limits = limits.Limits(self)
self.root = root.Root(self)
self.security_group_rules = security_groups.SecurityGroupRules(self)
self.security_groups = security_groups.SecurityGroups(self)
self.datastores = datastores.Datastores(self)
self.datastore_versions = datastores.DatastoreVersions(self)
self.configurations = configurations.Configurations(self)
config_parameters = configurations.ConfigurationParameters(self)
self.configuration_parameters = config_parameters
self.metadata = metadata.Metadata(self)
self.modules = modules.Modules(self)
self.quota = quota.Quotas(self)
self.mgmt_instances = management.Management(self)
# self.hosts = Hosts(self)
# self.storage = StorageInfo(self)
# self.management = MgmtClusters(self)
# self.mgmt_flavor = MgmtFlavors(self)
# self.accounts = Accounts(self)
# self.diagnostics = DiagnosticsInterrogator(self)
# self.hwinfo = HwInfoInterrogator(self)
# self.mgmt_config_params =
# management.MgmtConfigurationParameters(self)
# Add in any extensions...
if extensions:
for extension in extensions:
if extension.manager_class:
setattr(self, extension.name,
extension.manager_class(self))
self.client = trove_client._construct_http_client(
username=username,
password=password,
project_id=project_id,
auth_url=auth_url,
insecure=insecure,
timeout=timeout,
tenant_id=tenant_id,
proxy_token=proxy_token,
proxy_tenant_id=proxy_tenant_id,
region_name=region_name,
endpoint_type=endpoint_type,
service_type=service_type,
service_name=service_name,
database_service_name=database_service_name,
retries=retries,
http_log_debug=http_log_debug,
cacert=cacert,
bypass_url=bypass_url,
auth_system=auth_system,
auth_plugin=auth_plugin,
session=session,
auth=auth,
**kwargs)
def setUp(self):
super(BackupManagerTest, self).setUp()
self.backups = backups.Backups(mock.Mock())
