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 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)
TEST.databases = utils.TestDataContainer()
TEST.database_backups = utils.TestDataContainer()
TEST.databases.add(database1)
TEST.databases.add(database2)
TEST.database_backups.add(bkup1)
TEST.database_backups.add(bkup2)
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 test_instance_list_all_projects(self):
instance_id = self.random_uuid()
name = self.random_name('test-list')
tenant_id = self.random_uuid()
server_id = self.random_uuid()
insts = [{
"id": instance_id,
"name": name,
"status": "ACTIVE",
"operating_status": "HEALTHY",
"addresses": [{
"type": "private",
"address": "10.0.0.13"
}],
"volume": {
"size": 2
},
"flavor": {
"id": "02"
},
"region": "regionOne",
"datastore": {
"version": "5.6",
"type": "mysql",
"version_number": "5.7.29"
},
"tenant_id": tenant_id,
"access": {
"is_public": False,
"allowed_cidrs": []
},
"server_id": server_id,
'server': {
'id': server_id
}
}]
self.mgmt_client.list.return_value = common.Paginated(
[instances.Instance(mock.MagicMock(), inst) for inst in insts])
parsed_args = self.check_parser(self.cmd, ["--all-projects"],
[("all_projects", True)])
columns, data = self.cmd.take_action(parsed_args)
self.mgmt_client.list.assert_called_once_with(**self.defaults)
self.assertEqual(
database_instances.ListDatabaseInstances.admin_columns, columns)
expected_instances = [
(instance_id, name, 'mysql', '5.6', 'ACTIVE', 'HEALTHY', False, [{
"type":
"private",
"address":
"10.0.0.13"
}], '02', 2, '', server_id, tenant_id),
]
self.assertEqual(expected_instances, data)
def test_show(self):
instance_id = self.random_uuid()
name = self.random_name('test-show')
flavor_id = self.random_uuid()
primary_id = self.random_uuid()
tenant_id = self.random_uuid()
inst = {
"id": instance_id,
"name": name,
"status": "ACTIVE",
"operating_status": "HEALTHY",
"addresses": [{
"type": "private",
"address": "10.0.0.13"
}],
"volume": {
"size": 2
},
"flavor": {
"id": flavor_id
},
"region": "regionOne",
"datastore": {
"version": "5.7.29",
"type": "mysql",
"version_number": "5.7.29"
},
"tenant_id": tenant_id,
"replica_of": {
'id': primary_id
},
"access": {
"is_public": False,
"allowed_cidrs": []
},
}
self.instance_client.get.return_value = instances.Instance(
mock.MagicMock(), inst)
parsed_args = self.check_parser(self.cmd, [instance_id], [])
columns, data = self.cmd.take_action(parsed_args)
values = ([{
'address': '10.0.0.13',
'type': 'private'
}], [], 'mysql', '5.7.29', '5.7.29', flavor_id, instance_id, name,
'HEALTHY', False, 'regionOne', primary_id, 'ACTIVE',
tenant_id, 2)
self.assertEqual(self.columns, columns)
self.assertEqual(values, data)
def setUp(self):
super(InstanceTest, self).setUp()
self.orig__init = instances.Instance.__init__
instances.Instance.__init__ = Mock(return_value=None)
self.instance = instances.Instance()
self.instance.manager = Mock()
def get_default_configuration(self):
return instances.Instance(None, self.fake_default_config)
def get_configuration_instances(self):
return [
instances.Instance(None, fake_instance)
for fake_instance in self.fake_config_instances['instances']
]
def get_clusters_member_2(self):
return instances.Instance(None, self.fake_cluster_member)
def get_instance_create(self):
return instances.Instance(None, self.fake_instance['instance'])
def get_instances(self):
return [
instances.Instance(None, fake_instance)
for fake_instance in self.fake_instances
]
def get_instances_1234(self):
return instances.Instance(None, self.fake_instances[0])
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 test_instance_create_without_allowed_cidrs(self, mock_find):
resp = {
"id": "a1fea1cf-18ad-48ab-bdfd-fce99a4b834e",
"name": "test-mysql",
"status": "BUILD",
"flavor": {
"id": "a48ea749-7ee3-4003-8aae-eb4e79773e2d"
},
"datastore": {
"type": "mysql",
"version": "5.7.29",
"version_number": "5.7.29"
},
"region": "RegionOne",
"access": {
"is_public": True
},
"volume": {
"size": 1
},
"created": "2020-08-12T09:41:47",
"updated": "2020-08-12T09:41:47",
"service_status_updated": "2020-08-12T09:41:47"
}
self.instance_client.create.return_value = instances.Instance(
mock.MagicMock(), resp)
args = [
'test-mysql', '--flavor', 'a48ea749-7ee3-4003-8aae-eb4e79773e2d',
'--size', '1', '--datastore', "mysql", '--datastore-version',
"5.7.29", '--nic', 'net-id=net1', '--is-public'
]
verifylist = [('name', 'test-mysql'),
('flavor', 'a48ea749-7ee3-4003-8aae-eb4e79773e2d'),
('size', 1), ('datastore', "mysql"),
('datastore_version', "5.7.29"), ('nics', 'net-id=net1'),
('is_public', True), ('allowed_cidrs', None)]
parsed_args = self.check_parser(self.cmd, args, verifylist)
columns, data = self.cmd.take_action(parsed_args)
expected_columns = (
'allowed_cidrs',
'created',
'datastore',
'datastore_version',
'datastore_version_number',
'flavor',
'id',
'name',
'public',
'region',
'service_status_updated',
'status',
'updated',
'volume',
)
expected_values = (
[],
"2020-08-12T09:41:47",
"mysql",
"5.7.29",
"5.7.29",
"a48ea749-7ee3-4003-8aae-eb4e79773e2d",
"a1fea1cf-18ad-48ab-bdfd-fce99a4b834e",
"test-mysql",
True,
"RegionOne",
"2020-08-12T09:41:47",
"BUILD",
"2020-08-12T09:41:47",
1,
)
self.assertEqual(expected_columns, columns)
self.assertEqual(expected_values, data)
