def _prepare_dynamic(self,
packages,
config_content='MockContent',
device_path='/dev/vdb',
is_db_installed=True,
backup_id=None,
is_root_enabled=False,
overrides=None):
# covering all outcomes is starting to cause trouble here
if not backup_id:
backup_info = {
'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
mock_status = MagicMock()
mock_app = MagicMock()
mock_app.status = mock_status
self.manager._app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.init_storage_structure = MagicMock(return_value=None)
mock_app.write_config = MagicMock(return_value=None)
mock_app.apply_initial_guestagent_configuration = MagicMock(
return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
with patch.object(pkg.Package,
'pkg_is_installed',
return_value=is_db_installed):
# invocation
self.manager.prepare(context=self.context,
packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048',
users=None,
device_path=device_path,
mount_point="/var/lib/cassandra",
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app.init_storage_structure.assert_any_call('/var/lib/cassandra')
mock_app.apply_initial_guestagent_configuration.assert_any_call()
mock_app.start_db.assert_any_call(update_db=False)
mock_app.stop_db.assert_any_call()
def _prepare_dynamic(self,
device_path='/dev/vdb',
is_db_installed=True,
backup_info=None):
mock_status = MagicMock()
self.manager.appStatus = mock_status
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
couch_service.CouchbaseApp.install_if_needed = MagicMock(
return_value=None)
couch_service.CouchbaseApp.complete_install_or_restart = MagicMock(
return_value=None)
#invocation
self.manager.prepare(self.context,
self.packages,
None,
2048,
None,
device_path=device_path,
mount_point='/var/lib/couchbase',
backup_info=backup_info)
#verification/assertion
mock_status.begin_install.assert_any_call()
couch_service.CouchbaseApp.install_if_needed.assert_any_call(
self.packages)
couch_service.CouchbaseApp.complete_install_or_restart.\
assert_any_call()
def _prepare_dynamic(self, device_path='/dev/vdb', is_db_installed=True,
backup_info=None):
mock_status = MagicMock()
self.manager.appStatus = mock_status
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
couch_service.CouchbaseApp.install_if_needed = MagicMock(
return_value=None)
couch_service.CouchbaseApp.complete_install_or_restart = MagicMock(
return_value=None)
#invocation
self.manager.prepare(self.context, self.packages, None, 2048,
None, device_path=device_path,
mount_point='/var/lib/couchbase',
backup_info=backup_info)
#verification/assertion
mock_status.begin_install.assert_any_call()
couch_service.CouchbaseApp.install_if_needed.assert_any_call(
self.packages)
couch_service.CouchbaseApp.complete_install_or_restart.\
assert_any_call()
def _prepare_dynamic(self, device_path='/dev/vdb', backup_id=None,
*mocks, **kwmocks):
# covering all outcomes is starting to cause trouble here
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'CbBackup',
'checksum': 'fake-checksum'} if backup_id else None
mock_status = MagicMock()
mock_status.begin_install = MagicMock(return_value=None)
self.manager.appStatus = mock_status
instance_ram = 2048
mount_point = '/var/lib/couchbase'
self.manager.prepare(self.context, self.packages, None,
instance_ram, None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
kwmocks['install_if_needed'].assert_any_call(self.packages)
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
mount_point)
def _prepare_dynamic(self, device_path='/dev/vdb', backup_id=None,
*mocks, **kwmocks):
# covering all outcomes is starting to cause trouble here
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'CbBackup',
'checksum': 'fake-checksum'} if backup_id else None
mock_status = MagicMock()
mock_status.begin_install = MagicMock(return_value=None)
self.manager.appStatus = mock_status
instance_ram = 2048
mount_point = '/var/lib/couchbase'
self.manager.prepare(self.context, self.packages, None,
instance_ram, None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
kwmocks['install_if_needed'].assert_any_call(self.packages)
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
mount_point)
def _prepare_dynamic(self, device_path='/dev/vdb', is_redis_installed=True,
backup_info=None, is_root_enabled=False,
mount_point='var/lib/redis'):
# covering all outcomes is starting to cause trouble here
mock_status = MagicMock()
redis_service.RedisAppStatus.get = MagicMock(return_value=mock_status)
redis_service.RedisApp.start_redis = MagicMock(return_value=None)
redis_service.RedisApp.install_if_needed = MagicMock(return_value=None)
redis_service.RedisApp.write_config = MagicMock(return_value=None)
operating_system.update_owner = MagicMock(return_value=None)
redis_service.RedisApp.restart = MagicMock(return_value=None)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
self.manager.prepare(self.context, self.packages,
None, '2048',
None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
self.assertEqual(redis_service.RedisAppStatus.get.call_count, 2)
mock_status.begin_install.assert_any_call()
VolumeDevice.format.assert_any_call()
redis_service.RedisApp.install_if_needed.assert_any_call(self.packages)
redis_service.RedisApp.write_config.assert_any_call(None)
operating_system.update_owner.assert_any_call(
'redis', 'redis', mount_point)
redis_service.RedisApp.restart.assert_any_call()
def _prepare_dynamic(self,
device_path='/dev/vdb',
is_redis_installed=True,
backup_info=None,
is_root_enabled=False,
mount_point='var/lib/redis'):
# covering all outcomes is starting to cause trouble here
mock_status = MagicMock()
redis_service.RedisAppStatus.get = MagicMock(return_value=mock_status)
redis_service.RedisApp.start_redis = MagicMock(return_value=None)
redis_service.RedisApp.install_if_needed = MagicMock(return_value=None)
redis_service.RedisApp.write_config = MagicMock(return_value=None)
redis_service.RedisApp.complete_install_or_restart = MagicMock(
return_value=None)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
backup.restore = MagicMock(return_value=None)
self.manager.prepare(self.context,
self.packages,
None,
'2048',
None,
device_path=device_path,
mount_point='/var/lib/redis',
backup_info=backup_info)
self.assertEqual(redis_service.RedisAppStatus.get.call_count, 2)
mock_status.begin_install.assert_any_call()
VolumeDevice.format.assert_any_call()
redis_service.RedisApp.install_if_needed.assert_any_call(self.packages)
redis_service.RedisApp.write_config.assert_any_call(None)
redis_service.RedisApp.complete_install_or_restart.assert_any_call()
def _prepare_dynamic(self, packages,
config_content='MockContent', device_path='/dev/vdb',
backup_id=None,
overrides=None, is_mounted=False):
# covering all outcomes is starting to cause trouble here
expected_vol_count = 1 if device_path else 0
if not backup_id:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
mock_status = MagicMock()
self.manager.appStatus = mock_status
mock_status.begin_install = MagicMock(return_value=None)
path_exists_function = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
mount_points = []
if is_mounted:
mount_points = ['/mnt']
VolumeDevice.mount_points = MagicMock(return_value=mount_points)
VolumeDevice.unmount = MagicMock(return_value=None)
VerticaApp.install_if_needed = MagicMock(return_value=None)
VerticaApp.install_vertica = MagicMock(return_value=None)
VerticaApp.create_db = MagicMock(return_value=None)
VerticaApp.prepare_for_install_vertica = MagicMock(return_value=None)
VerticaApp.complete_install_or_restart = MagicMock(return_value=None)
# invocation
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048', users=None,
device_path=device_path,
mount_point="/var/lib/vertica",
backup_info=backup_info,
overrides=None,
cluster_config=None,
path_exists_function=path_exists_function)
self.assertEqual(expected_vol_count, VolumeDevice.format.call_count)
self.assertEqual(expected_vol_count,
VolumeDevice.migrate_data.call_count)
self.assertEqual(expected_vol_count,
VolumeDevice.mount_points.call_count)
if is_mounted:
self.assertEqual(1, VolumeDevice.unmount.call_count)
else:
self.assertEqual(0, VolumeDevice.unmount.call_count)
VerticaApp.install_if_needed.assert_any_call(packages)
VerticaApp.prepare_for_install_vertica.assert_any_call()
VerticaApp.install_vertica.assert_any_call()
VerticaApp.create_db.assert_any_call()
VerticaApp.complete_install_or_restart.assert_any_call()
def _prepare_dynamic(self, packages,
config_content='MockContent', device_path='/dev/vdb',
backup_id=None,
overrides=None, is_mounted=False):
# covering all outcomes is starting to cause trouble here
expected_vol_count = 1 if device_path else 0
if not backup_id:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
mock_status = MagicMock()
self.manager.appStatus = mock_status
mock_status.begin_install = MagicMock(return_value=None)
path_exists_function = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
mount_points = []
if is_mounted:
mount_points = ['/mnt']
VolumeDevice.mount_points = MagicMock(return_value=mount_points)
VolumeDevice.unmount = MagicMock(return_value=None)
VerticaApp.install_if_needed = MagicMock(return_value=None)
VerticaApp.install_vertica = MagicMock(return_value=None)
VerticaApp.create_db = MagicMock(return_value=None)
VerticaApp.prepare_for_install_vertica = MagicMock(return_value=None)
VerticaApp.complete_install_or_restart = MagicMock(return_value=None)
# invocation
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048', users=None,
device_path=device_path,
mount_point="/var/lib/vertica",
backup_info=backup_info,
overrides=None,
cluster_config=None,
path_exists_function=path_exists_function)
self.assertEqual(expected_vol_count, VolumeDevice.format.call_count)
self.assertEqual(expected_vol_count,
VolumeDevice.migrate_data.call_count)
self.assertEqual(expected_vol_count,
VolumeDevice.mount_points.call_count)
if is_mounted:
self.assertEqual(1, VolumeDevice.unmount.call_count)
else:
self.assertEqual(0, VolumeDevice.unmount.call_count)
VerticaApp.install_if_needed.assert_any_call(packages)
VerticaApp.prepare_for_install_vertica.assert_any_call()
VerticaApp.install_vertica.assert_any_call()
VerticaApp.create_db.assert_any_call()
VerticaApp.complete_install_or_restart.assert_any_call()
def _prepare_dynamic(self,
packages,
config_content='MockContent',
device_path='/dev/vdb',
is_db_installed=True,
backup_info=None,
is_root_enabled=False,
overrides=None):
mock_status = MagicMock()
mock_app = MagicMock()
mock_app.status = mock_status
self.manager._app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.init_storage_structure = MagicMock(return_value=None)
mock_app.write_config = MagicMock(return_value=None)
mock_app.apply_initial_guestagent_configuration = MagicMock(
return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
mock_app._remove_system_tables = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
with patch.object(pkg.Package,
'pkg_is_installed',
return_value=is_db_installed):
# invocation
self.manager.prepare(context=self.context,
packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048',
users=None,
device_path=device_path,
mount_point=self.__MOUNT_POINT,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app._remove_system_tables.assert_any_call()
mock_app.init_storage_structure.assert_any_call('/var/lib/cassandra')
mock_app.apply_initial_guestagent_configuration.assert_any_call(
cluster_name=None)
mock_app.start_db.assert_any_call(update_db=False)
mock_app.stop_db.assert_any_call()
if backup_info:
mock_app._apply_post_restore_updates.assert_called_once_with(
backup_info)
def _prepare_dynamic(self, save_configuration_mock, chown_mock,
apply_initial_guestagent_configuration, restart,
install_if_needed,
device_path='/dev/vdb', is_redis_installed=True,
backup_info=None, is_root_enabled=False,
mount_point='var/lib/redis', backup_id=None,
snapshot=None):
backup_info = None
if backup_id is not None:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'RedisBackup',
'checksum': 'fake-checksum',
}
# covering all outcomes is starting to cause trouble here
mock_status = MagicMock()
self.manager._app.status = mock_status
self.manager._build_admin_client = MagicMock(return_value=MagicMock())
redis_service.RedisApp.stop_db = MagicMock(return_value=None)
redis_service.RedisApp.start_db = MagicMock(return_value=None)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
mock_replication = MagicMock()
mock_replication.enable_as_slave = MagicMock()
self.mock_repl.return_value = mock_replication
self.manager.prepare(self.context, self.packages,
None, '2048',
None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None,
snapshot=snapshot)
mock_status.begin_install.assert_any_call()
VolumeDevice.format.assert_any_call()
install_if_needed.assert_any_call(self.packages)
save_configuration_mock.assert_any_call(None)
apply_initial_guestagent_configuration.assert_called_once_with()
chown_mock.assert_any_call(mount_point, 'redis', 'redis', as_root=True)
if backup_info:
backup.restore.assert_called_once_with(self.context,
backup_info,
'/var/lib/redis')
else:
redis_service.RedisApp.restart.assert_any_call()
if snapshot:
self.assertEqual(1, mock_replication.enable_as_slave.call_count)
else:
self.assertEqual(0, mock_replication.enable_as_slave.call_count)
def _prepare_dynamic(self, save_configuration_mock, chown_mock,
apply_initial_guestagent_configuration, restart,
install_if_needed,
device_path='/dev/vdb', is_redis_installed=True,
backup_info=None, is_root_enabled=False,
mount_point='var/lib/redis', backup_id=None,
snapshot=None):
backup_info = None
if backup_id is not None:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'RedisBackup',
'checksum': 'fake-checksum',
}
# covering all outcomes is starting to cause trouble here
mock_status = MagicMock()
self.manager._app.status = mock_status
self.manager._build_admin_client = MagicMock(return_value=MagicMock())
redis_service.RedisApp.stop_db = MagicMock(return_value=None)
redis_service.RedisApp.start_db = MagicMock(return_value=None)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
mock_replication = MagicMock()
mock_replication.enable_as_slave = MagicMock()
self.mock_repl.return_value = mock_replication
self.manager.prepare(self.context, self.packages,
None, '2048',
None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None,
snapshot=snapshot)
mock_status.begin_install.assert_any_call()
VolumeDevice.format.assert_any_call()
install_if_needed.assert_any_call(self.packages)
save_configuration_mock.assert_any_call(None)
apply_initial_guestagent_configuration.assert_called_once_with()
chown_mock.assert_any_call(mount_point, 'redis', 'redis', as_root=True)
if backup_info:
backup.restore.assert_called_once_with(self.context,
backup_info,
'/var/lib/redis')
else:
redis_service.RedisApp.restart.assert_any_call()
if snapshot:
self.assertEqual(1, mock_replication.enable_as_slave.call_count)
else:
self.assertEqual(0, mock_replication.enable_as_slave.call_count)
def _prepare_dynamic(self, packages=None, databases=None, users=None,
config_content=None, device_path='/dev/vdb',
is_db_installed=True, backup_id=None, overrides=None):
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'DB2Backup',
'checksum': 'fake-checksum'} if backup_id else None
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.change_ownership = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
db2_service.DB2Admin.create_user = MagicMock(return_value=None)
db2_service.DB2Admin.create_database = MagicMock(return_value=None)
backup.restore = MagicMock(return_value=None)
with patch.object(pkg.Package, 'pkg_is_installed',
return_value=MagicMock(
return_value=is_db_installed)):
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=databases,
memory_mb='2048', users=users,
device_path=device_path,
mount_point="/home/db2inst1/db2inst1",
backup_info=backup_info,
overrides=None,
cluster_config=None)
mock_status.begin_install.assert_any_call()
self.assertEqual(1, mock_app.change_ownership.call_count)
if databases:
self.assertTrue(db2_service.DB2Admin.create_database.called)
else:
self.assertFalse(db2_service.DB2Admin.create_database.called)
if users:
self.assertTrue(db2_service.DB2Admin.create_user.called)
else:
self.assertFalse(db2_service.DB2Admin.create_user.called)
if backup_id:
backup.restore.assert_any_call(self.context,
backup_info,
'/home/db2inst1/db2inst1')
def _prepare_dynamic(self,
device_path='/dev/vdb',
backup_id=None,
*mocks,
**kwmocks):
# covering all outcomes is starting to cause trouble here
backup_info = {
'id': backup_id,
'location': 'fake-location',
'type': 'CbBackup',
'checksum': 'fake-checksum'
} if backup_id else None
mock_status = MagicMock()
mock_status.begin_install = MagicMock(return_value=None)
self.manager.app.status = mock_status
instance_ram = 2048
mount_point = '/var/lib/couchbase'
with patch.object(couch_service.CouchbaseApp,
'available_ram_mb',
new_callable=PropertyMock) as available_ram_mock:
available_ram_mock.return_value = instance_ram
self.manager.prepare(self.context,
self.packages,
None,
instance_ram,
None,
device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
storage_mock = kwmocks['init_storage_structure']
init_mock = kwmocks['initialize_node']
init_mock.assert_called_once_with()
storage_mock.assert_called_once_with(mount_point)
kwmocks['install_if_needed'].assert_any_call(self.packages)
if backup_info:
backup.restore.assert_called_once_with(self.context, backup_info,
mount_point)
kwmocks['apply_post_restore_updates'].assert_called_once_with(
backup_info)
kwmocks['secure'].assert_called_once_with(initialize=True,
password=None)
def _prepare_dynamic(self, packages=None, databases=None,
config_content=None, device_path='/dev/vdb',
is_db_installed=True, backup_id=None,
overrides=None):
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mount_point = '/var/lib/couchdb'
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.make_host_reachable = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'CouchDBBackup',
'checksum': 'fake-checksum'} if backup_id else None
couchdb_service.CouchDBAdmin.create_database = MagicMock(
return_value=None)
couchdb_service.CouchDBAdmin.create_user = MagicMock(return_value=None)
with patch.object(pkg.Package, 'pkg_is_installed',
return_value=MagicMock(
return_value=is_db_installed)):
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=databases,
memory_mb='2048', users=None,
device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app.make_host_reachable.assert_any_call()
mock_app.change_permissions.assert_any_call()
if backup_id:
backup.restore.assert_any_call(self.context,
backup_info,
mount_point)
def _prepare_dynamic(self, packages,
config_content='MockContent', device_path='/dev/vdb',
is_db_installed=True, backup_id=None,
is_root_enabled=False,
overrides=None):
# covering all outcomes is starting to cause trouble here
if not backup_id:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
mock_status = MagicMock()
mock_app = MagicMock()
mock_app.status = mock_status
self.manager._app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.init_storage_structure = MagicMock(return_value=None)
mock_app.write_config = MagicMock(return_value=None)
mock_app.apply_initial_guestagent_configuration = MagicMock(
return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
with patch.object(pkg.Package, 'pkg_is_installed',
return_value=is_db_installed):
# invocation
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048', users=None,
device_path=device_path,
mount_point="/var/lib/cassandra",
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app.init_storage_structure.assert_any_call('/var/lib/cassandra')
mock_app.apply_initial_guestagent_configuration.assert_any_call()
mock_app.start_db.assert_any_call(update_db=False)
mock_app.stop_db.assert_any_call()
def _prepare_dynamic(self, packages=None, databases=None,
config_content=None, device_path='/dev/vdb',
is_db_installed=True, backup_id=None,
overrides=None):
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mount_point = '/var/lib/couchdb'
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.make_host_reachable = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'CouchDBBackup',
'checksum': 'fake-checksum'} if backup_id else None
couchdb_service.CouchDBAdmin.create_database = MagicMock(
return_value=None)
couchdb_service.CouchDBAdmin.create_user = MagicMock(return_value=None)
with patch.object(pkg.Package, 'pkg_is_installed',
return_value=MagicMock(
return_value=is_db_installed)):
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=databases,
memory_mb='2048', users=None,
device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app.make_host_reachable.assert_any_call()
mock_app.change_permissions.assert_any_call()
if backup_id:
backup.restore.assert_any_call(self.context,
backup_info,
mount_point)
def _prepare_dynamic(
self,
packages=None,
databases=None,
users=None,
config_content=None,
device_path="/dev/vdb",
is_db_installed=True,
backup_id=None,
overrides=None,
):
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.change_ownership = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
db2_service.DB2Admin.create_user = MagicMock(return_value=None)
db2_service.DB2Admin.create_database = MagicMock(return_value=None)
with patch.object(pkg.Package, "pkg_is_installed", return_value=MagicMock(return_value=is_db_installed)):
self.manager.prepare(
context=self.context,
packages=packages,
config_contents=config_content,
databases=databases,
memory_mb="2048",
users=users,
device_path=device_path,
mount_point="/home/db2inst1/db2inst1",
backup_info=None,
overrides=None,
cluster_config=None,
)
mock_status.begin_install.assert_any_call()
self.assertEqual(1, mock_app.change_ownership.call_count)
if databases:
self.assertTrue(db2_service.DB2Admin.create_database.called)
else:
self.assertFalse(db2_service.DB2Admin.create_database.called)
if users:
self.assertTrue(db2_service.DB2Admin.create_user.called)
else:
self.assertFalse(db2_service.DB2Admin.create_user.called)
def _prepare_dynamic(self, packages,
config_content='MockContent', device_path='/dev/vdb',
is_db_installed=True, backup_info=None,
is_root_enabled=False,
overrides=None):
mock_status = MagicMock()
mock_app = MagicMock()
mock_app.status = mock_status
self.manager._app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.init_storage_structure = MagicMock(return_value=None)
mock_app.write_config = MagicMock(return_value=None)
mock_app.apply_initial_guestagent_configuration = MagicMock(
return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
mock_app._remove_system_tables = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
with patch.object(pkg.Package, 'pkg_is_installed',
return_value=is_db_installed):
# invocation
self.manager.prepare(context=self.context, packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048', users=None,
device_path=device_path,
mount_point=self.__MOUNT_POINT,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app._remove_system_tables.assert_any_call()
mock_app.init_storage_structure.assert_any_call('/var/lib/cassandra')
mock_app.apply_initial_guestagent_configuration.assert_any_call(
cluster_name=None)
mock_app.start_db.assert_any_call(update_db=False)
mock_app.stop_db.assert_any_call()
if backup_info:
mock_app._apply_post_restore_updates.assert_called_once_with(
backup_info)
def _prepare_dynamic(self,
device_path='/dev/vdb',
is_db_installed=True,
backup_id=None):
# covering all outcomes is starting to cause trouble here
backup_info = {
'id': backup_id,
'location': 'fake-location',
'type': 'MongoDump',
'checksum': 'fake-checksum'
} if backup_id else None
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.status = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.clear_storage = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=is_db_installed)
with patch.object(utils, 'execute_with_timeout'):
# invocation
self.manager.prepare(context=self.context,
databases=None,
packages=['package'],
memory_mb='2048',
users=None,
device_path=device_path,
mount_point='/var/lib/mongodb',
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(['package'])
mock_app.stop_db.assert_any_call()
VolumeDevice.format.assert_any_call()
VolumeDevice.migrate_data.assert_any_call('/var/lib/mongodb')
if backup_info:
backup.restore.assert_any_call(self.context, backup_info,
'/var/lib/mongodb')
def _prepare_dynamic(self,
packages=None,
databases=None,
users=None,
config_content=None,
device_path='/dev/vdb',
is_db_installed=True,
backup_id=None,
overrides=None):
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.change_ownership = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
db2_service.DB2Admin.create_user = MagicMock(return_value=None)
db2_service.DB2Admin.create_database = MagicMock(return_value=None)
with patch.object(
pkg.Package,
'pkg_is_installed',
return_value=MagicMock(return_value=is_db_installed)):
self.manager.prepare(context=self.context,
packages=packages,
config_contents=config_content,
databases=databases,
memory_mb='2048',
users=users,
device_path=device_path,
mount_point="/home/db2inst1/db2inst1",
backup_info=None,
overrides=None,
cluster_config=None)
mock_status.begin_install.assert_any_call()
self.assertEqual(1, mock_app.change_ownership.call_count)
if databases:
self.assertTrue(db2_service.DB2Admin.create_database.called)
else:
self.assertFalse(db2_service.DB2Admin.create_database.called)
if users:
self.assertTrue(db2_service.DB2Admin.create_user.called)
else:
self.assertFalse(db2_service.DB2Admin.create_user.called)
def _prepare_dynamic(self, device_path="/dev/vdb", is_db_installed=True, backup_id=None):
# covering all outcomes is starting to cause trouble here
backup_info = (
{"id": backup_id, "location": "fake-location", "type": "MongoDump", "checksum": "fake-checksum"}
if backup_id
else None
)
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.status = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.clear_storage = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=is_db_installed)
with patch.object(utils, "execute_with_timeout"):
# invocation
self.manager.prepare(
context=self.context,
databases=None,
packages=["package"],
memory_mb="2048",
users=None,
device_path=device_path,
mount_point="/var/lib/mongodb",
backup_info=backup_info,
overrides=None,
cluster_config=None,
)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(["package"])
mock_app.stop_db.assert_any_call()
VolumeDevice.format.assert_any_call()
VolumeDevice.migrate_data.assert_any_call("/var/lib/mongodb")
if backup_info:
backup.restore.assert_any_call(self.context, backup_info, "/var/lib/mongodb")
def _prepare_dynamic(
self,
packages,
config_content=None,
device_path="/dev/vdb",
is_db_installed=True,
backup_id=None,
overrides=None,
):
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.make_host_reachable = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
with patch.object(pkg.Package, "pkg_is_installed", return_value=MagicMock(return_value=is_db_installed)):
self.manager.prepare(
context=self.context,
packages=packages,
config_contents=config_content,
databases=None,
memory_mb="2048",
users=None,
device_path=device_path,
mount_point="/var/lib/couchdb",
backup_info=None,
overrides=None,
cluster_config=None,
)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app.make_host_reachable.assert_any_call()
mock_app.change_permissions.assert_any_call()
def _prepare_dynamic(self, device_path='/dev/vdb', backup_id=None):
# covering all outcomes is starting to cause trouble here
backup_info = {
'id': backup_id,
'location': 'fake-location',
'type': 'CbBackup',
'checksum': 'fake-checksum'
} if backup_id else None
mock_status = MagicMock()
self.manager.appStatus = mock_status
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
couch_service.CouchbaseApp.install_if_needed = MagicMock(
return_value=None)
couch_service.CouchbaseApp.start_db_with_conf_changes = MagicMock(
return_value=None)
couch_service.CouchbaseApp.initial_setup = MagicMock(return_value=None)
couch_service.CouchbaseApp.complete_install_or_restart = MagicMock(
return_value=None)
backup.restore = MagicMock(return_value=None)
#invocation
self.manager.prepare(self.context,
self.packages,
None,
2048,
None,
device_path=device_path,
mount_point='/var/lib/couchbase',
backup_info=backup_info,
overrides=None,
cluster_config=None)
#verification/assertion
mock_status.begin_install.assert_any_call()
couch_service.CouchbaseApp.install_if_needed.assert_any_call(
self.packages)
couch_service.CouchbaseApp.complete_install_or_restart.\
assert_any_call()
if backup_info:
backup.restore.assert_any_call(self.context, backup_info,
'/var/lib/couchbase')
def _prepare_dynamic(self,
packages,
config_content=None,
device_path='/dev/vdb',
is_db_installed=True,
backup_id=None,
overrides=None):
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.appStatus = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
mock_app.install_if_needed = MagicMock(return_value=None)
mock_app.make_host_reachable = MagicMock(return_value=None)
mock_app.restart = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
with patch.object(
pkg.Package,
'pkg_is_installed',
return_value=MagicMock(return_value=is_db_installed)):
self.manager.prepare(context=self.context,
packages=packages,
config_contents=config_content,
databases=None,
memory_mb='2048',
users=None,
device_path=device_path,
mount_point="/var/lib/couchdb",
backup_info=None,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(packages)
mock_app.make_host_reachable.assert_any_call()
mock_app.change_permissions.assert_any_call()
def _prepare_dynamic(self, device_path='/dev/vdb', is_db_installed=True,
backup_id=None):
# covering all outcomes is starting to cause trouble here
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'MongoDump',
'checksum': 'fake-checksum'} if backup_id else None
mock_status = MagicMock()
mock_app = MagicMock()
self.manager.status = mock_status
self.manager.app = mock_app
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.migrate_data = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
mock_app.stop_db = MagicMock(return_value=None)
mock_app.start_db = MagicMock(return_value=None)
mock_app.clear_storage = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=is_db_installed)
self.manager.prepare(context=self.context, databases=None,
packages=['package'],
memory_mb='2048', users=None,
device_path=device_path,
mount_point='/var/lib/mongodb',
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
mock_app.install_if_needed.assert_any_call(['package'])
mock_app.stop_db.assert_any_call()
VolumeDevice.format.assert_any_call()
VolumeDevice.migrate_data.assert_any_call('/var/lib/mongodb')
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
'/var/lib/mongodb')
def _prepare_dynamic(self, device_path='/dev/vdb', backup_id=None,
*mocks, **kwmocks):
# covering all outcomes is starting to cause trouble here
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'CbBackup',
'checksum': 'fake-checksum'} if backup_id else None
mock_status = MagicMock()
mock_status.begin_install = MagicMock(return_value=None)
self.manager.app.status = mock_status
instance_ram = 2048
mount_point = '/var/lib/couchbase'
with patch.object(couch_service.CouchbaseApp, 'available_ram_mb',
new_callable=PropertyMock) as available_ram_mock:
available_ram_mock.return_value = instance_ram
self.manager.prepare(self.context, self.packages, None,
instance_ram, None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
storage_mock = kwmocks['init_storage_structure']
init_mock = kwmocks['initialize_node']
init_mock.assert_called_once_with()
storage_mock.assert_called_once_with(mount_point)
kwmocks['install_if_needed'].assert_any_call(self.packages)
if backup_info:
backup.restore.assert_called_once_with(self.context,
backup_info,
mount_point)
kwmocks['apply_post_restore_updates'].assert_called_once_with(
backup_info)
kwmocks['secure'].assert_called_once_with(initialize=True,
password=None)
def _prepare_dynamic(self, device_path='/dev/vdb', backup_id=None):
# covering all outcomes is starting to cause trouble here
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'CbBackup',
'checksum': 'fake-checksum'} if backup_id else None
mock_status = MagicMock()
self.manager.appStatus = mock_status
mock_status.begin_install = MagicMock(return_value=None)
volume.VolumeDevice.format = MagicMock(return_value=None)
volume.VolumeDevice.mount = MagicMock(return_value=None)
volume.VolumeDevice.mount_points = MagicMock(return_value=[])
couch_service.CouchbaseApp.install_if_needed = MagicMock(
return_value=None)
couch_service.CouchbaseApp.start_db_with_conf_changes = MagicMock(
return_value=None)
couch_service.CouchbaseApp.initial_setup = MagicMock(
return_value=None)
couch_service.CouchbaseApp.complete_install_or_restart = MagicMock(
return_value=None)
backup.restore = MagicMock(return_value=None)
#invocation
self.manager.prepare(self.context, self.packages, None, 2048,
None, device_path=device_path,
mount_point='/var/lib/couchbase',
backup_info=backup_info,
overrides=None,
cluster_config=None)
#verification/assertion
mock_status.begin_install.assert_any_call()
couch_service.CouchbaseApp.install_if_needed.assert_any_call(
self.packages)
couch_service.CouchbaseApp.complete_install_or_restart.\
assert_any_call()
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
'/var/lib/couchbase')
def _prepare_dynamic(self, save_configuration_mock,
apply_initial_guestagent_configuration,
device_path='/dev/vdb', is_redis_installed=True,
backup_info=None, is_root_enabled=False,
mount_point='var/lib/redis'):
# covering all outcomes is starting to cause trouble here
mock_status = MagicMock()
self.manager._app.status = mock_status
self.manager._build_admin_client = MagicMock(return_value=MagicMock())
redis_service.RedisApp.start_redis = MagicMock(return_value=None)
redis_service.RedisApp.install_if_needed = MagicMock(return_value=None)
operating_system.chown = MagicMock(return_value=None)
redis_service.RedisApp.restart = MagicMock(return_value=None)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
VolumeDevice.mount_points = MagicMock(return_value=[])
backup.restore = MagicMock(return_value=None)
self.manager.prepare(self.context, self.packages,
None, '2048',
None, device_path=device_path,
mount_point=mount_point,
backup_info=backup_info,
overrides=None,
cluster_config=None)
mock_status.begin_install.assert_any_call()
VolumeDevice.format.assert_any_call()
redis_service.RedisApp.install_if_needed.assert_any_call(self.packages)
save_configuration_mock.assert_any_call(None)
apply_initial_guestagent_configuration.assert_called_once_with()
operating_system.chown.assert_any_call(
mount_point, 'redis', 'redis', as_root=True)
redis_service.RedisApp.restart.assert_any_call()
def _prepare_dynamic(self, device_path='/dev/vdb', is_mysql_installed=True,
backup_id=None, is_root_enabled=False,
overrides=None, is_mounted=False):
# covering all outcomes is starting to cause trouble here
COUNT = 1 if device_path else 0
backup_info = None
if backup_id is not None:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
# TODO(juice): this should stub an instance of the MySqlAppStatus
mock_status = MagicMock()
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.migrate_data = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
mount_points = []
if is_mounted:
mount_points = ['/mnt']
VolumeDevice.mount_points = MagicMock(return_value=mount_points)
VolumeDevice.unmount = MagicMock(return_value=None)
dbaas.MySqlApp.stop_db = MagicMock(return_value=None)
dbaas.MySqlApp.start_mysql = MagicMock(return_value=None)
dbaas.MySqlApp.install_if_needed = MagicMock(return_value=None)
backup.restore = MagicMock(return_value=None)
dbaas.MySqlApp.secure = MagicMock(return_value=None)
dbaas.MySqlApp.secure_root = MagicMock(return_value=None)
pkg.Package.pkg_is_installed = MagicMock(
return_value=is_mysql_installed)
dbaas.MySqlAdmin.is_root_enabled = MagicMock(
return_value=is_root_enabled)
dbaas.MySqlAdmin.create_user = MagicMock(return_value=None)
dbaas.MySqlAdmin.create_database = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
# invocation
self.manager.prepare(context=self.context,
packages=None,
memory_mb='2048',
databases=None,
users=None,
device_path=device_path,
mount_point='/var/lib/mysql',
backup_info=backup_info,
overrides=overrides,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
self.assertEqual(VolumeDevice.format.call_count, COUNT)
self.assertEqual(VolumeDevice.migrate_data.call_count, COUNT)
self.assertEqual(VolumeDevice.mount_points.call_count, COUNT)
self.assertEqual(dbaas.MySqlApp.stop_db.call_count, COUNT)
if is_mounted:
self.assertEqual(VolumeDevice.unmount.call_count, 1)
else:
self.assertEqual(VolumeDevice.unmount.call_count, 0)
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
'/var/lib/mysql')
dbaas.MySqlApp.install_if_needed.assert_any_call(None)
# We don't need to make sure the exact contents are there
dbaas.MySqlApp.secure.assert_any_call(None, None)
self.assertFalse(dbaas.MySqlAdmin.create_database.called)
self.assertFalse(dbaas.MySqlAdmin.create_user.called)
dbaas.MySqlApp.secure_root.assert_any_call(
secure_remote_root=not is_root_enabled)
def _prepare_dynamic(self,
restore_mock,
create_user,
create_database,
enable_root,
device_path='/dev/vdb',
is_mysql_installed=True,
backup_id=None,
is_root_enabled=False,
root_password=None,
overrides=None,
is_mounted=False,
databases=None,
users=None,
snapshot=None):
# covering all outcomes is starting to cause trouble here
COUNT = 1 if device_path else 0
backup_info = None
if backup_id is not None:
backup_info = {
'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
# TODO(juice): this should stub an instance of the MySqlAppStatus
mock_status = MagicMock()
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.migrate_data = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
mount_points = []
if is_mounted:
mount_points = ['/mnt']
VolumeDevice.mount_points = MagicMock(return_value=mount_points)
VolumeDevice.unmount = MagicMock(return_value=None)
set_data_dir_patcher = patch.object(dbaas.MySqlApp,
'set_data_dir',
return_value='/var/lib/mysql')
self.addCleanup(set_data_dir_patcher.stop)
set_data_dir_patcher.start()
dbaas.MySqlApp.stop_db = MagicMock(return_value=None)
dbaas.MySqlApp.start_mysql = MagicMock(return_value=None)
dbaas.MySqlApp.update_overrides = MagicMock(return_value=None)
dbaas.MySqlApp.install_if_needed = MagicMock(return_value=None)
dbaas.MySqlApp.secure = MagicMock(return_value=None)
dbaas.MySqlApp.secure_root = MagicMock(return_value=None)
pkg.Package.pkg_is_installed = MagicMock(
return_value=is_mysql_installed)
operating_system.chown = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
mock_replication = MagicMock()
mock_replication.enable_as_slave = MagicMock()
self.mock_rs_class.return_value = mock_replication
with patch.object(dbaas.MySqlAdmin,
'is_root_enabled',
return_value=is_root_enabled):
self.manager.prepare(context=self.context,
packages=None,
memory_mb='2048',
databases=databases,
users=users,
device_path=device_path,
mount_point='/var/lib/mysql',
backup_info=backup_info,
root_password=root_password,
overrides=overrides,
cluster_config=None,
snapshot=snapshot)
# verification/assertion
mock_status.begin_install.assert_any_call()
self.assertEqual(COUNT, VolumeDevice.format.call_count)
self.assertEqual(COUNT, VolumeDevice.migrate_data.call_count)
self.assertEqual(COUNT, VolumeDevice.mount_points.call_count)
self.assertEqual(COUNT, dbaas.MySqlApp.stop_db.call_count)
if is_mounted:
self.assertEqual(1, VolumeDevice.unmount.call_count)
else:
self.assertEqual(0, VolumeDevice.unmount.call_count)
if backup_info:
restore_mock.assert_any_call(self.context, backup_info,
'/var/lib/mysql/data')
dbaas.MySqlApp.install_if_needed.assert_any_call(None)
# We don't need to make sure the exact contents are there
dbaas.MySqlApp.secure.assert_any_call(None)
dbaas.MySqlApp.secure_root.assert_any_call(
secure_remote_root=not is_root_enabled)
if root_password:
dbaas.MySqlAdmin.enable_root.assert_any_call(root_password)
if databases:
dbaas.MySqlAdmin.create_database.assert_any_call(databases)
else:
self.assertFalse(dbaas.MySqlAdmin.create_database.called)
if users:
dbaas.MySqlAdmin.create_user.assert_any_call(users)
else:
self.assertFalse(dbaas.MySqlAdmin.create_user.called)
if snapshot:
self.assertEqual(1, mock_replication.enable_as_slave.call_count)
else:
self.assertEqual(0, mock_replication.enable_as_slave.call_count)
def _prepare_dynamic(self, device_path='/dev/vdb', is_mysql_installed=True,
backup_id=None, is_root_enabled=False,
overrides=None, is_mounted=False):
# covering all outcomes is starting to cause trouble here
COUNT = 1 if device_path else 0
backup_info = None
if backup_id is not None:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
# TODO(juice): this should stub an instance of the MySqlAppStatus
mock_status = MagicMock()
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.migrate_data = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
mount_points = []
if is_mounted:
mount_points = ['/mnt']
VolumeDevice.mount_points = MagicMock(return_value=mount_points)
VolumeDevice.unmount = MagicMock(return_value=None)
dbaas.MySqlApp.stop_db = MagicMock(return_value=None)
dbaas.MySqlApp.start_mysql = MagicMock(return_value=None)
dbaas.MySqlApp.install_if_needed = MagicMock(return_value=None)
backup.restore = MagicMock(return_value=None)
dbaas.MySqlApp.secure = MagicMock(return_value=None)
dbaas.MySqlApp.secure_root = MagicMock(return_value=None)
pkg.Package.pkg_is_installed = MagicMock(
return_value=is_mysql_installed)
dbaas.MySqlAdmin.is_root_enabled = MagicMock(
return_value=is_root_enabled)
dbaas.MySqlAdmin.create_user = MagicMock(return_value=None)
dbaas.MySqlAdmin.create_database = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
# invocation
self.manager.prepare(context=self.context,
packages=None,
memory_mb='2048',
databases=None,
users=None,
device_path=device_path,
mount_point='/var/lib/mysql',
backup_info=backup_info,
overrides=overrides,
cluster_config=None)
# verification/assertion
mock_status.begin_install.assert_any_call()
self.assertEqual(VolumeDevice.format.call_count, COUNT)
self.assertEqual(VolumeDevice.migrate_data.call_count, COUNT)
self.assertEqual(VolumeDevice.mount_points.call_count, COUNT)
self.assertEqual(dbaas.MySqlApp.stop_db.call_count, COUNT)
if is_mounted:
self.assertEqual(VolumeDevice.unmount.call_count, 1)
else:
self.assertEqual(VolumeDevice.unmount.call_count, 0)
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
'/var/lib/mysql')
dbaas.MySqlApp.install_if_needed.assert_any_call(None)
# We don't need to make sure the exact contents are there
dbaas.MySqlApp.secure.assert_any_call(None, None)
self.assertFalse(dbaas.MySqlAdmin.create_database.called)
self.assertFalse(dbaas.MySqlAdmin.create_user.called)
dbaas.MySqlApp.secure_root.assert_any_call(
secure_remote_root=not is_root_enabled)
def _prepare_dynamic(self, device_path='/dev/vdb', is_mysql_installed=True,
backup_id=None, is_root_enabled=False,
root_password=None, overrides=None, is_mounted=False,
databases=None, users=None, snapshot=None):
# covering all outcomes is starting to cause trouble here
COUNT = 1 if device_path else 0
backup_info = None
if backup_id is not None:
backup_info = {'id': backup_id,
'location': 'fake-location',
'type': 'InnoBackupEx',
'checksum': 'fake-checksum',
}
# TODO(juice): this should stub an instance of the MySqlAppStatus
mock_status = MagicMock()
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
mock_status.begin_install = MagicMock(return_value=None)
VolumeDevice.format = MagicMock(return_value=None)
VolumeDevice.migrate_data = MagicMock(return_value=None)
VolumeDevice.mount = MagicMock(return_value=None)
mount_points = []
if is_mounted:
mount_points = ['/mnt']
VolumeDevice.mount_points = MagicMock(return_value=mount_points)
VolumeDevice.unmount = MagicMock(return_value=None)
set_data_dir_patcher = patch.object(dbaas.MySqlApp, 'set_data_dir',
return_value='/var/lib/mysql')
self.addCleanup(set_data_dir_patcher.stop)
set_data_dir_patcher.start()
dbaas.MySqlApp.stop_db = MagicMock(return_value=None)
dbaas.MySqlApp.start_mysql = MagicMock(return_value=None)
dbaas.MySqlApp.update_overrides = MagicMock(return_value=None)
dbaas.MySqlApp.install_if_needed = MagicMock(return_value=None)
backup.restore = MagicMock(return_value=None)
dbaas.MySqlApp.secure = MagicMock(return_value=None)
dbaas.MySqlApp.secure_root = MagicMock(return_value=None)
pkg.Package.pkg_is_installed = MagicMock(
return_value=is_mysql_installed)
dbaas.MySqlAdmin.is_root_enabled = MagicMock(
return_value=is_root_enabled)
dbaas.MySqlAdmin.create_user = MagicMock(return_value=None)
dbaas.MySqlAdmin.create_database = MagicMock(return_value=None)
dbaas.MySqlAdmin.enable_root = MagicMock(return_value=None)
operating_system.chown = MagicMock(return_value=None)
os.path.exists = MagicMock(return_value=True)
mock_replication = MagicMock()
mock_replication.enable_as_slave = MagicMock()
self.mock_rs_class.return_value = mock_replication
# invocation
self.manager.prepare(context=self.context,
packages=None,
memory_mb='2048',
databases=databases,
users=users,
device_path=device_path,
mount_point='/var/lib/mysql',
backup_info=backup_info,
root_password=root_password,
overrides=overrides,
cluster_config=None,
snapshot=snapshot)
# verification/assertion
mock_status.begin_install.assert_any_call()
self.assertEqual(COUNT, VolumeDevice.format.call_count)
self.assertEqual(COUNT, VolumeDevice.migrate_data.call_count)
self.assertEqual(COUNT, VolumeDevice.mount_points.call_count)
self.assertEqual(COUNT, dbaas.MySqlApp.stop_db.call_count)
if is_mounted:
self.assertEqual(1, VolumeDevice.unmount.call_count)
else:
self.assertEqual(0, VolumeDevice.unmount.call_count)
if backup_info:
backup.restore.assert_any_call(self.context,
backup_info,
'/var/lib/mysql/data')
dbaas.MySqlApp.install_if_needed.assert_any_call(None)
# We don't need to make sure the exact contents are there
dbaas.MySqlApp.secure.assert_any_call(None, None)
dbaas.MySqlApp.secure_root.assert_any_call(
secure_remote_root=not is_root_enabled)
if root_password:
dbaas.MySqlAdmin.enable_root.assert_any_call(root_password)
if databases:
dbaas.MySqlAdmin.create_database.assert_any_call(databases)
else:
self.assertFalse(dbaas.MySqlAdmin.create_database.called)
if users:
dbaas.MySqlAdmin.create_user.assert_any_call(users)
else:
self.assertFalse(dbaas.MySqlAdmin.create_user.called)
if snapshot:
self.assertEqual(1, mock_replication.enable_as_slave.call_count)
else:
self.assertEqual(0, mock_replication.enable_as_slave.call_count)