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_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()
class TestReplication(TestCase):
def setUp(self):
util.init_db()
self.replica_datastore_version = Mock(spec=DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.root_info = DBInstance(
InstanceTasks.NONE,
id="Another_instance",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id)
self.root_info.save()
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id="Another_instance")
self.replica_info.save()
self.safe_nova = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def tearDown(self):
models.create_nova_client = self.safe_nova
self.replica_info.delete()
self.root_info.delete()
super(TestReplication, self).tearDown()
def test_create_replica_from_replica(self):
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
2,
"UUID", [], [],
None,
self.replica_datastore_version,
1,
None,
slave_of_id=self.replica_info.id)
class TestReplication(TestCase):
def setUp(self):
util.init_db()
self.replica_datastore_version = Mock(spec=DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.root_info = DBInstance(
InstanceTasks.NONE,
id="Another_instance",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id)
self.root_info.save()
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id="Another_instance")
self.replica_info.save()
self.safe_nova = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def tearDown(self):
models.create_nova_client = self.safe_nova
self.replica_info.delete()
self.root_info.delete()
super(TestReplication, self).tearDown()
def test_create_replica_from_replica(self):
self.assertRaises(exception.Forbidden, Instance.create,
None, 'name', 2, "UUID", [], [], None,
self.replica_datastore_version, 1,
None, slave_of_id=self.replica_info.id)
class TestReplication(TestCase):
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 tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
def test_replica_of_not_active_master(self):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
self.master_status.save()
self.assertRaises(exception.UnprocessableEntity,
Instance.create,
None,
'name',
1,
"UUID", [], [],
None,
self.datastore_version,
1,
None,
slave_of_id=self.master.id)
def test_replica_with_invalid_slave_of_id(self):
self.assertRaises(exception.NotFound,
Instance.create,
None,
'name',
1,
"UUID", [], [],
None,
self.datastore_version,
1,
None,
slave_of_id=str(uuid.uuid4()))
def test_create_replica_from_replica(self):
self.replica_datastore_version = Mock(
spec=datastore_models.DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id=self.master.id)
self.replica_info.save()
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
2,
"UUID", [], [],
None,
self.datastore_version,
1,
None,
slave_of_id=self.replica_info.id)
class TestReplication(TestCase):
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 tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
def test_replica_of_not_active_master(self):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
self.master_status.save()
self.assertRaises(
exception.UnprocessableEntity,
Instance.create,
None,
"name",
1,
"UUID",
[],
[],
None,
self.datastore_version,
1,
None,
slave_of_id=self.master.id,
)
def test_replica_with_invalid_slave_of_id(self):
self.assertRaises(
exception.NotFound,
Instance.create,
None,
"name",
1,
"UUID",
[],
[],
None,
self.datastore_version,
1,
None,
slave_of_id=str(uuid.uuid4()),
)
def test_create_replica_from_replica(self):
self.replica_datastore_version = Mock(spec=datastore_models.DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = "mysql"
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id=self.master.id,
)
self.replica_info.save()
self.assertRaises(
exception.Forbidden,
Instance.create,
None,
"name",
2,
"UUID",
[],
[],
None,
self.datastore_version,
1,
None,
slave_of_id=self.replica_info.id,
)
class TestReplication(trove_testtools.TestCase):
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,
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 = models.create_nova_client
models.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 tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
@patch('trove.instance.models.LOG')
def test_replica_of_not_active_master(self, mock_logging):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
self.master_status.save()
self.assertRaises(exception.UnprocessableEntity,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=self.master.id)
@patch('trove.instance.models.LOG')
def test_replica_with_invalid_slave_of_id(self, mock_logging):
self.assertRaises(exception.NotFound,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=str(uuid.uuid4()))
def test_create_replica_from_replica(self):
self.replica_datastore_version = Mock(
spec=datastore_models.DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id=self.master.id)
self.replica_info.save()
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
2,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=self.replica_info.id)
def test_create_replica_with_users(self):
self.users.append({"name": "testuser", "password": "******"})
self.assertRaises(exception.ReplicaCreateWithUsersDatabasesError,
Instance.create,
None,
'name',
2,
"UUID", [],
self.users,
self.datastore,
self.datastore_version,
1,
None,
slave_of_id=self.master.id)
def test_create_replica_with_databases(self):
self.databases.append({"name": "testdb"})
self.assertRaises(exception.ReplicaCreateWithUsersDatabasesError,
Instance.create,
None,
'name',
1,
"UUID",
self.databases, [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=self.master.id)
def test_replica_volume_size_smaller_than_master(self):
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
1,
None,
slave_of_id=self.master.id)
class TestReplication(trove_testtools.TestCase):
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 tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
clients.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
@patch('trove.instance.models.LOG')
def test_replica_with_invalid_slave_of_id(self, mock_logging):
self.assertRaises(exception.NotFound,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=str(uuid.uuid4()))
