687 lines
30 KiB
Python
687 lines
30 KiB
Python
# Copyright 2012 OpenStack Foundation
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import os
|
|
|
|
from mock import MagicMock
|
|
from mock import patch
|
|
from proboscis.asserts import assert_equal
|
|
import testtools
|
|
from testtools.matchers import Is, Equals, Not
|
|
|
|
from trove.common.context import TroveContext
|
|
from trove.common.exception import InsufficientSpaceForReplica
|
|
from trove.common.exception import ProcessExecutionError
|
|
from trove.common import instance as rd_instance
|
|
from trove.guestagent import backup
|
|
from trove.guestagent.common import operating_system
|
|
# TODO(atomic77) The test cases should be made configurable
|
|
# to make it easier to test the various derived datastores.
|
|
from trove.guestagent.datastore.mysql.manager import Manager
|
|
import trove.guestagent.datastore.mysql.service as dbaas
|
|
from trove.guestagent import dbaas as base_dbaas
|
|
from trove.guestagent import pkg as pkg
|
|
from trove.guestagent import volume
|
|
from trove.guestagent.volume import VolumeDevice
|
|
|
|
|
|
class GuestAgentManagerTest(testtools.TestCase):
|
|
def setUp(self):
|
|
super(GuestAgentManagerTest, self).setUp()
|
|
self.context = TroveContext()
|
|
self.manager = Manager()
|
|
self.origin_MySqlAppStatus = dbaas.MySqlAppStatus
|
|
self.origin_os_path_exists = os.path.exists
|
|
self.origin_format = volume.VolumeDevice.format
|
|
self.origin_migrate_data = volume.VolumeDevice.migrate_data
|
|
self.origin_mount = volume.VolumeDevice.mount
|
|
self.origin_unmount = volume.VolumeDevice.unmount
|
|
self.origin_mount_points = volume.VolumeDevice.mount_points
|
|
self.origin_stop_mysql = dbaas.MySqlApp.stop_db
|
|
self.origin_start_mysql = dbaas.MySqlApp.start_mysql
|
|
self.origin_update_overrides = dbaas.MySqlApp.update_overrides
|
|
self.origin_pkg_is_installed = pkg.Package.pkg_is_installed
|
|
self.origin_os_path_exists = os.path.exists
|
|
self.origin_chown = operating_system.chown
|
|
# set up common mock objects, etc. for replication testing
|
|
self.patcher_gfvs = patch(
|
|
'trove.guestagent.dbaas.get_filesystem_volume_stats')
|
|
self.patcher_rs = patch(self.manager.replication_namespace + "." +
|
|
self.manager.replication_strategy)
|
|
self.mock_gfvs_class = self.patcher_gfvs.start()
|
|
self.mock_rs_class = self.patcher_rs.start()
|
|
self.repl_datastore_manager = 'mysql'
|
|
self.repl_replication_strategy = 'MysqlGTIDReplication'
|
|
|
|
def tearDown(self):
|
|
super(GuestAgentManagerTest, self).tearDown()
|
|
dbaas.MySqlAppStatus = self.origin_MySqlAppStatus
|
|
os.path.exists = self.origin_os_path_exists
|
|
volume.VolumeDevice.format = self.origin_format
|
|
volume.VolumeDevice.migrate_data = self.origin_migrate_data
|
|
volume.VolumeDevice.mount = self.origin_mount
|
|
volume.VolumeDevice.unmount = self.origin_unmount
|
|
volume.VolumeDevice.mount_points = self.origin_mount_points
|
|
dbaas.MySqlApp.stop_db = self.origin_stop_mysql
|
|
dbaas.MySqlApp.start_mysql = self.origin_start_mysql
|
|
dbaas.MySqlApp.update_overrides = self.origin_update_overrides
|
|
operating_system.chown = self.origin_chown
|
|
pkg.Package.pkg_is_installed = self.origin_pkg_is_installed
|
|
os.path.exists = self.origin_os_path_exists
|
|
# teardown the replication mock objects
|
|
self.patcher_gfvs.stop()
|
|
self.patcher_rs.stop()
|
|
|
|
def test_update_status(self):
|
|
mock_status = MagicMock()
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
self.manager.update_status(self.context)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
mock_status.update.assert_any_call()
|
|
|
|
def test_create_database(self):
|
|
dbaas.MySqlAdmin.create_database = MagicMock(return_value=None)
|
|
self.manager.create_database(self.context, ['db1'])
|
|
dbaas.MySqlAdmin.create_database.assert_any_call(['db1'])
|
|
|
|
def test_create_user(self):
|
|
dbaas.MySqlAdmin.create_user = MagicMock(return_value=None)
|
|
self.manager.create_user(self.context, ['user1'])
|
|
dbaas.MySqlAdmin.create_user.assert_any_call(['user1'])
|
|
|
|
def test_delete_database(self):
|
|
databases = ['db1']
|
|
dbaas.MySqlAdmin.delete_database = MagicMock(return_value=None)
|
|
self.manager.delete_database(self.context, databases)
|
|
dbaas.MySqlAdmin.delete_database.assert_any_call(databases)
|
|
|
|
def test_delete_user(self):
|
|
user = ['user1']
|
|
dbaas.MySqlAdmin.delete_user = MagicMock(return_value=None)
|
|
self.manager.delete_user(self.context, user)
|
|
dbaas.MySqlAdmin.delete_user.assert_any_call(user)
|
|
|
|
def test_grant_access(self):
|
|
username = "test_user"
|
|
hostname = "test_host"
|
|
databases = ["test_database"]
|
|
dbaas.MySqlAdmin.grant_access = MagicMock(return_value=None)
|
|
self.manager.grant_access(self.context,
|
|
username,
|
|
hostname,
|
|
databases)
|
|
|
|
dbaas.MySqlAdmin.grant_access.assert_any_call(username,
|
|
hostname,
|
|
databases)
|
|
|
|
def test_list_databases(self):
|
|
dbaas.MySqlAdmin.list_databases = MagicMock(return_value=['database1'])
|
|
databases = self.manager.list_databases(self.context)
|
|
self.assertThat(databases, Not(Is(None)))
|
|
self.assertThat(databases, Equals(['database1']))
|
|
dbaas.MySqlAdmin.list_databases.assert_any_call(None, None, False)
|
|
|
|
def test_list_users(self):
|
|
dbaas.MySqlAdmin.list_users = MagicMock(return_value=['user1'])
|
|
users = self.manager.list_users(self.context)
|
|
self.assertThat(users, Equals(['user1']))
|
|
dbaas.MySqlAdmin.list_users.assert_any_call(None, None, False)
|
|
|
|
def test_get_users(self):
|
|
username = ['user1']
|
|
hostname = ['host']
|
|
dbaas.MySqlAdmin.get_user = MagicMock(return_value=['user1'])
|
|
users = self.manager.get_user(self.context, username, hostname)
|
|
self.assertThat(users, Equals(['user1']))
|
|
dbaas.MySqlAdmin.get_user.assert_any_call(username, hostname)
|
|
|
|
def test_enable_root(self):
|
|
dbaas.MySqlAdmin.enable_root = MagicMock(return_value='user_id_stuff')
|
|
user_id = self.manager.enable_root(self.context)
|
|
self.assertThat(user_id, Is('user_id_stuff'))
|
|
dbaas.MySqlAdmin.enable_root.assert_any_call()
|
|
|
|
def test_is_root_enabled(self):
|
|
dbaas.MySqlAdmin.is_root_enabled = MagicMock(return_value=True)
|
|
is_enabled = self.manager.is_root_enabled(self.context)
|
|
self.assertThat(is_enabled, Is(True))
|
|
dbaas.MySqlAdmin.is_root_enabled.assert_any_call()
|
|
|
|
def test_create_backup(self):
|
|
backup.backup = MagicMock(return_value=None)
|
|
# entry point
|
|
Manager().create_backup(self.context, 'backup_id_123')
|
|
# assertions
|
|
backup.backup.assert_any_call(self.context, 'backup_id_123')
|
|
|
|
def test_prepare_device_path_true(self):
|
|
self._prepare_dynamic()
|
|
|
|
def test_prepare_device_path_false(self):
|
|
self._prepare_dynamic(device_path=None)
|
|
|
|
def test_prepare_device_path_mounted(self):
|
|
self._prepare_dynamic(is_mounted=True)
|
|
|
|
def test_prepare_mysql_not_installed(self):
|
|
self._prepare_dynamic(is_mysql_installed=False)
|
|
|
|
def test_prepare_mysql_from_backup(self):
|
|
self._prepare_dynamic(backup_id='backup_id_123abc')
|
|
|
|
def test_prepare_mysql_from_backup_with_root(self):
|
|
self._prepare_dynamic(backup_id='backup_id_123abc',
|
|
is_root_enabled=True)
|
|
|
|
def test_prepare_mysql_with_root_password(self):
|
|
self._prepare_dynamic(root_password='some_password')
|
|
|
|
def test_prepare_mysql_with_users_and_databases(self):
|
|
self._prepare_dynamic(databases=['db1'], users=['user1'])
|
|
|
|
def test_prepare_mysql_with_snapshot(self):
|
|
snapshot = {'replication_strategy': self.repl_replication_strategy,
|
|
'dataset': {'dataset_size': 1.0},
|
|
'config': None}
|
|
self._prepare_dynamic(snapshot=snapshot)
|
|
|
|
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)
|
|
|
|
def test_get_replication_snapshot(self):
|
|
mock_status = MagicMock()
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
|
|
snapshot_id = 'my_snapshot_id'
|
|
log_position = 123456789
|
|
master_ref = 'my_master'
|
|
used_size = 1.0
|
|
total_size = 2.0
|
|
|
|
mock_replication = MagicMock()
|
|
mock_replication.enable_as_master = MagicMock()
|
|
mock_replication.snapshot_for_replication = MagicMock(
|
|
return_value=(snapshot_id, log_position))
|
|
mock_replication.get_master_ref = MagicMock(
|
|
return_value=master_ref)
|
|
self.mock_rs_class.return_value = mock_replication
|
|
self.mock_gfvs_class.return_value = (
|
|
{'used': used_size, 'total': total_size})
|
|
|
|
expected_replication_snapshot = {
|
|
'dataset': {
|
|
'datastore_manager': self.repl_datastore_manager,
|
|
'dataset_size': used_size,
|
|
'volume_size': total_size,
|
|
'snapshot_id': snapshot_id
|
|
},
|
|
'replication_strategy': self.repl_replication_strategy,
|
|
'master': master_ref,
|
|
'log_position': log_position
|
|
}
|
|
|
|
snapshot_info = None
|
|
replica_source_config = None
|
|
# entry point
|
|
replication_snapshot = (
|
|
self.manager.get_replication_snapshot(self.context, snapshot_info,
|
|
replica_source_config))
|
|
# assertions
|
|
self.assertEqual(expected_replication_snapshot, replication_snapshot)
|
|
self.assertEqual(1, mock_replication.enable_as_master.call_count)
|
|
self.assertEqual(
|
|
1, mock_replication.snapshot_for_replication.call_count)
|
|
self.assertEqual(1, mock_replication.get_master_ref.call_count)
|
|
|
|
def test_attach_replication_slave_valid(self):
|
|
mock_status = MagicMock()
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
|
|
total_size = 2.0
|
|
dataset_size = 1.0
|
|
|
|
mock_replication = MagicMock()
|
|
mock_replication.enable_as_slave = MagicMock()
|
|
self.mock_rs_class.return_value = mock_replication
|
|
self.mock_gfvs_class.return_value = {'total': total_size}
|
|
|
|
snapshot = {'replication_strategy': self.repl_replication_strategy,
|
|
'dataset': {'dataset_size': dataset_size}}
|
|
|
|
# entry point
|
|
self.manager.attach_replica(self.context, snapshot, None)
|
|
# assertions
|
|
self.assertEqual(1, mock_replication.enable_as_slave.call_count)
|
|
|
|
@patch('trove.guestagent.datastore.mysql_common.manager.LOG')
|
|
def test_attach_replication_slave_invalid(self, *args):
|
|
mock_status = MagicMock()
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
|
|
total_size = 2.0
|
|
dataset_size = 3.0
|
|
|
|
mock_replication = MagicMock()
|
|
mock_replication.enable_as_slave = MagicMock()
|
|
self.mock_rs_class.return_value = mock_replication
|
|
self.mock_gfvs_class.return_value = {'total': total_size}
|
|
|
|
snapshot = {'replication_strategy': self.repl_replication_strategy,
|
|
'dataset': {'dataset_size': dataset_size}}
|
|
|
|
# entry point
|
|
self.assertRaises(InsufficientSpaceForReplica,
|
|
self.manager.attach_replica,
|
|
self.context, snapshot, None)
|
|
# assertions
|
|
self.assertEqual(0, mock_replication.enable_as_slave.call_count)
|
|
|
|
def test_detach_replica(self):
|
|
mock_status = MagicMock()
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
|
|
mock_replication = MagicMock()
|
|
mock_replication.detach_slave = MagicMock()
|
|
self.mock_rs_class.return_value = mock_replication
|
|
|
|
# entry point
|
|
self.manager.detach_replica(self.context)
|
|
# assertions
|
|
self.assertEqual(1, mock_replication.detach_slave.call_count)
|
|
|
|
def test_demote_replication_master(self):
|
|
mock_status = MagicMock()
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
|
|
mock_replication = MagicMock()
|
|
mock_replication.demote_master = MagicMock()
|
|
self.mock_rs_class.return_value = mock_replication
|
|
|
|
# entry point
|
|
self.manager.demote_replication_master(self.context)
|
|
# assertions
|
|
self.assertEqual(1, mock_replication.demote_master.call_count)
|
|
|
|
def test_get_master_UUID(self):
|
|
app = dbaas.MySqlApp(None)
|
|
|
|
def test_case(slave_status, expected_value):
|
|
with patch.object(dbaas.MySqlApp, '_get_slave_status',
|
|
return_value=slave_status):
|
|
assert_equal(app._get_master_UUID(), expected_value)
|
|
|
|
test_case({'Master_UUID': '2a5b-2064-32fb'}, '2a5b-2064-32fb')
|
|
test_case({'Master_UUID': ''}, None)
|
|
test_case({}, None)
|
|
|
|
def test_get_last_txn(self):
|
|
|
|
def test_case(gtid_list, expected_value):
|
|
with patch.object(dbaas.MySqlApp, '_get_gtid_executed',
|
|
return_value=gtid_list):
|
|
txn = self.manager.get_last_txn(self.context)
|
|
assert_equal(txn, expected_value)
|
|
|
|
with patch.object(dbaas.MySqlApp, '_get_slave_status',
|
|
return_value={'Master_UUID': '2a5b-2064-32fb'}):
|
|
test_case('2a5b-2064-32fb:1', ('2a5b-2064-32fb', 1))
|
|
test_case('2a5b-2064-32fb:1-5', ('2a5b-2064-32fb', 5))
|
|
test_case('2a5b-2064-32fb:1,4b4-23:5', ('2a5b-2064-32fb', 1))
|
|
test_case('4b4-23:5,2a5b-2064-32fb:1', ('2a5b-2064-32fb', 1))
|
|
test_case('4b-23:5,2a5b-2064-32fb:1,25:3-4', ('2a5b-2064-32fb', 1))
|
|
test_case('4b4-23:1-5,2a5b-2064-32fb:1-10', ('2a5b-2064-32fb', 10))
|
|
|
|
with patch.object(dbaas.MySqlApp, '_get_slave_status',
|
|
return_value={'Master_UUID': ''}):
|
|
test_case('2a5b-2064-32fb:1', (None, 0))
|
|
|
|
with patch.object(dbaas.MySqlApp, '_get_slave_status',
|
|
return_value={}):
|
|
test_case('2a5b-2064-32fb:1', (None, 0))
|
|
|
|
def test_rpc_ping(self):
|
|
self.assertTrue(self.manager.rpc_ping(self.context))
|
|
|
|
def test_change_passwords(self):
|
|
dbaas.MySqlAdmin.change_passwords = MagicMock(return_value=None)
|
|
self.manager.change_passwords(
|
|
self.context, [{'name': 'test_user', 'password': 'testpwd'}])
|
|
dbaas.MySqlAdmin.change_passwords.assert_any_call(
|
|
[{'name': 'test_user', 'password': 'testpwd'}])
|
|
|
|
def test_update_attributes(self):
|
|
dbaas.MySqlAdmin.update_attributes = MagicMock(return_value=None)
|
|
self.manager.update_attributes(self.context, 'test_user', '%',
|
|
{'password': 'testpwd'})
|
|
dbaas.MySqlAdmin.update_attributes.assert_any_call('test_user', '%',
|
|
{'password':
|
|
'testpwd'})
|
|
|
|
def test_reset_configuration(self):
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=MagicMock())
|
|
dbaas.MySqlApp.reset_configuration = MagicMock(return_value=None)
|
|
configuration = {'config_contents': 'some junk'}
|
|
self.manager.reset_configuration(self.context, configuration)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.reset_configuration.assert_any_call({'config_contents':
|
|
'some junk'})
|
|
|
|
def test_revoke_access(self):
|
|
dbaas.MySqlAdmin.revoke_access = MagicMock(return_value=None)
|
|
self.manager.revoke_access(self.context, 'test_user', '%', 'test_db')
|
|
dbaas.MySqlAdmin.revoke_access.assert_any_call('test_user', '%',
|
|
'test_db')
|
|
|
|
def test_list_access(self):
|
|
dbaas.MySqlAdmin.list_access = MagicMock(return_value=['database1'])
|
|
access = self.manager.list_access(self.context, 'test_user', '%')
|
|
self.assertEqual(['database1'], access)
|
|
dbaas.MySqlAdmin.list_access.assert_any_call('test_user', '%')
|
|
|
|
def test_restart(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.restart = MagicMock(return_value=None)
|
|
self.manager.restart(self.context)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.restart.assert_any_call()
|
|
|
|
def test_start_db_with_conf_changes(self):
|
|
mock_status = MagicMock()
|
|
configuration = {'config_contents': 'some junk'}
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.start_db_with_conf_changes = MagicMock(
|
|
return_value=None)
|
|
self.manager.start_db_with_conf_changes(self.context, configuration)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.start_db_with_conf_changes.assert_any_call(
|
|
{'config_contents': 'some junk'})
|
|
|
|
def test_stop_db(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.stop_db = MagicMock(return_value=None)
|
|
self.manager.stop_db(self.context)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.stop_db.assert_any_call(do_not_start_on_reboot=False)
|
|
|
|
def test_get_filesystem_stats(self):
|
|
with patch.object(base_dbaas, 'get_filesystem_volume_stats'):
|
|
self.manager.get_filesystem_stats(self.context, '/var/lib/mysql')
|
|
base_dbaas.get_filesystem_volume_stats.assert_any_call(
|
|
'/var/lib/mysql')
|
|
|
|
def test_mount_volume(self):
|
|
with patch.object(volume.VolumeDevice, 'mount', return_value=None):
|
|
self.manager.mount_volume(self.context,
|
|
device_path='/dev/vdb',
|
|
mount_point='/var/lib/mysql')
|
|
test_mount = volume.VolumeDevice.mount.call_args_list[0]
|
|
test_mount.assert_called_with('/var/lib/mysql', False)
|
|
|
|
def test_unmount_volume(self):
|
|
with patch.object(volume.VolumeDevice, 'unmount', return_value=None):
|
|
self.manager.unmount_volume(self.context, device_path='/dev/vdb')
|
|
test_unmount = volume.VolumeDevice.unmount.call_args_list[0]
|
|
test_unmount.assert_called_with('/var/lib/mysql')
|
|
|
|
def test_resize_fs(self):
|
|
with patch.object(volume.VolumeDevice, 'resize_fs', return_value=None):
|
|
self.manager.resize_fs(self.context, device_path='/dev/vdb')
|
|
test_resize_fs = volume.VolumeDevice.resize_fs.call_args_list[0]
|
|
test_resize_fs.assert_called_with('/var/lib/mysql')
|
|
|
|
def test_update_overrides(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.remove_overrides = MagicMock(return_value=None)
|
|
dbaas.MySqlApp.update_overrides = MagicMock(return_value=None)
|
|
self.manager.update_overrides(self.context, 'something_overrides')
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.remove_overrides.assert_not_called()
|
|
dbaas.MySqlApp.update_overrides.assert_any_call('something_overrides')
|
|
|
|
def test_update_overrides_with_remove(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.remove_overrides = MagicMock(return_value=None)
|
|
dbaas.MySqlApp.update_overrides = MagicMock(return_value=None)
|
|
self.manager.update_overrides(self.context, 'something_overrides',
|
|
True)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.remove_overrides.assert_any_call()
|
|
dbaas.MySqlApp.update_overrides.assert_any_call('something_overrides')
|
|
|
|
def test_apply_overrides(self):
|
|
mock_status = MagicMock()
|
|
override = {'some_key': 'some value'}
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.apply_overrides = MagicMock(return_value=None)
|
|
self.manager.apply_overrides(self.context, override)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.apply_overrides.assert_any_call({'some_key':
|
|
'some value'})
|
|
|
|
def test_get_txn_count(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.get_txn_count = MagicMock(return_value=(9879))
|
|
txn_count = self.manager.get_txn_count(self.context)
|
|
self.assertEqual(9879, txn_count)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.get_txn_count.assert_any_call()
|
|
|
|
def test_get_latest_txn_id(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.get_latest_txn_id = MagicMock(
|
|
return_value=('2a5b-2064-32fb:1'))
|
|
latest_txn_id = self.manager.get_latest_txn_id(self.context)
|
|
self.assertEqual('2a5b-2064-32fb:1', latest_txn_id)
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.get_latest_txn_id.assert_any_call()
|
|
|
|
def test_wait_for_txn(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.wait_for_txn = MagicMock(return_value=None)
|
|
self.manager.wait_for_txn(self.context, '4b4-23:5,2a5b-2064-32fb:1')
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.wait_for_txn.assert_any_call('4b4-23:5,2a5b-2064-32fb:1'
|
|
)
|
|
|
|
def test_make_read_only(self):
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
dbaas.MySqlApp.make_read_only = MagicMock(return_value=None)
|
|
self.manager.make_read_only(self.context, 'ON')
|
|
dbaas.MySqlAppStatus.get.assert_any_call()
|
|
dbaas.MySqlApp.make_read_only.assert_any_call('ON')
|
|
|
|
def test_cleanup_source_on_replica_detach(self):
|
|
mock_replication = MagicMock()
|
|
mock_replication.cleanup_source_on_replica_detach = MagicMock()
|
|
self.mock_rs_class.return_value = mock_replication
|
|
snapshot = {'replication_strategy': self.repl_replication_strategy,
|
|
'dataset': {'dataset_size': '1.0'}}
|
|
|
|
# entry point
|
|
self.manager.cleanup_source_on_replica_detach(self.context, snapshot)
|
|
# assertions
|
|
self.assertEqual(
|
|
1, mock_replication.cleanup_source_on_replica_detach.call_count)
|
|
|
|
def test_get_replica_context(self):
|
|
replication_user = {
|
|
'name': 'repl_user',
|
|
'password': 'repl_pwd'
|
|
}
|
|
master_ref = {
|
|
'host': '1.2.3.4',
|
|
'port': 3306
|
|
}
|
|
rep_info = {
|
|
'master': master_ref,
|
|
'log_position': {
|
|
'replication_user': replication_user
|
|
}
|
|
}
|
|
mock_replication = MagicMock()
|
|
mock_replication.get_replica_context = MagicMock(return_value=rep_info)
|
|
self.mock_rs_class.return_value = mock_replication
|
|
|
|
# entry point
|
|
replica_info = self.manager.get_replica_context(self.context)
|
|
# assertions
|
|
self.assertEqual(1, mock_replication.get_replica_context.call_count)
|
|
self.assertEqual(rep_info, replica_info)
|
|
|
|
def test_enable_as_master(self):
|
|
mock_replication = MagicMock()
|
|
mock_replication.enable_as_master = MagicMock()
|
|
self.mock_rs_class.return_value = mock_replication
|
|
|
|
# entry point
|
|
self.manager.enable_as_master(self.context, None)
|
|
# assertions
|
|
self.assertEqual(mock_replication.enable_as_master.call_count, 1)
|
|
|
|
@patch('trove.guestagent.datastore.mysql_common.manager.LOG')
|
|
def test__perform_restore(self, *args):
|
|
backup_info = {'id': 'backup_id_123abc',
|
|
'location': 'fake-location',
|
|
'type': 'InnoBackupEx',
|
|
'checksum': 'fake-checksum',
|
|
}
|
|
mock_status = MagicMock()
|
|
self.manager.appStatus = mock_status
|
|
dbaas.MySqlAppStatus.get = MagicMock(return_value=mock_status)
|
|
app = dbaas.MySqlApp(dbaas.MySqlAppStatus.get())
|
|
backup.restore = MagicMock(side_effect=ProcessExecutionError)
|
|
self.assertRaises(ProcessExecutionError,
|
|
self.manager._perform_restore, backup_info,
|
|
self.context, '/var/lib/mysql', app)
|
|
app.status.set_status.assert_called_with(
|
|
rd_instance.ServiceStatuses.FAILED)
|