def test_bad_resize_vol_data(self):
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
data = "bad data"
try:
self.dbaas.instances.resize_volume(self.instance.id, data)
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(
httpCode, 400,
"Resize instance failed with code %s, exception %s" %
(httpCode, e))
data = "u'bad data'"
assert_equal(
e.message, "Validation error: "
"resize['volume']['size'] %s "
"is not valid under any of the given schemas; "
"%s is not of type 'integer'; "
"%s does not match '[0-9]+'" % (data, data, data))
def test_bad_change_user_password(self):
password = ""
users = [{"name": password}]
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
try:
self.dbaas.users.change_passwords(self.instance, users)
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(httpCode, 400,
"Change usr/passwd failed with code %s, exception %s"
% (httpCode, e))
if not isinstance(self.dbaas.client,
troveclient.xml.TroveXmlClient):
password = "******"
assert_equal(e.message,
"Validation error: "
"users[0] 'password' is a required property; "
"users[0]['name'] %s is too short; "
"users[0]['name'] %s does not match "
"'^.*[0-9a-zA-Z]+.*$'" %
(password, password))
def test_backup_delete(self):
"""test delete"""
# Test to make sure that user in other tenant is not able
# to DELETE this backup
reqs = Requirements(is_admin=False)
other_user = CONFIG.users.find_user(
reqs,
black_list=[instance_info.user.auth_user])
other_client = create_dbaas_client(other_user)
assert_raises(exceptions.NotFound, other_client.backups.delete,
backup_info.id)
instance_info.dbaas.backups.delete(backup_info.id)
assert_equal(202, instance_info.dbaas.last_http_code)
def backup_is_gone():
result = instance_info.dbaas.instances.backups(instance_info.id)
if len(result) == 0:
return True
else:
return False
poll_until(backup_is_gone)
assert_raises(exceptions.NotFound, instance_info.dbaas.backups.get,
backup_info.id)
def test_bad_change_user_password(self):
password = ""
users = [{"name": password}]
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
try:
self.dbaas.users.change_passwords(self.instance, users)
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(
httpCode, 400,
"Change usr/passwd failed with code %s, exception %s" %
(httpCode, e))
if not isinstance(self.dbaas.client,
troveclient.xml.TroveXmlClient):
password = "******"
assert_equal(
e.message, "Validation error: "
"users[0] 'password' is a required property; "
"users[0]['name'] %s is too short; "
"users[0]['name'] %s does not match "
"'^.*[0-9a-zA-Z]+.*$'" % (password, password))
def test_bad_resize_vol_data(self):
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
data = "bad data"
try:
self.dbaas.instances.resize_volume(self.instance.id, data)
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(httpCode, 400,
"Resize instance failed with code %s, exception %s"
% (httpCode, e))
data = "u'bad data'"
assert_equal(e.message,
"Validation error: "
"resize['volume']['size'] %s "
"is not valid under any of the given schemas; "
"%s is not of type 'integer'; "
"%s does not match '[0-9]+'" %
(data, data, data))
def test_backup_delete(self):
"""test delete"""
# Test to make sure that user in other tenant is not able
# to DELETE this backup
reqs = Requirements(is_admin=False)
other_user = CONFIG.users.find_user(
reqs,
black_list=[instance_info.user.auth_user])
other_client = create_dbaas_client(other_user)
assert_raises(exceptions.NotFound, other_client.backups.delete,
backup_info.id)
instance_info.dbaas.backups.delete(backup_info.id)
assert_equal(202, instance_info.dbaas.last_http_code)
def backup_is_gone():
result = instance_info.dbaas.instances.backups(instance_info.id)
if len(result) == 0:
return True
else:
return False
poll_until(backup_is_gone)
assert_raises(exceptions.NotFound, instance_info.dbaas.backups.get,
backup_info.id)
def test_create_backup_with_instance_not_active(self):
name = "spare_instance"
flavor = 2
self.databases.append({"name": "db2"})
self.users.append({"name": "lite", "password": "******",
"databases": [{"name": "db2"}]})
volume = {'size': 2}
self.xtra_instance = instance_info.dbaas.instances.create(
name,
flavor,
volume,
self.databases,
self.users)
assert_equal(200, instance_info.dbaas.last_http_code)
# immediately create the backup while instance is still in "BUILD"
try:
self.xtra_backup = self._create_backup(
BACKUP_NAME, BACKUP_DESC, inst_id=self.xtra_instance.id)
assert_true(False, "Expected 422 from create backup")
except exceptions.UnprocessableEntity:
assert_equal(422, instance_info.dbaas.last_http_code)
assert_equal(422, instance_info.dbaas.last_http_code)
# make sure the instance status goes back to "ACTIVE"
poll_until(lambda: self._verify_instance_status(self.xtra_instance.id,
"ACTIVE"),
time_out=120, sleep_time=2)
# Now that it's active, create the backup
self.xtra_backup = self._create_backup(BACKUP_NAME, BACKUP_DESC)
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._verify_backup_status(self.xtra_backup.id,
'COMPLETED'),
time_out=120, sleep_time=2)
def restart_compute_service(extra_args=None):
extra_args = extra_args or []
test_config.compute_service.restart(extra_args=extra_args)
# Be absolutely certain the compute manager is ready before passing control
# back to caller.
poll_until(lambda: hosts_up('compute'), sleep_time=1, time_out=60)
wait_for_compute_service()
def wait_for_resize(self):
def is_finished_resizing():
instance = self.instance
if instance.status == "RESIZE":
return False
assert_equal("ACTIVE", instance.status)
return True
testsutil.poll_until(is_finished_resizing, time_out=TIME_OUT_TIME)
def restart_compute_service(extra_args=None):
extra_args = extra_args or []
test_config.compute_service.restart(extra_args=extra_args)
# Be absolutely certain the compute manager is ready before passing control
# back to caller.
poll_until(lambda: hosts_up('compute'),
sleep_time=1, time_out=60)
wait_for_compute_service()
def wait_for_resize(self):
def is_finished_resizing():
instance = self.instance
if instance.status == "RESIZE":
return False
assert_equal("ACTIVE", instance.status)
return True
poll_until(is_finished_resizing, time_out=TIME_OUT_TIME)
def wait_for_broken_connection(self):
"""Wait until our connection breaks."""
if not USE_IP:
return
if not hasattr(self, "connection"):
return
poll_until(self.connection.is_connected,
lambda connected: not connected,
time_out=TIME_OUT_TIME)
def wait_for_broken_connection(self):
"""Wait until our connection breaks."""
if not USE_IP:
return
if not hasattr(self, "connection"):
return
testsutil.poll_until(self.connection.is_connected,
lambda connected: not connected,
time_out=TIME_OUT_TIME)
def wait_for_compute_service():
pid = test_config.compute_service.find_proc_id()
line = "Creating Consumer connection for Service compute from (pid=%d)" % \
pid
try:
poll_until(lambda: check_logs_for_message(line),
sleep_time=1, time_out=60)
except exception.PollTimeOut:
raise RuntimeError("Could not find the line %s in the logs." % line)
def wait_for_successful_restart(self):
"""Wait until status becomes running."""
def is_finished_rebooting():
instance = self.instance
if instance.status == "REBOOT":
return False
assert_equal("ACTIVE", instance.status)
return True
testsutil.poll_until(is_finished_rebooting, time_out=TIME_OUT_TIME)
def test_instance_action_right_after_backup_create(self):
"""test any instance action while backup is running"""
backup = self._create_backup("modify_during_create",
"modify instance while creating backup")
assert_equal(202, instance_info.dbaas.last_http_code)
# Dont wait for backup to complete, try to delete it
assert_unprocessable(instance_info.dbaas.instances.resize_instance,
instance_info.id, 1)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=2)
def wait_for_successful_restart(self):
"""Wait until status becomes running."""
def is_finished_rebooting():
instance = self.instance
if instance.status == "REBOOT":
return False
assert_equal("ACTIVE", instance.status)
return True
poll_until(is_finished_rebooting, time_out=TIME_OUT_TIME)
def wait_for_compute_service():
pid = test_config.compute_service.find_proc_id()
line = "Creating Consumer connection for Service compute from (pid=%d)" % \
pid
try:
poll_until(lambda: check_logs_for_message(line),
sleep_time=1,
time_out=60)
except exception.PollTimeOut:
raise RuntimeError("Could not find the line %s in the logs." % line)
def update_and_wait_to_finish(self):
instance_info.dbaas_admin.management.update(instance_info.id)
def finished():
current_version = self.get_version()
if current_version == self.next_version:
return True
# The only valid thing for it to be aside from next_version is
# old version.
assert_equal(current_version, self.old_version)
poll_until(finished, sleep_time=1, time_out=3 * 60)
def update_and_wait_to_finish(self):
instance_info.dbaas_admin.management.update(instance_info.id)
def finished():
current_version = self.get_version()
if current_version == self.next_version:
return True
# The only valid thing for it to be aside from next_version is
# old version.
assert_equal(current_version, self.old_version)
testsutil.poll_until(finished, sleep_time=1, time_out=3 * 60)
def test_clean_up_backups(self):
backup_list = instance_info.dbaas.backups.list()
for backup in backup_list:
print("Cleanup backup: %r and status: %r" % (backup.id, backup.status))
if backup.status == 'COMPLETED':
try:
self._delete_backup(backup.id)
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._backup_is_gone(backup.id))
except exceptions.NotFound:
assert_equal(404, instance_info.dbaas.last_http_code)
def test_backup_created(self):
# This version just checks the REST API status.
def result_is_active():
backup = instance_info.dbaas.backups.get(backup_info.id)
if backup.status == "COMPLETED":
return True
else:
assert_not_equal("FAILED", backup.status)
return False
poll_until(result_is_active)
def test_backup_created(self):
# This version just checks the REST API status.
def result_is_active():
backup = instance_info.dbaas.backups.get(backup_info.id)
if backup.status == "COMPLETED":
return True
else:
assert_not_equal("FAILED", backup.status)
return False
poll_until(result_is_active)
def test_delete_deleted_backup(self):
backup = self._create_backup("del_backup", "delete a deleted backup")
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=1)
self._delete_backup(backup.id)
poll_until(lambda: self._backup_is_gone(backup.id))
try:
self._delete_backup(backup.id)
assert_true(False, "Expected 404 from delete backup")
except exceptions.NotFound:
assert_equal(404, instance_info.dbaas.last_http_code)
def test_volume_resize_success(self):
def check_resize_status():
instance = instance_info.dbaas.instances.get(instance_info.id)
if instance.status == "ACTIVE":
return True
elif instance.status == "RESIZE":
return False
else:
fail("Status should not be %s" % instance.status)
testsutil.poll_until(check_resize_status, sleep_time=2, time_out=300)
instance = instance_info.dbaas.instances.get(instance_info.id)
assert_equal(instance.volume['size'], self.new_volume_size)
def wait_for_failure_status(self):
"""Wait until status becomes running."""
def is_finished_rebooting():
instance = self.instance
if instance.status == "REBOOT" or instance.status == "ACTIVE":
return False
# The reason we check for BLOCKED as well as SHUTDOWN is because
# Upstart might try to bring mysql back up after the borked
# connection and the guest status can be either
assert_true(instance.status in ("SHUTDOWN", "BLOCKED"))
return True
poll_until(is_finished_rebooting, time_out=TIME_OUT_TIME)
def wait_for_failure_status(self):
"""Wait until status becomes running."""
def is_finished_rebooting():
instance = self.instance
if instance.status == "REBOOT" or instance.status == "ACTIVE":
return False
# The reason we check for BLOCKED as well as SHUTDOWN is because
# Upstart might try to bring mysql back up after the borked
# connection and the guest status can be either
assert_true(instance.status in ("SHUTDOWN", "BLOCKED"))
return True
testsutil.poll_until(is_finished_rebooting, time_out=TIME_OUT_TIME)
def test_instance_resize_to_ephemeral_in_volume_support_should_fail(self):
flavor_name = CONFIG.values.get('instance_bigger_eph_flavor_name',
'eph.rd-smaller')
flavors = self.dbaas.find_flavors_by_name(flavor_name)
def is_active():
return self.instance.status == 'ACTIVE'
poll_until(is_active, time_out=TIME_OUT_TIME)
assert_equal(self.instance.status, 'ACTIVE')
old_flavor_href = self.get_flavor_href(
flavor_id=self.expected_old_flavor_id)
assert_raises(HTTPNotImplemented, self.dbaas.instances.resize_instance,
self.instance_id, flavors[0].id)
def create_user(self):
"""Create a MySQL user we can use for this test."""
users = [{"name": MYSQL_USERNAME, "password": MYSQL_PASSWORD,
"databases": [{"name": MYSQL_USERNAME}]}]
self.dbaas.users.create(instance_info.id, users)
def has_user():
users = self.dbaas.users.list(instance_info.id)
return any([user.name == MYSQL_USERNAME for user in users])
poll_until(has_user, time_out=30)
if not FAKE_MODE:
time.sleep(5)
def test_instance_resize_to_ephemeral_in_volume_support_should_fail(self):
flavor_name = CONFIG.values.get('instance_bigger_eph_flavor_name',
'eph.rd-smaller')
flavors = self.dbaas.find_flavors_by_name(flavor_name)
def is_active():
return self.instance.status == 'ACTIVE'
testsutil.poll_until(is_active, time_out=TIME_OUT_TIME)
assert_equal(self.instance.status, 'ACTIVE')
self.get_flavor_href(
flavor_id=self.expected_old_flavor_id)
assert_raises(HTTPNotImplemented, self.dbaas.instances.resize_instance,
self.instance_id, flavors[0].id)
def test_create_backup(self):
databases = []
databases.append({"name": BACKUP_DB_NAME, "charset": "latin2",
"collate": "latin2_general_ci"})
instance_info.dbaas.databases.create(instance_info.id, databases)
assert_equal(202, instance_info.dbaas.last_http_code)
backup = self._create_backup(BACKUP_NAME, BACKUP_DESC,
instance_info.id)
self.backup_id = backup.id
assert_equal(backup.name, BACKUP_NAME)
assert_equal(backup.description, BACKUP_DESC)
assert_equal(backup.instance_id, instance_info.id)
assert_equal(backup.status, 'NEW')
assert_is_not_none(backup.id, 'backup.id does not exist')
assert_is_not_none(backup.created, 'backup.created does not exist')
assert_is_not_none(backup.updated, 'backup.updated does not exist')
instance = instance_info.dbaas.instances.get(instance_info.id)
assert_true(instance.status in ('ACTIVE', 'BACKUP'))
# Get Backup status by backup id during and after backup creation
poll_until(lambda: self._verify_instance_status(instance.id,
'BACKUP'),
time_out=120, sleep_time=2)
poll_until(lambda: self._verify_backup_status(backup.id, 'BUILDING'),
time_out=120, sleep_time=2)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=2)
poll_until(lambda: self._verify_instance_status(instance.id,
'ACTIVE'),
time_out=120, sleep_time=2)
def test_volume_resize_success(self):
def check_resize_status():
instance = instance_info.dbaas.instances.get(instance_info.id)
if instance.status == "ACTIVE":
return True
elif instance.status == "RESIZE":
return False
else:
fail("Status should not be %s" % instance.status)
testsutil.poll_until(check_resize_status, sleep_time=2, time_out=300)
instance = instance_info.dbaas.instances.get(instance_info.id)
assert_equal(instance.volume['size'], self.new_volume_size)
def create_user(self):
"""Create a MySQL user we can use for this test."""
users = [{"name": MYSQL_USERNAME, "password": MYSQL_PASSWORD,
"databases": [{"name": MYSQL_USERNAME}]}]
self.dbaas.users.create(instance_info.id, users)
def has_user():
users = self.dbaas.users.list(instance_info.id)
return any([user.name == MYSQL_USERNAME for user in users])
testsutil.poll_until(has_user, time_out=30)
if not FAKE_MODE:
time.sleep(5)
def test_backup_delete(self):
"""test delete"""
instance_info.dbaas.backups.delete(backup_info.id)
assert_equal(202, instance_info.dbaas.last_http_code)
def backup_is_gone():
result = instance_info.dbaas.instances.backups(instance_info.id)
if len(result) == 0:
return True
else:
return False
poll_until(backup_is_gone)
assert_raises(exceptions.NotFound, instance_info.dbaas.backups.get,
backup_info.id)
def test_restore_backup_account_not_owned(self):
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping restore tests for fake mode.")
backup = self._create_backup("rest_not_owned_backup",
"restoring a backup of a different user")
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=2)
try:
self._create_restore(self.spare_client, backup.id)
assert_true(False, "Expected 404 from create restore")
except exceptions.ClientException:
assert_equal(404, self.spare_client.last_http_code)
instance_info.dbaas.backups.delete(backup.id)
poll_until(lambda: self._backup_is_gone(backup_id=backup.id))
def test_delete_while_backing_up(self):
backup = self._create_backup("delete_as_backup",
"delete backup while backing up")
assert_equal(202, instance_info.dbaas.last_http_code)
# Dont wait for backup to complete, try to delete it
try:
self._delete_backup(backup.id)
assert_true(False, "Expected 422 from delete backup")
except:
assert_equal(422, instance_info.dbaas.last_http_code)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=1)
# DCF WHy is this delete different than the one above that uses the helper function?
instance_info.dbaas.backups.delete(backup.id)
poll_until(lambda: self._backup_is_gone(backup_id=backup.id))
def test_restore_deleted_backup(self):
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping restore tests for fake mode.")
backup = self._create_backup("rest_del_backup",
"restoring a deleted backup")
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=2)
self._delete_backup(backup.id)
poll_until(self._backup_is_gone(backup.id))
try:
self._create_restore(instance_info.dbaas, backup.id)
assert_true(False, "Expected 404 from create restore")
except exceptions.ClientException:
assert_equal(404, instance_info.dbaas.last_http_code)
def test_delete_restored_instance(self):
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping delete restored instance for fake mode.")
# Create a backup to list after instance is deleted
backup = self._create_backup(self.restored_name,
self.restored_desc,
inst_id=self.restore_id)
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._verify_backup_status(backup.id, 'COMPLETED'),
time_out=120, sleep_time=2)
self.deleted_backup_id = backup.id
instance_info.dbaas.instances.delete(self.restore_id)
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._instance_is_gone(self.restore_id))
assert_raises(exceptions.NotFound, instance_info.dbaas.instances.get,
self.restore_id)
def test_bad_resize_vol_data(self):
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
try:
self.dbaas.instances.resize_volume(self.instance.id, "bad data")
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_true(httpCode == 400,
"Resize instance failed with code %s, exception %s"
% (httpCode, e))
def test_delete_restored_instance(self):
"""test delete restored instance"""
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping delete restored instance for fake mode.")
instance_info.dbaas.instances.delete(restore_instance_id)
assert_equal(202, instance_info.dbaas.last_http_code)
def instance_is_gone():
try:
instance_info.dbaas.instances.get(restore_instance_id)
return False
except exceptions.NotFound:
return True
poll_until(instance_is_gone)
assert_raises(exceptions.NotFound, instance_info.dbaas.instances.get,
restore_instance_id)
def test_delete_restored_instance(self):
"""test delete restored instance"""
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping delete restored instance for fake mode.")
instance_info.dbaas.instances.delete(restore_instance_id)
assert_equal(202, instance_info.dbaas.last_http_code)
def instance_is_gone():
try:
instance_info.dbaas.instances.get(restore_instance_id)
return False
except exceptions.NotFound:
return True
poll_until(instance_is_gone)
assert_raises(exceptions.NotFound, instance_info.dbaas.instances.get,
restore_instance_id)
def setUp(self):
self.user = test_config.users.find_user(Requirements(is_admin=True))
self.client = create_dbaas_client(self.user)
self.name = 'test_SERVER_ERROR'
# Create an instance with a broken compute instance.
volume = None
if CONFIG.trove_volume_support:
volume = {'size': 1}
self.response = self.client.instances.create(
self.name, instance_info.dbaas_flavor_href, volume, [])
poll_until(lambda: self.client.instances.get(self.response.id),
lambda instance: instance.status == 'ERROR',
time_out=10)
self.instance = self.client.instances.get(self.response.id)
print("Status: %s" % self.instance.status)
msg = "Instance did not drop to error after server prov failure."
assert_equal(self.instance.status, "ERROR", msg)
def test_restore_backup(self):
if test_config.auth_strategy == "fake":
# We should create restore logic in fake guest agent to not skip
raise SkipTest("Skipping restore tests for fake mode.")
restore_resp = self._create_restore(instance_info.dbaas,
self.backup_id)
assert_equal(200, instance_info.dbaas.last_http_code)
assert_equal("BUILD", restore_resp.status)
assert_is_not_none(restore_resp.id, 'restored inst_id does not exist')
self.restore_id = restore_resp.id
poll_until(self._result_is_active)
restored_inst = instance_info.dbaas.instances.get(self.restore_id)
assert_is_not_none(restored_inst, 'restored instance does not exist')
assert_equal(restored_inst.name, BACKUP_NAME + "_restore")
assert_equal(restored_inst.status, 'ACTIVE')
assert_is_not_none(restored_inst.id, 'restored inst_id does not exist')
self._verify_databases(BACKUP_DB_NAME)
def test_delete_negative_instance(self):
try:
self._delete_backup(self.xtra_backup.id)
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._backup_is_gone(self.xtra_backup.id))
except exceptions.NotFound:
assert_equal(404, instance_info.dbaas.last_http_code)
try:
instance_info.dbaas.instances.delete(self.xtra_instance.id)
assert_equal(202, instance_info.dbaas.last_http_code)
poll_until(lambda: self._instance_is_gone(self.xtra_instance.id))
except exceptions.NotFound:
assert_equal(404, instance_info.dbaas.last_http_code)
finally:
assert_raises(exceptions.NotFound,
instance_info.dbaas.instances.get,
self.xtra_instance.id)
def test_instance_restored(self):
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping restore tests for fake mode.")
# This version just checks the REST API status.
def result_is_active():
instance = instance_info.dbaas.instances.get(restore_instance_id)
if instance.status == "ACTIVE":
return True
else:
# If its not ACTIVE, anything but BUILD must be
# an error.
assert_equal("BUILD", instance.status)
if instance_info.volume is not None:
assert_equal(instance.volume.get('used', None), None)
return False
poll_until(result_is_active)
def test_bad_resize_instance_data(self):
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
try:
self.dbaas.instances.resize_instance(self.instance.id, "bad data")
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(
httpCode, 400,
"Resize instance failed with code %s, exception %s" %
(httpCode, e))
def test_resize_down(self):
expected_dbaas_flavor = self.expected_dbaas_flavor
def is_active():
return self.instance.status == 'ACTIVE'
testsutil.poll_until(is_active, time_out=TIME_OUT_TIME)
assert_equal(self.instance.status, 'ACTIVE')
old_flavor_href = self.get_flavor_href(
flavor_id=self.expected_old_flavor_id)
self.dbaas.instances.resize_instance(self.instance_id, old_flavor_href)
assert_equal(202, self.dbaas.last_http_code)
self.old_dbaas_flavor = instance_info.dbaas_flavor
instance_info.dbaas_flavor = expected_dbaas_flavor
self.wait_for_resize()
assert_equal(str(self.instance.flavor['id']),
str(self.expected_old_flavor_id))
def test_resize_down(self):
expected_dbaas_flavor = self.expected_dbaas_flavor
def is_active():
return self.instance.status == 'ACTIVE'
poll_until(is_active, time_out=TIME_OUT_TIME)
assert_equal(self.instance.status, 'ACTIVE')
old_flavor_href = self.get_flavor_href(
flavor_id=self.expected_old_flavor_id)
self.dbaas.instances.resize_instance(self.instance_id, old_flavor_href)
assert_equal(202, self.dbaas.last_http_code)
self.old_dbaas_flavor = instance_info.dbaas_flavor
instance_info.dbaas_flavor = expected_dbaas_flavor
self.wait_for_resize()
assert_equal(str(self.instance.flavor['id']),
str(self.expected_old_flavor_id))
def test_instance_restored(self):
if test_config.auth_strategy == "fake":
raise SkipTest("Skipping restore tests for fake mode.")
# This version just checks the REST API status.
def result_is_active():
instance = instance_info.dbaas.instances.get(restore_instance_id)
if instance.status == "ACTIVE":
return True
else:
# If its not ACTIVE, anything but BUILD must be
# an error.
assert_equal("BUILD", instance.status)
if instance_info.volume is not None:
assert_equal(instance.volume.get('used', None), None)
return False
poll_until(result_is_active)
def set_up(self):
"""Create client for mgmt instance test (2)."""
if not CONFIG.fake_mode:
raise SkipTest("This test only works in fake mode.")
self.client = create_client(is_admin=True)
self.mgmt = self.client.management
# Fake nova will fail a server ending with 'test_SERVER_ERROR'."
# Fake volume will fail if the size is 13.
# TODO(tim.simpson): This would be a lot nicer looking if we used a
# traditional mock framework.
body = None
if CONFIG.trove_volume_support:
body = {'size': 13}
response = self.client.instances.create(
'test_SERVER_ERROR', instance_info.dbaas_flavor_href, body, [])
poll_until(lambda: self.client.instances.get(response.id),
lambda instance: instance.status == 'ERROR',
time_out=10)
self.id = response.id
def test_bad_grant_user_access(self):
dbs = []
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
try:
self.dbaas.users.grant(self.instance, self.user, dbs)
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(
httpCode, 400,
"Grant user access failed with code %s, exception "
"%s" % (httpCode, e))
def test_bad_revoke_user_access(self):
db = ""
def _check_instance_status():
inst = self.dbaas.instances.get(self.instance)
if inst.status == "ACTIVE":
return True
else:
return False
poll_until(_check_instance_status)
try:
self.dbaas.users.revoke(self.instance, self.user, db)
except Exception as e:
resp, body = self.dbaas.client.last_response
httpCode = resp.status
assert_equal(
httpCode, 404,
"Revoke user access failed w/code %s, exception %s" %
(httpCode, e))
assert_equal(e.message, "The resource could not be found.")
def wait_for_instance_status(self, instance_id, status="ACTIVE"):
poll_until(lambda: self.dbaas.instances.get(instance_id),
lambda instance: instance.status == status,
time_out=10)
def wait_for_instance_task_status(self, instance_id, description):
poll_until(lambda: self.dbaas.management.show(instance_id),
lambda instance: instance.task_description == description,
time_out=10)
def _wait_for_active(self):
poll_until(lambda: self.client.instances.get(self.id),
lambda instance: instance.status == "ACTIVE",
time_out=(60 * 8))
def resize_volume_in_shutdown_state(self):
self.client.instances.resize_volume(self.id, 2)
poll_until(lambda: self.client.instances.get(self.id),
lambda instance: instance.volume['size'] == 2,
time_out=(60 * 8))
