def test_create_cluster(self, mock_dv, mock_ds, mock_find_all,
mock_all_instances_ready, mock_load, mock_ip,
mock_password, mock_guest, mock_create_shard,
mock_reset_task):
mock_find_all.return_value.all.return_value = [
self.dbinst1, self.dbinst2, self.dbinst3, self.dbinst4
]
mock_all_instances_ready.return_value = True
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
query_router = BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
config_server = BaseInstance(
Mock(), self.dbinst4, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_load.side_effect = [member1, member2, query_router, config_server]
mock_ip.side_effect = ["10.0.0.5"]
mock_create_shard.return_value = True
self.clustertasks.create_cluster(Mock(), self.cluster_id)
mock_guest().add_config_servers.assert_called_with(["10.0.0.5"])
mock_guest().create_admin_user.assert_called_with("pwd")
mock_create_shard.assert_called_with(query_router, [member1, member2])
self.assertEqual(4, mock_guest().cluster_complete.call_count)
mock_reset_task.assert_called_with()
def test_create_replica_set(self, mock_dv, mock_ds, mock_ip, mock_guest):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
members = [member1, member2]
mock_ip.return_value = "10.0.0.2"
mock_guest.return_value.add_members.return_value = Mock()
ret_val = self.clustertasks._create_replica_set(members,
self.cluster_id,
shard_id="shard-1")
mock_guest.return_value.add_members.assert_called_with(["10.0.0.2"])
self.assertEqual(True, ret_val)
def test_grow_cluster_query_router(self, mock_dv, mock_ds, mock_load,
mock_ip, mock_add_query_router):
query_router = BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
config_server = BaseInstance(
Mock(), self.dbinst4, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_load.side_effect = [query_router, config_server]
mock_ip.return_value = '10.0.0.5'
mock_add_query_router.return_value = True
self._run_grow_cluster(new_instances_ids=[query_router.id])
mock_add_query_router.assert_called_with([query_router], ['10.0.0.5'])
def test_init_replica_set(self, mock_dv, mock_ds, mock_ip, mock_guest):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
primary_member = member1
other_members = [member2]
mock_ip.side_effect = ["10.0.0.3"]
mock_guest().prep_primary.return_value = Mock()
mock_guest().add_members.return_value = Mock()
ret_val = self.clustertasks._init_replica_set(primary_member,
other_members)
mock_guest.return_value.add_members.assert_called_with(["10.0.0.3"])
self.assertEqual(True, ret_val)
def test_grow_cluster_shard(self, mock_dv, mock_ds, mock_running_qr_id,
mock_load, mock_create_shard):
mock_running_qr_id.return_value = '3'
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
query_router = BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_load.side_effect = [member1, member2, query_router]
mock_create_shard.return_value = True
self._run_grow_cluster(new_instances_ids=[member1.id, member2.id])
mock_create_shard.assert_called_with(query_router, [member1, member2])
def test_upgrade(self, task_upgrade):
instance_model = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestUpgradeInstance",
datastore_version_id=self.datastore_version1.id)
instance_model.set_task_status(InstanceTasks.NONE)
instance_model.save()
instance_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=instance_model.id)
instance_status.save()
self.assertIsNotNone(instance_model)
instance = models.load_instance(models.Instance, self.context,
instance_model.id)
try:
instance.upgrade(self.datastore_version2)
self.assertEqual(self.datastore_version2.id,
instance.db_info.datastore_version_id)
self.assertEqual(InstanceTasks.UPGRADING,
instance.db_info.task_status)
self.assertTrue(task_upgrade.called)
finally:
instance_status.delete()
instance_model.delete()
def test_tranformer(self):
transformer = mgmtmodels.NotificationTransformer(context=self.context)
status = rd_instance.ServiceStatuses.BUILDING.api_status
db_instance = MockMgmtInstanceTest.build_db_instance(
status, InstanceTasks.BUILDING)
when(DatabaseModelBase).find_all(deleted=False).thenReturn(
[db_instance])
stub_dsv_db_info = mock(datastore_models.DBDatastoreVersion)
stub_dsv_db_info.id = "test_datastore_version"
stub_dsv_db_info.datastore_id = "mysql_test_version"
stub_dsv_db_info.name = "test_datastore_name"
stub_dsv_db_info.image_id = "test_datastore_image_id"
stub_dsv_db_info.packages = "test_datastore_pacakges"
stub_dsv_db_info.active = 1
stub_dsv_db_info.manager = "mysql"
stub_datastore_version = datastore_models.DatastoreVersion(
stub_dsv_db_info)
when(DatabaseModelBase).find_by(id=any()).thenReturn(
stub_datastore_version)
when(DatabaseModelBase).find_by(instance_id='1').thenReturn(
InstanceServiceStatus(rd_instance.ServiceStatuses.BUILDING))
payloads = transformer()
self.assertIsNotNone(payloads)
self.assertThat(len(payloads), Equals(1))
payload = payloads[0]
self.assertThat(payload['audit_period_beginning'], Not(Is(None)))
self.assertThat(payload['audit_period_ending'], Not(Is(None)))
self.assertThat(payload['state'], Equals(status.lower()))
def setUp(self):
super(SimpleInstanceTest, self).setUp()
self.context = trove_testtools.TroveTestContext(self, is_admin=True)
db_info = DBInstance(InstanceTasks.BUILDING, name="TestInstance")
self.instance = SimpleInstance(None,
db_info,
InstanceServiceStatus(
ServiceStatuses.BUILDING),
ds_version=Mock(),
ds=Mock(),
locality='affinity')
self.instance.context = self.context
db_info.addresses = {
"private": [{
"addr": "123.123.123.123"
}],
"internal": [{
"addr": "10.123.123.123"
}],
"public": [{
"addr": "15.123.123.123"
}]
}
self.orig_conf = CONF.network_label_regex
self.orig_ip_regex = CONF.ip_regex
self.orig_black_list_regex = CONF.black_list_regex
def setUp(self):
super(SimpleInstanceTest, self).setUp()
self.context = trove_testtools.TroveTestContext(self, is_admin=True)
db_info = DBInstance(InstanceTasks.BUILDING, name="TestInstance")
self.instance = SimpleInstance(None,
db_info,
InstanceServiceStatus(
ServiceStatuses.BUILDING),
ds_version=Mock(),
ds=Mock(),
locality='affinity')
self.instance.context = self.context
db_info.addresses = [
{
'type': 'private',
'address': '123.123.123.123'
},
{
'type': 'private',
'address': '10.123.123.123'
},
{
'type': 'public',
'address': '15.123.123.123'
},
]
self.orig_ip_regex = CONF.ip_regex
self.orig_black_list_regex = CONF.black_list_regex
def setUp(self):
util.init_db()
self.datastore = datastore_models.DBDatastore.create(
id=str(uuid.uuid4()),
name='name',
default_version_id=str(uuid.uuid4()))
self.datastore_version = datastore_models.DBDatastoreVersion.create(
id=self.datastore.default_version_id,
name='name',
image_id=str(uuid.uuid4()),
packages=str(uuid.uuid4()),
datastore_id=self.datastore.id,
manager='mysql',
active=1)
self.master = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestMasterInstance",
datastore_version_id=self.datastore_version.id)
self.master.set_task_status(InstanceTasks.NONE)
self.master.save()
self.master_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=self.master.id)
self.master_status.save()
self.safe_nova_client = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def test_create_replica_set_failure(self, mock_dv, mock_ds, mock_ip,
mock_guest, mock_update):
mock_ip.return_value = "10.0.0.2"
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
members = [member1, member2]
mock_guest.return_value.add_members = Mock(
side_effect=Exception("Boom!"))
ret_val = self.clustertasks._create_replica_set(members,
self.cluster_id,
shard_id="shard-1")
mock_guest.return_value.add_members.assert_called_with(["10.0.0.2"])
mock_update.assert_called_with(self.cluster_id, 'shard-1')
self.assertEqual(False, ret_val)
def test_create_cluster_instance_not_ready(self, mock_dv, mock_ds,
mock_find_all, mock_load,
mock_ready, mock_reset_task):
mock_find_all.return_value.all.return_value = [self.dbinst1]
mock_load.return_value = BaseInstance(
Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
self.clustertasks.create_cluster(Mock(), self.cluster_id)
mock_reset_task.assert_called_with()
def get_inst_service_status(self, status_id, statuses):
answers = []
for i, status in enumerate(statuses):
inst_svc_status = InstanceServiceStatus(status,
id="%s-%s" % (status_id,
i))
inst_svc_status.save = MagicMock(return_value=None)
answers.append(inst_svc_status)
return answers
def test_add_query_routers_failure(self, mock_logging, mock_dv, mock_ds,
mock_password, mock_guest, mock_update):
query_router = BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_guest.side_effect = Exception("Boom!")
ret_val = self.clustertasks._add_query_routers([query_router],
['10.0.0.5'])
mock_update.assert_called_with(self.cluster_id)
self.assertEqual(False, ret_val)
def test_create_shard(self, mock_dv, mock_ds, mock_ip, mock_guest):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
members = [member1, member2]
query_routers = [
BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
]
mock_ip.return_value = "10.0.0.2"
mock_guest.return_value.add_shard.return_value = Mock()
ret_val = self.clustertasks._create_shard(query_routers,
"rs1",
members,
self.cluster_id,
shard_id="shard-1")
mock_guest.return_value.add_shard.assert_called_with("rs1", "10.0.0.2")
self.assertEqual(True, ret_val)
def test_init_replica_set_failure(self, mock_logging, mock_dv, mock_ds,
mock_ip, mock_guest, mock_update):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
primary_member = member1
other_members = [member2]
mock_ip.side_effect = ["10.0.0.3"]
mock_guest().prep_primary.return_value = Mock()
mock_guest().add_members.return_value = Mock()
mock_guest.return_value.add_members = Mock(
side_effect=Exception("Boom!"))
ret_val = self.clustertasks._init_replica_set(primary_member,
other_members)
mock_update.assert_called_with(self.cluster_id, shard_id='shard-1')
self.assertEqual(False, ret_val)
def test_add_query_routers(self, mock_dv, mock_ds, mock_guest):
password = '******'
query_router = BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
ret_val = self.clustertasks._add_query_routers([query_router],
['10.0.0.5'],
admin_password=password)
mock_guest.assert_called_with(query_router)
mock_guest().add_config_servers.assert_called_with(['10.0.0.5'])
mock_guest().store_admin_password.assert_called_with(password)
self.assertTrue(ret_val)
def setUp(self):
super(SimpleInstanceTest, self).setUp()
db_info = DBInstance(InstanceTasks.BUILDING, name="TestInstance")
self.instance = SimpleInstance(None, db_info,
InstanceServiceStatus(
ServiceStatuses.BUILDING),
ds_version=Mock(), ds=Mock())
db_info.addresses = {"private": [{"addr": "123.123.123.123"}],
"internal": [{"addr": "10.123.123.123"}],
"public": [{"addr": "15.123.123.123"}]}
self.orig_conf = CONF.network_label_regex
self.orig_ip_regex = CONF.ip_regex
def test_create_cluster(self, mock_dv, mock_ds, mock_find_all, mock_load,
mock_ready, mock_ip, mock_guest, mock_reset_task):
mock_find_all.return_value.all.return_value = [self.dbinst1]
mock_load.return_value = BaseInstance(
Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_ip.return_value = "10.0.0.2"
self.clustertasks.create_cluster(Mock(), self.cluster_id)
mock_guest.return_value.install_cluster.assert_called_with(
['10.0.0.2'])
mock_reset_task.assert_called()
mock_guest.return_value.cluster_complete.assert_called()
def test_add_query_routers(self, mock_dv, mock_ds, mock_password,
mock_guest):
query_router = BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_password.return_value = 'pwd'
ret_val = self.clustertasks._add_query_routers([query_router],
['10.0.0.5'])
mock_guest.assert_called_with(query_router)
mock_guest().add_config_servers.assert_called_with(['10.0.0.5'])
mock_guest().store_admin_password.assert_called_with('pwd')
self.assertEqual(True, ret_val)
def test_create_shard_failure(self, mock_dv, mock_ds, mock_ip, mock_guest,
mock_init_rs, mock_update):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
members = [member1, member2]
mock_ip.side_effect = ["10.0.0.2"]
query_router = [
BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
]
mock_guest().get_replica_set_name.return_value = 'testrs'
mock_add_shard = Mock(side_effect=Exception("Boom!"))
mock_guest().add_shard = mock_add_shard
ret_val = self.clustertasks._create_shard(query_router, members)
mock_init_rs.assert_called_with(member1, [member2])
mock_update.assert_called_with(self.cluster_id, shard_id="shard-1")
self.assertEqual(False, ret_val)
def test_create_shard_failure(self, mock_dv, mock_ds, mock_ip, mock_guest,
mock_update):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
members = [member1, member2]
query_routers = [
BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
]
mock_ip.return_value = "10.0.0.2"
mock_guest.return_value.add_shard = Mock(
side_effect=Exception("Boom!"))
ret_val = self.clustertasks._create_shard(query_routers,
"rs1",
members,
self.cluster_id,
shard_id="shard-1")
mock_guest.return_value.add_shard.assert_called_with("rs1", "10.0.0.2")
mock_update.assert_called_with(self.cluster_id, "shard-1")
self.assertEqual(False, ret_val)
def test_create_shard(self, mock_dv, mock_ds, mock_ip, mock_guest,
mock_init_rs):
member1 = BaseInstance(Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
member2 = BaseInstance(Mock(), self.dbinst2, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
members = [member1, member2]
mock_ip.side_effect = ["10.0.0.2"]
query_router = [
BaseInstance(Mock(), self.dbinst3, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
]
mock_guest().get_replica_set_name.return_value = 'testrs'
mock_add_shard = Mock()
mock_guest().add_shard = mock_add_shard
ret_val = self.clustertasks._create_shard(query_router, members)
mock_init_rs.assert_called_with(member1, [member2])
mock_add_shard.assert_called_with("testrs", "10.0.0.2")
self.assertEqual(True, ret_val)
def test_create_cluster_fail(self, mock_logging, mock_dv, mock_ds,
mock_find_all, mock_load, mock_ready, mock_ip,
mock_reset_task, mock_update_status):
mock_find_all.return_value.all.return_value = [self.dbinst1]
mock_load.return_value = BaseInstance(
Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_ip.return_value = "10.0.0.2"
guest_client = Mock()
guest_client.install_cluster = Mock(side_effect=GuestError("Error"))
with patch.object(ClusterTasks, 'get_guest',
return_value=guest_client):
self.clustertasks.create_cluster(Mock(), self.cluster_id)
mock_update_status.assert_called_with('1232')
mock_reset_task.assert_called_with()
def test_add_shard_cluster(self, mock_find_all, mock_all_instances_ready,
mock_load, mock_dv, mock_ds, mock_add_shard,
mock_guest, mock_reset_task):
mock_find_all.return_value.all.return_value = [
self.dbinst1, self.dbinst2, self.dbinst3, self.dbinst4
]
mock_load.return_value = BaseInstance(
Mock(), self.dbinst1, Mock(),
InstanceServiceStatus(ServiceStatuses.NEW))
mock_all_instances_ready.return_value = True
mock_add_shard.return_value = True
mock_guest.return_value.cluster_complete.return_value = Mock()
self.clustertasks.add_shard_cluster(Mock(), self.cluster_id, "shard-1",
"rs1")
mock_guest.return_value.cluster_complete.assert_called_with()
mock_reset_task.assert_called_with()
def setUp(self):
util.init_db()
self.db_info = FakeDBInstance()
self.status = InstanceServiceStatus(ServiceStatuses.RUNNING)
self.datastore = models.DBDatastore.create(
id=str(uuid.uuid4()),
name='mysql' + str(uuid.uuid4()),
default_version_id=self.db_info.datastore_version_id)
self.version = models.DBDatastoreVersion.create(
id=self.db_info.datastore_version_id,
datastore_id=self.datastore.id,
name='5.7' + str(uuid.uuid4()),
manager='mysql',
image_id=str(uuid.uuid4()),
active=1,
packages="mysql-server-5.7")
super(BaseInstanceStatusTestCase, self).setUp()
def test_tranformer(self):
transformer = mgmtmodels.NotificationTransformer(context=self.context)
status = rd_instance.ServiceStatuses.BUILDING.api_status
db_instance = MockMgmtInstanceTest.build_db_instance(
status, InstanceTasks.BUILDING)
when(DatabaseModelBase).find_all(deleted=False).thenReturn(
[db_instance])
when(DatabaseModelBase).find_by(instance_id='1').thenReturn(
InstanceServiceStatus(rd_instance.ServiceStatuses.BUILDING))
payloads = transformer()
self.assertIsNotNone(payloads)
self.assertThat(len(payloads), Equals(1))
payload = payloads[0]
self.assertThat(payload['audit_period_beginning'], Not(Is(None)))
self.assertThat(payload['audit_period_ending'], Not(Is(None)))
self.assertThat(payload['state'], Equals(status.lower()))
def setUp(self):
util.init_db()
self.datastore = datastore_models.DBDatastore.create(
id=str(uuid.uuid4()),
name='name' + str(uuid.uuid4()),
default_version_id=str(uuid.uuid4()))
self.datastore_version = datastore_models.DBDatastoreVersion.create(
id=self.datastore.default_version_id,
name='name' + str(uuid.uuid4()),
image_id=str(uuid.uuid4()),
packages=str(uuid.uuid4()),
datastore_id=self.datastore.id,
manager='mysql',
active=1)
self.databases = []
self.users = []
self.master = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestMasterInstance",
datastore_version_id=self.datastore_version.id,
flavor_id=str(uuid.uuid4()),
volume_size=2)
self.master.set_task_status(InstanceTasks.NONE)
self.master.save()
self.master_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=self.master.id)
self.master_status.save()
self.safe_nova_client = clients.create_nova_client
clients.create_nova_client = nova.fake_create_nova_client
self.swift_verify_patch = patch.object(models.Backup,
'verify_swift_auth_token')
self.addCleanup(self.swift_verify_patch.stop)
self.swift_verify_patch.start()
super(TestReplication, self).setUp()
def build_db_instance(self, status, task_status=InstanceTasks.NONE):
instance = DBInstance(InstanceTasks.NONE,
name='test_name',
id=str(uuid.uuid4()),
flavor_id='flavor_1',
datastore_version_id=self.version.id,
compute_instance_id='compute_id_1',
server_id='server_id_1',
tenant_id='tenant_id_1',
server_status=rd_instance.ServiceStatuses.
BUILDING.api_status,
deleted=False)
instance.save()
service_status = InstanceServiceStatus(
rd_instance.ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=instance.id,
)
service_status.save()
instance.set_task_status(task_status)
instance.server_status = status
instance.save()
return instance, service_status
def setUp(self):
super(BuiltInstanceTasksTest, self).setUp()
self.new_flavor = {'id': 8, 'ram': 768, 'name': 'bigger_flavor'}
stub_nova_server = MagicMock()
self.rpc_patches = patch.multiple(
rpc, get_notifier=MagicMock(), get_client=MagicMock())
self.rpc_mocks = self.rpc_patches.start()
self.addCleanup(self.rpc_patches.stop)
db_instance = DBInstance(InstanceTasks.NONE,
id=INST_ID,
name='resize-inst-name',
datastore_version_id='1',
datastore_id='id-1',
flavor_id='6',
manager='mysql',
created=datetime.datetime.utcnow(),
updated=datetime.datetime.utcnow(),
compute_instance_id='computeinst-id-1',
tenant_id='testresize-tenant-id',
volume_size='1',
volume_id=VOLUME_ID)
# this is used during the final check of whether the resize successful
db_instance.server_status = 'ACTIVE'
self.db_instance = db_instance
self.dm_dv_load_by_uuid_patch = patch.object(
datastore_models.DatastoreVersion, 'load_by_uuid', MagicMock(
return_value=datastore_models.DatastoreVersion(db_instance)))
self.dm_dv_load_by_uuid_mock = self.dm_dv_load_by_uuid_patch.start()
self.addCleanup(self.dm_dv_load_by_uuid_patch.stop)
self.dm_ds_load_patch = patch.object(
datastore_models.Datastore, 'load', MagicMock(
return_value=datastore_models.Datastore(db_instance)))
self.dm_ds_load_mock = self.dm_ds_load_patch.start()
self.addCleanup(self.dm_ds_load_patch.stop)
self.instance_task = taskmanager_models.BuiltInstanceTasks(
trove.common.context.TroveContext(),
db_instance,
stub_nova_server,
InstanceServiceStatus(ServiceStatuses.RUNNING,
id='inst-stat-id-0'))
self.instance_task._guest = MagicMock(spec=trove.guestagent.api.API)
self.instance_task._nova_client = MagicMock(
spec=novaclient.client)
self.stub_server_mgr = MagicMock(
spec=novaclient.v2.servers.ServerManager)
self.stub_running_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_running_server.status = 'ACTIVE'
self.stub_running_server.flavor = {'id': 6, 'ram': 512}
self.stub_verifying_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_verifying_server.status = 'VERIFY_RESIZE'
self.stub_verifying_server.flavor = {'id': 8, 'ram': 768}
self.stub_server_mgr.get = MagicMock(
return_value=self.stub_verifying_server)
self.instance_task._nova_client.servers = self.stub_server_mgr
stub_flavor_manager = MagicMock(
spec=novaclient.v2.flavors.FlavorManager)
self.instance_task._nova_client.flavors = stub_flavor_manager
nova_flavor = novaclient.v2.flavors.Flavor(stub_flavor_manager,
self.new_flavor,
True)
stub_flavor_manager.get = MagicMock(return_value=nova_flavor)
self.instance_task._volume_client = MagicMock(spec=cinderclient)
self.instance_task._volume_client.volumes = Mock(
spec=cinderclient_volumes.VolumeManager)
answers = (status for status in
self.get_inst_service_status('inst_stat-id',
[ServiceStatuses.SHUTDOWN,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING]))
def side_effect_func(*args, **kwargs):
if 'instance_id' in kwargs:
return next(answers)
elif ('id' in kwargs and 'deleted' in kwargs
and not kwargs['deleted']):
return db_instance
else:
return MagicMock()
self.dbm_dbmb_patch = patch.object(
trove.db.models.DatabaseModelBase, 'find_by',
MagicMock(side_effect=side_effect_func))
self.dbm_dbmb_mock = self.dbm_dbmb_patch.start()
self.addCleanup(self.dbm_dbmb_patch.stop)
self.template_patch = patch.object(
template, 'SingleInstanceConfigTemplate',
MagicMock(spec=template.SingleInstanceConfigTemplate))
self.template_mock = self.template_patch.start()
self.addCleanup(self.template_patch.stop)
db_instance.save = MagicMock(return_value=None)
self.tbmb_running_patch = patch.object(
trove.backup.models.Backup, 'running',
MagicMock(return_value=None))
self.tbmb_running_mock = self.tbmb_running_patch.start()
self.addCleanup(self.tbmb_running_patch.stop)
if 'volume' in self._testMethodName:
self._stub_volume_client()
stub_floating_ips_manager = MagicMock(
spec=novaclient.v2.floating_ips.FloatingIPManager)
self.instance_task._nova_client.floating_ips = (
stub_floating_ips_manager)
floatingip = novaclient.v2.floating_ips.FloatingIP(
stub_floating_ips_manager, {'ip': '192.168.10.1'}, True)
stub_floating_ips_manager.list = MagicMock(return_value=[floatingip])
