def setUp(self):
"""
Run this setup for each test to ensure an active instance is available
"""
super(SmokeTest, self).setUp()
tc_name = "Create Instance"
instance_status = testutil.getInstanceStatus(self.dbaas,
instanceId=self.instance_id)
if (testutil.isInstanceActive(self.dbaas,
instanceStatus=instance_status) is False):
#start a new instance and set the global instance ID
NAME = "qe-smoke"
FLAVOR = 4
VOLUME = 1
try:
instance = self.dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME},
databases=[{"databases": [{"name": "databaseA"}], "name": "dbuser1",
"password": "******"}])
httpCode = testutil.get_last_response_code(self.dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" % httpCode)
self.instance_id = instance.id
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
if self.stability_mode:
testutil.write_to_report(tc_name, tc_pass=True)
except Exception as e:
if self.stability_mode:
testutil.write_to_error_report(self.instance_id, repr(e))
testutil.write_to_report(tc_name, tc_pass=False)
raise
def test_create_user_req_params(self):
_user = []
_user_name = "F343jasdf"
_user.append({"name": _user_name,
"password": "******"})
self.dbaas.users.create(self.instance_id, _user)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#print (self.instance_id)
self.assertTrue(testutil.getInstanceStatus(self.dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
#Get the instance and check instance attribs: such as the flavor / volume size
#TODO: need to verify this list later...
_users = self.dbaas.users.list(self.dbaas.instances.get(self.instance_id))
#self.assertTrue(len(_users) == 1, "Expected 1 user: Got: %s " % len(_users))
#try to find our instance in the list
self.assertTrue(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
userName=_user_name),
"Did not find our user name: %s in the list." % _user_name)
self.dbaas.users.delete(self.instance_id, _user_name)
self.assertFalse(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
userName=_user_name),
"Delete error: Found user name: %s in the list." % _user_name)
def setUpClass(cls):
"""
Creating an instance for smoke testing
"""
super(test_resize_volume_instances, cls).setUpClass()
test_resize_volume_instances.dbaas = cls.dbaas_provider.client.reddwarfclient
NAME = "qe-resize_instances"
FLAVOR = 1
VOLUME = test_resize_volume_instances.ResizeUpSizes.origLevel
instance = test_resize_volume_instances.dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME},
databases=[{"databases": [{"name": "databaseA"}],
"name": "dbuser1",
"password": "******"}])
httpCode = testutil.get_last_response_code(test_resize_volume_instances.dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" % httpCode)
test_resize_volume_instances.instance_id = instance.id
#status = instance.status
testutil.waitForActive(test_resize_volume_instances.dbaas, instanceId=test_resize_volume_instances.instance_id)
def test_resize_to_xxlarge_instance(self):
"""
Resize the instance to xxlarge
"""
dbaas = self.dbaas_provider.client.reddwarfclient
if testutil.isInstanceActive(dbaas, instanceId=self.instance_id):
dbaas.instances.resize_instance(self.instance_id, self.flavorTypes.xxlarge)
httpCode = testutil.get_last_response_code(dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=self.instance_id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
newFlavorSize = dbaas.instances.get(self.instance_id).flavor['id']
self.assertTrue(newFlavorSize == str(self.flavorTypes.xxlarge),
"Unexpected flavor size for resize: %s" % newFlavorSize)
#Resize back to tiny
if testutil.isInstanceActive(dbaas, instanceId=self.instance_id):
dbaas.instances.resize_instance(self.instance_id, self.flavorTypes.tiny)
httpCode = testutil.get_last_response_code(dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=self.instance_id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
def test_restart_instance(self):
"""
test restart of instance
"""
tc_name = "Restart Instance"
try:
# restart the instance
self.dbaas.instances.restart(self.instance_id)
status = testutil.getInstanceStatus(self.dbaas, self.instance_id)
# check interim status of REBOOT
self.assertEqual(status,
"REBOOT",
"Error: instance is not REBOOT, it is: %s" % status)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
if self.stability_mode:
testutil.write_to_report(tc_name, tc_pass=True)
except Exception as e:
if self.stability_mode:
testutil.write_to_error_report(self.instance_id, repr(e))
testutil.write_to_report(tc_name, tc_pass=False)
raise
def setUp(cls):
"""
Run this setup for each test to ensure an active instance is available
"""
tc_name = "Create Instance"
instance_status = testutil.getInstanceStatus(cls.mgmt_dbaas,
instanceId=cls.instance_id)
if (testutil.isInstanceActive(cls.mgmt_dbaas,
instanceStatus=instance_status) is False):
# delete non-Active instance
test_actions.mgmt_dbaas.instances.get(cls.instance_id).delete()
# start a new instance and set the global instance ID
NAME = "qe-mgmt-actions-testing"
FLAVOR = 1
VOLUME = 1
try:
instance = cls.mgmt_dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME},
databases=[{"databases": [{"name": "databaseA"}],
"name": "dbuser1",
"password": "******"}])
httpCode = testutil.get_last_response_code(cls.mgmt_dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" %
(httpCode))
cls.instance_id = instance.id
cls.instance = instance
testutil.waitForActive(cls.mgmt_dbaas,
instanceId=cls.instance_id)
except Exception as e:
self.fixture_log.debug("\tException: %r" % (e))
raise
def test_create_db_singular(self):
db_name = "1234FiRstdb"
_databases = [{"name": db_name,
"character_set": "latin2",
"collate": "latin2_general_ci"}]
self.dbaas.databases.create(self.instance_id, _databases)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#print (self.instance_id)
self.assertTrue(testutil.getInstanceStatus(self.dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
#Get the instance and check instance attribs: such as the flavor / volume size
_databases = self.dbaas.databases.list(self.dbaas.instances.get(self.instance_id))
self.assertTrue(len(_databases) == 1, "Expected 1 database: Got: %s " % len(_databases))
#try to find our instance in the list
self.assertTrue(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
databaseName=db_name),
"Did not find our database name: %s in the list." % db_name)
self.dbaas.databases.delete(self.instance_id, db_name)
self.assertFalse(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
databaseName=db_name),
"Delete error: Found database name: %s in the list." % db_name)
def setUpClass(cls):
"""
Creating an instance for database testing
"""
tc_name = "Create Instance"
super(test_actions, cls).setUpClass()
cls.mgmt_dbaas = cls.dbaas_provider.mgmt_client.reddwarfclient
cls.mgmt_dbaas.authenticate()
NAME = "qe-mgmt-actions-testing"
FLAVOR = 1
VOLUME = 1
instance = test_actions.mgmt_dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME})
httpCode = testutil.get_last_response_code(test_actions.mgmt_dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" % httpCode)
cls.instance_id = instance.id
cls.instance = instance
#status = instance.status
testutil.waitForActive(test_actions.mgmt_dbaas,
instanceId=test_actions.instance_id)
def test_create_tiny_instance(self):
"""
Creating an instance for smoke testing
"""
#database = self.dbaas_provider.client.reddwarfclient
NAME = "qe-tiny-instance"
FLAVOR = 1
VOLUME = 20
instance = self.dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME},
databases=[{"databases": [{"name": "databaseA"}],
"name": "dbuser1",
"password": "******"}])
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '200',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(self.dbaas, instanceId=instance.id)
self.tiny_instance_id = instance.id
#print (self.instance_id)
self.assertTrue(testutil.getInstanceStatus(self.dbaas, instanceId=instance.id) == 'ACTIVE',
"Instance is not in Active statue")
#Get the instance and check instance attribs: such as the flavor / volume size
instance = self.dbaas.instances.get(instance)
self.assertTrue(instance.flavor['id'] == str(FLAVOR))
self.assertTrue(instance.volume['size'] == VOLUME)
self.assertTrue(instance.name == NAME)
#try to find our instance in the list
self.assertTrue(testutil.found_resource(self.dbaas, instanceId=instance.id),
"Did not find our instance id: %s in the list." % instance.id)
def test_create_required_params_instance(self):
"""
Creating an instance for smoke testing
"""
dbaas = self.dbaas_provider.client.reddwarfclient
NAME = "qe-req-params-instance"
FLAVOR = 1
VOLUME = 10
instance = dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME})
httpCode = testutil.get_last_response_code(dbaas)
self.req_params_instance_id = instance.id
self.assertTrue(httpCode == '200',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=instance.id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=instance.id) == 'ACTIVE',
"Instance is not in Active statue")
#Get the instance and check instance attribs: such as the flavor / volume size
instance = self.dbaas.instances.get(instance)
self.assertTrue(instance.flavor['id'] == str(FLAVOR))
self.assertTrue(instance.volume['size'] == VOLUME)
self.assertTrue(instance.name == NAME)
#try to find our instance in the list
self.assertTrue(testutil.found_resource(self.dbaas, instanceId=instance.id),
"Did not find our instance id: %s in the list." % instance.id)
def test_resize_volume(self):
"""
Test Resize volume
"""
tc_name = "Resize Volume"
resize_vol = 6
try:
self.dbaas.instances.resize_volume(self.instance_id, resize_vol)
status = testutil.getInstanceStatus(self.dbaas, self.instance_id)
# check interim status of RESIZE
self.assertEqual(status,
"RESIZE",
"Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#Get the new volume size
volume_size = self.dbaas.instances.get(self.instance_id).volume["size"]
self.assertEqual(resize_vol, volume_size,
"Error: Flavors do not match: %s != %s"
% (resize_vol, volume_size))
if self.stability_mode:
testutil.write_to_report(tc_name, tc_pass=True)
except Exception as e:
if self.stability_mode:
testutil.write_to_error_report(self.instance_id, repr(e))
testutil.write_to_report(tc_name, tc_pass=False)
raise
def test_create_multi_user_with_multi_db(self):
_db_name1 = "multi_user_with_multi-database"
_db_name2 = "multi_user_with_multi-db2"
_databases = [{"name": _db_name1},
{"name": _db_name2}]
_test_users = []
_test_users.append({"name": "F343jasdf_",
"password": "******",
"databases": _databases})
_test_users.append({"name": "403F23F343jasdf",
"password": "******",
"databases": _databases})
_test_users.append({"name": "easy_user_name",
"password": "******",
"databases": _databases})
self.dbaas.users.create(self.instance_id, _test_users)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#print (self.instance_id)
self.assertTrue(testutil.getInstanceStatus(self.dbaas,
instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
#Get the instance and check user dbs
_user_list = self.dbaas.users.list(self.dbaas.instances.get(self.instance_id))
#self.assertTrue(len(_user_list) == len(_test_users), "Expected %s user: Got: %s "
# % (len(_test_users), len(_user_list)))
for _user in _user_list:
self.assertEqual(_user.databases, _databases)
#try to find our user in the list
self.assertTrue(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
userName=_user.name),
"Did not find our user name: %s in the list." % _user.name)
self.dbaas.users.delete(self.instance_id, _user.name)
self.assertFalse(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
userName=_user.name),
"Delete error: Found user name: %s in the list." % _user.name)
def test_usage_02_resize_flavor_up(self):
""" Dynamically increase the memory size of an instance """
tc_name = "Usage 02 tests"
tc_num = 02
NEW_FLAVOR_UP = 4
instance_id = self.instance_id_list[0]
# insure instance was ACTIVE for 10 minutes
running_time = (datetime.utcnow() - self.starttime_list[tc_num]).seconds
if 10 * self.ONEMIN > running_time:
time.sleep((10 * self.ONEMIN) - running_time)
# resize the instance UP
rootAction = "reddwarf.instance.modify_flavor"
response = self.client.instances.resize_instance(instance_id, NEW_FLAVOR_UP)
self.assertEqual(
str(testutil.get_last_response_code(self.client)),
"202",
"Error: Resize instance. Unexpected resp code: %r != %r"
% (str(testutil.get_last_response_code(self.client)), "202"),
)
# wait for it to return to Active
testutil.wait_for_status(self.client, instance_id, "RESIZE")
status, elapsed_time = testutil.waitForActive(self.client, instanceId=instance_id)
self.fixture_log.debug("Inst: %r is: %r after: %r seconds" % (instance_id, status, elapsed_time))
duration = datetime.utcnow() - self.starttime_list[tc_num]
startTime = datetime.utcnow()
# AH Event Sent - Check instance as a result of RESIZE
time.sleep(self.AHDELAY)
AHEventsList = self.dbaas_atomhopper_provider.events_by_resourceId(instance_id)
single_event = [event for event in AHEventsList if event.rootAction == rootAction].pop()
self.assertEqual(
single_event.resourceId,
instance_id,
"AH resourceID:%r != created instanceID:%r" % (single_event.resourceId, instance_id),
)
testutil.valid_duration(duration, single_event, self.dateFormat)
self.instance = self.client.instances.get(instance_id)
self.assertEqual(
str(NEW_FLAVOR_UP),
self.instance.flavor["id"],
"Error: Expected flavor of: %r != Actual flavor: %r" % (str(NEW_FLAVOR_UP), self.instance.flavor["id"]),
)
time.sleep(5 * self.ONEMIN)
# Capture the duration and delete the instance
if testutil.getInstanceStatus(self.client, instance_id) == "ACTIVE":
self.client.instances.get(instance_id).delete()
self.instance_id_list.remove(instance_id)
duration = datetime.utcnow() - startTime
rootAction = "reddwarf.instance.delete"
# AH Event Sent - Check instance data AFTER the DELETE
time.sleep(self.AHDELAY)
AHEventsList = self.dbaas_atomhopper_provider.events_by_resourceId(instance_id)
single_event = [event for event in AHEventsList if event.rootAction == rootAction].pop()
self.assertEqual(
single_event.resourceId,
instance_id,
"AH resourceID:%r != created instanceID:%r" % (single_event.resourceId, instance_id),
)
testutil.valid_duration(duration, single_event, self.dateFormat)
def test_create_2_users_instance(self):
"""
Creating an instance for smoke testing
"""
dbaas = self.dbaas_provider.client.reddwarfclient
NAME = "qe-2users-instance"
FLAVOR = 1
VOLUME = 10
databases = []
databases.append({"name": "firstdb",
"character_set": "latin2",
"collate": "latin2_general_ci"})
users = []
users.append({"name": "lite",
"password": "******",
"databases": [{"name": "firstdb"}]})
users.append({"name": "lite1",
"password": "******",
"databases": [{"name": "firstdb"}]})
instance = dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME},
databases=databases,
users=users)
httpCode = testutil.get_last_response_code(dbaas)
self.multi_users_instance_id = instance.id
self.assertTrue(httpCode == '200',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=instance.id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=instance.id) == 'ACTIVE',
"Instance is not in Active statue")
#Get the instance and check instance attribs: such as the flavor / volume size
instance = self.dbaas.instances.get(instance)
self.assertTrue(instance.flavor['id'] == str(FLAVOR))
self.assertTrue(instance.volume['size'] == VOLUME)
self.assertTrue(instance.name == NAME)
#try to find our instance in the list
self.assertTrue(testutil.found_resource(self.dbaas, instanceId=instance.id),
"Did not find our instance id: %s in the list." % instance.id)
def setUpClass(cls):
"""
Creating an instance for database testing
"""
super(test_users, cls).setUpClass()
test_users.dbaas = cls.dbaas_provider.client.reddwarfclient
NAME = "qe-user-testing"
FLAVOR = 1
VOLUME = 1
instance = test_users.dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME})
httpCode = testutil.get_last_response_code(test_users.dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" % httpCode)
test_users.instance_id = instance.id
testutil.waitForActive(test_users.dbaas, instanceId=test_users.instance_id)
def test_resize_instance(self):
"""
test resize of instance
"""
tc_name = "Resize Instance"
next_flavor = 1
final_flavor = 2
try:
self.dbaas.instances.resize_instance(self.instance_id, next_flavor)
status = testutil.getInstanceStatus(self.dbaas, self.instance_id)
self.assertEqual(status, "RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#get the new flavorId
flavorId = self.dbaas.instances.get(self.instance_id).flavor["id"]
self.assertEqual(str(next_flavor), flavorId,
"Error: Flavors do not match: %s != %s"
% (next_flavor, flavorId))
self.dbaas.instances.resize_instance(self.instance_id, final_flavor)
status = testutil.getInstanceStatus(self.dbaas, self.instance_id)
self.assertEqual(status, "RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#get the new flavorId
flavorId = self.dbaas.instances.get(self.instance_id).flavor["id"]
self.assertEqual(str(final_flavor), flavorId,
"Error: Flavors do not match: %s != %s"
% (final_flavor, flavorId))
if self.stability_mode:
testutil.write_to_report(tc_name, tc_pass=True)
except Exception as e:
if self.stability_mode:
testutil.write_to_error_report(self.instance_id, repr(e))
testutil.write_to_report(tc_name, tc_pass=False)
raise
def setUpClass(cls):
"""
Creating an instance for database testing
"""
super(TestMalformedData, cls).setUpClass()
cls.client_neg_testing = cls.dbaas_provider.client
cls.auth_data = cls.dbaas_provider.auth_provider.authenticate()
cls.dbaas = cls.dbaas_provider.client.reddwarfclient
NAME = "qe-database-testing"
FLAVOR = 1
VOLUME = 1
instance = cls.dbaas.instances.create(
name=NAME,
flavor_id=FLAVOR,
volume={"size": VOLUME})
httpCode = testutil.get_last_response_code(cls.dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" % httpCode)
cls.instance_id = instance.id
#status = instance.status
testutil.waitForActive(cls.dbaas, instanceId=cls.instance_id)
def test_change_user_pw(self):
"""
Changes the password of a user
Issue: You cannot verify the new password since that is
never returned from the server.
@return:
"""
_db_name1 = "test_change_user_pw"
_db_name2 = "test_change_user_pw2"
_databases = [{"name": _db_name1},
{"name": _db_name2}]
_test_user = []
_user_name = "F343jasdf1234"
_test_user.append({"name": _user_name,
"password": "******",
"databases": _databases})
self.dbaas.users.create(self.instance_id, _test_user)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
_test_user[0]['password'] = "******"
self.dbaas.users.change_passwords(self.instance_id, _test_user)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
self.dbaas.users.delete(self.instance_id, _user_name)
self.assertFalse(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
userName=_user_name),
"Delete error: Found user name: %s in the list." % _user_name)
def setUpClass(cls):
"""
Creating an instance for smoke testing
"""
tc_name = "Create Instance"
super(SmokeTest, cls).setUpClass()
cls.dbaas = cls.client.reddwarfclient
if cls.stability_mode == 'True':
cls.stability_mode = True
else:
cls.stability_mode = False
cls.NAME = "qe-smoke"
cls.FLAVOR = 4
cls.VOLUME = 1
try:
instance = cls.dbaas.instances.create(
name=cls.NAME,
flavor_id=cls.FLAVOR,
volume={"size": cls.VOLUME},
databases=[{"databases": [{"name": "databaseA"}],
"name": "dbuser1",
"password": "******"}])
httpCode = testutil.get_last_response_code(SmokeTest.dbaas)
if httpCode != '200':
raise Exception("Create instance failed with code %s" % httpCode)
cls.instance_id = instance.id
#status = instance.status
testutil.waitForActive(cls.dbaas, instanceId=cls.instance_id)
if cls.stability_mode:
testutil.write_to_report(tc_name, tc_pass=True)
except Exception as e:
if cls.stability_mode:
testutil.write_to_error_report(cls.instance_id, repr(e))
testutil.write_to_report(tc_name, tc_pass=False)
raise
def test_resize_volume_instance(self):
"""
Resize the volume of an instance
"""
dbaas = self.dbaas_provider.client.reddwarfclient
if testutil.isInstanceActive(dbaas, instanceId=self.instance_id):
dbaas.instances.resize_volume(self.instance_id, self.ResizeUpSizes.lev1)
httpCode = testutil.get_last_response_code(dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=self.instance_id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
newVolume = dbaas.instances.get(self.instance_id).volume['size']
self.assertTrue(newVolume == self.ResizeUpSizes.lev1, "Expected new volume size %s: Got %s "
% (self.ResizeUpSizes.lev1, newVolume))
if testutil.isInstanceActive(dbaas, instanceId=self.instance_id):
dbaas.instances.resize_volume(self.instance_id, self.ResizeUpSizes.lev2)
httpCode = testutil.get_last_response_code(dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=self.instance_id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
newVolume = dbaas.instances.get(self.instance_id).volume['size']
self.assertTrue(newVolume == self.ResizeUpSizes.lev2, "Expected new volume size %s: Got %s "
% (self.ResizeUpSizes.lev2, newVolume))
if testutil.isInstanceActive(dbaas, instanceId=self.instance_id):
dbaas.instances.resize_volume(self.instance_id, self.ResizeUpSizes.lev3)
httpCode = testutil.get_last_response_code(dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(dbaas, instanceId=self.instance_id)
self.assertTrue(testutil.getInstanceStatus(dbaas, instanceId=self.instance_id) == 'ACTIVE',
"Instance is not in Active statue")
newVolume = dbaas.instances.get(self.instance_id).volume['size']
self.assertTrue(newVolume == self.ResizeUpSizes.lev3, "Expected new volume size %s: Got %s "
% (self.ResizeUpSizes.lev3, newVolume))
def test_usage_05_restart_mysql(self):
""" Restart MySQL then Delete one instance after 10 minutes """
tc_name = "Usage 05 tests"
tc_num = 05
instance_id = self.instance_id_list[0]
self.client.instances.restart(instance_id)
self.assertEqual(
str(testutil.get_last_response_code(self.client)),
"202",
"Error: Resize instance. Unexpected resp code: %r != %r"
% (str(testutil.get_last_response_code(self.client)), "202"),
)
# check interim status of REBOOT
testutil.wait_for_status(self.client, instance_id, "REBOOT")
# wait for active, ensure time elapsed, record the duration
status, elapsed_time = testutil.waitForActive(self.client, instanceId=instance_id)
self.fixture_log.debug("Inst: %r is: %r after: %r seconds" % (instance_id, status, elapsed_time))
running_time = (datetime.utcnow() - self.starttime_list[tc_num]).seconds
if 10 * self.ONEMIN > running_time:
time.sleep((10 * self.ONEMIN) - running_time)
# delete the ACTIVE instance
if testutil.getInstanceStatus(self.client, instance_id) == "ACTIVE":
self.client.instances.get(instance_id).delete()
self.instance_id_list.remove(instance_id)
duration = datetime.utcnow() - self.starttime_list[tc_num]
rootAction = "reddwarf.instance.delete"
# AH Event Sent - Check AH data data AFTER the DELETE
time.sleep(self.AHDELAY)
AHEventsList = self.dbaas_atomhopper_provider.events_by_resourceId(instance_id)
single_event = [event for event in AHEventsList if event.rootAction == rootAction].pop()
self.assertEqual(
single_event.resourceId,
instance_id,
"AH resourceID:%r != created instanceID:%r" % (single_event.resourceId, instance_id),
)
testutil.valid_duration(duration, single_event, self.dateFormat)
def test_rbac_instance_admin_rights(self):
next_flavor = 1
final_flavor = 2
resize_vol = 5
try:
# list instances
instancesList = self.dbaas_admin.instances.list()
self.assertIsNotNone(instancesList)
httpCode = testutil.get_last_response_code(self.dbaas_admin)
self.assertTrue(httpCode == '200', "DB List: Expected http code: %s | Actual http code: %s "
% ('200', httpCode))
# list instance details
current_instance = self.dbaas_admin.instances.get(self.admin_instance_id)
self.assertIsNotNone(current_instance)
httpCode = testutil.get_last_response_code(self.dbaas_admin)
self.assertTrue(httpCode == '200', "DB List Get Id:Expected http code: %s | Actual http code: %s "
% ('200', httpCode))
#Enable root
user_name, user_password = self.dbaas_admin.root.create(self.admin_instance_id)
httpCode = testutil.get_last_response_code(self.dbaas_admin)
self.assertTrue(httpCode == '200',
"DB Enable Root: Expected http code: %s | Actual http code: %s "
% ('200', httpCode))
self.assertEqual(user_name, 'root', "Error: user name is not root")
self.assertIsNotNone(user_password, "Error: root password is None")
# finally, verify root has been enabled for the instance
self.assertTrue(self.dbaas_admin.root.is_root_enabled(self.admin_instance_id),
"Error: root is not enabled")
# resize instance
self.dbaas_admin.instances.resize_instance(self.admin_instance_id, next_flavor)
httpCode = testutil.get_last_response_code(self.dbaas_admin)
self.assertTrue(httpCode == '202', "DB Resize: Expected http code: %s | Actual http code: %s "
% ('202', httpCode))
status = testutil.getInstanceStatus(self.dbaas_admin, self.admin_instance_id)
self.assertEqual(status, "RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas_admin, instanceId=self.admin_instance_id)
#get the new flavorId
flavorId = self.dbaas_admin.instances.get(self.admin_instance_id).flavor["id"]
self.assertEqual(str(next_flavor), flavorId,
"Error: Flavors do not match: %s != %s"
% (next_flavor, flavorId))
#resize again
self.dbaas_admin.instances.resize_instance(self.admin_instance_id, final_flavor)
status = testutil.getInstanceStatus(self.dbaas_admin, self.admin_instance_id)
self.assertEqual(status, "RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas_admin, instanceId=self.admin_instance_id)
#get the new flavorId
flavorId = self.dbaas_admin.instances.get(self.admin_instance_id).flavor["id"]
self.assertEqual(str(final_flavor), flavorId,
"Error: Flavors do not match: %s != %s"
% (final_flavor, flavorId))
#restart instance
self.dbaas_admin.instances.restart(self.admin_instance_id)
httpCode = testutil.get_last_response_code(self.dbaas_admin)
self.assertTrue(httpCode == '202',
"DB Restart: Expected http code: %s | Actual http code: %s "
% ('202', httpCode))
status = testutil.getInstanceStatus(self.dbaas_admin, self.admin_instance_id)
self.assertEqual(status,
"REBOOT", "Error: instance is not REBOOT, it is: %s" % status)
testutil.waitForActive(self.dbaas_admin, instanceId=self.admin_instance_id)
#resize instance volume
self.dbaas_admin.instances.resize_volume(self.admin_instance_id, resize_vol)
httpCode = testutil.get_last_response_code(self.dbaas_admin)
self.assertTrue(httpCode == '202',
"DB Reboot: Expected http code: %s | Actual http code: %s "
% ('202', httpCode))
status = testutil.getInstanceStatus(self.dbaas_admin, self.admin_instance_id)
self.assertEqual(status,
"RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas_admin, instanceId=self.admin_instance_id)
#Get the new volume size
volume_size = self.dbaas_admin.instances.get(self.admin_instance_id).volume["size"]
self.assertEqual(resize_vol, volume_size,
"Error: Flavors do not match: %s != %s"
% (resize_vol, volume_size))
except Exception as e:
self.fail(e)
def test_user_access(self):
_db_name1 = "test_user_access-database"
_db_name2 = "test_user_access-db2"
_databases = [{"name": _db_name1},
{"name": _db_name2}]
_test_users = []
_user_name = "F343jasdfasdf"
_test_users.append({"name": _user_name,
"password": "******",
"databases": _databases})
self.dbaas.users.create(self.instance_id, _test_users)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
testutil.waitForActive(self.dbaas, instanceId=self.instance_id)
#Validate access to the databases just created
for _test_user in _test_users:
_username = _test_user['name']
_db_access_list = self.dbaas.users.list_access(self.instance_id, _username)
#create a dict to compare with
_db_actual_list = []
for db_list in _db_access_list:
_db_actual = {'name': db_list.name}
_db_actual_list.append(_db_actual)
self.assertEqual(_databases, _db_actual_list,
"Expected %s | Actual %s"
% (_databases, _db_actual_list))
#Revoke access to the dbs
db_count = 2
for _test_user in _test_users:
_username = _test_user['name']
for _db in _databases:
self.dbaas.users.revoke(self.instance_id, _username, _db['name'])
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
db_count -= 1
_db_access_list = self.dbaas.users.list_access(self.instance_id, _username)
self.assertEqual(len(_db_access_list), db_count)
_db_actual_list = []
for db_list in _db_access_list:
_db_actual = {'name': db_list.name}
_db_actual_list.append(_db_actual)
self.assertNotEqual(_databases, _db_actual_list,
"Expected %s | Actual %s"
% (_databases, _db_actual_list))
#Grant access to the dbs
db_count = 0
for _test_user in _test_users:
_username = _test_user['name']
for _db in _databases:
_db_list = [_db['name']]
self.dbaas.users.grant(self.instance_id, _username, _db_list)
httpCode = testutil.get_last_response_code(self.dbaas)
self.assertTrue(httpCode == '202',
"Create instance failed with code %s" % httpCode)
db_count += 1
_db_access_list = self.dbaas.users.list_access(self.instance_id, _username)
self.assertEqual(len(_db_access_list), db_count,
"Expected database count %s, Actual DBs found %s"
% (db_count, _db_access_list))
_db_actual_list = []
for db_list in _db_access_list:
_db_actual = {'name': db_list.name}
_db_actual_list.append(_db_actual)
if db_count != 2:
self.assertNotEqual(_databases, _db_actual_list,
"Expected %s | Actual %s"
% (_databases, _db_actual_list))
else:
self.assertEqual(_databases, _db_actual_list,
"Expected %s | Actual %s"
% (_databases, _db_actual_list))
self.dbaas.users.delete(self.instance_id, _user_name)
self.assertFalse(testutil.found_resource(self.dbaas,
instanceId=self.instance_id,
userName=_user_name),
"Delete error: Found user name: %s in the list." % _user_name)
def test_usage_06_resize_reboot_volume_up(self):
""" Resize the Volume Storage and then reboot, ensure only two AH events """
tc_name = "Usage 06 tests"
tc_num = 06
NEW_VOLUME = 6
instance_id = self.instance_id_list[0]
running_time = (datetime.utcnow() - self.starttime_list[tc_num]).seconds
if 10 * self.ONEMIN > running_time:
time.sleep((10 * self.ONEMIN) - running_time)
# resize the instance UP
rootAction = "reddwarf.instance.modify_volume"
response = self.client.instances.resize_volume(instance_id, NEW_VOLUME)
self.assertEqual(
str(testutil.get_last_response_code(self.client)),
"202",
"Error: Resize instance. Unexpected resp code: %r != %r"
% (str(testutil.get_last_response_code(self.client)), "202"),
)
testutil.wait_for_status(self.client, instance_id, "RESIZE")
status, elapsed_time = testutil.waitForActive(self.client, instanceId=instance_id)
self.fixture_log.debug("Inst: %r is: %r after: %r seconds" % (instance_id, status, elapsed_time))
duration = datetime.utcnow() - self.starttime_list[tc_num]
startTime = datetime.utcnow()
# AH Event Sent - Check instance as a result of RESIZE
time.sleep(self.AHDELAY * 2)
AHEventsList = self.dbaas_atomhopper_provider.events_by_resourceId(instance_id)
single_event = [event for event in AHEventsList if event.rootAction == rootAction].pop()
self.assertEqual(
single_event.resourceId,
instance_id,
"AH resourceID:%r != created instanceID:%r" % (single_event.resourceId, instance_id),
)
testutil.valid_duration(duration, single_event, self.dateFormat)
self.instance = self.client.instances.get(instance_id)
# confirm the new flavor
self.assertEqual(
NEW_VOLUME,
self.instance.volume["size"],
"Error: Expected flavor of: %r != Actual flavor: %r" % (NEW_VOLUME, self.instance.volume["size"]),
)
time.sleep(2 * self.ONEMIN)
# restart the instance
self.mgmt_client.management.reboot(instance_id)
self.assertEqual(
str(testutil.get_last_response_code(self.client)),
"200",
"Error: Resize instance. Unexpected resp code: %r != %r"
% (str(testutil.get_last_response_code(self.client)), "200"),
)
testutil.wait_for_status(self.client, instance_id, "REBOOT")
status, elapsed_time = testutil.waitForActive(self.client, instanceId=instance_id)
self.fixture_log.debug("Inst: %r is: %r after: %r seconds" % (instance_id, status, elapsed_time))
time.sleep(2 * self.ONEMIN)
# Capture the duration and delete the instance
if testutil.getInstanceStatus(self.client, instance_id) == "ACTIVE":
self.client.instances.get(instance_id).delete()
self.instance_id_list.remove(instance_id)
duration = datetime.utcnow() - startTime
rootAction = "reddwarf.instance.delete"
# AH Event Sent - Check instance data AFTER the DELETE
time.sleep(self.AHDELAY)
AHEventsList = self.dbaas_atomhopper_provider.events_by_resourceId(instance_id)
single_event = [event for event in AHEventsList if event.rootAction == rootAction].pop()
self.assertEqual(
single_event.resourceId,
instance_id,
"AH resourceID:%r != created instanceID:%r" % (single_event.resourceId, instance_id),
)
testutil.valid_duration(duration, single_event, self.dateFormat)
def test_rbac_instance_creator_rights(self):
next_flavor = 1
final_flavor = 2
current_instance = None
resize_vol = 5
try:
# list instances
instancesList = self.dbaas_creator.instances.list()
self.assertIsNotNone(instancesList)
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '200',
"DB list: Expected http code: %s | Actual http code: %s "
% ('200', httpCode))
# list instance details
current_instance = self.dbaas_creator.instances.get(self.creator_instance_id)
self.assertIsNotNone(current_instance)
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '200',
"DB list get ID: Expected http code: %s | Actual http code: %s "
% ('200', httpCode))
try:
#Enable root
self.dbaas_creator.root.create(self.creator_instance_id)
except Exception as e:
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '405',
"Expected http code: %s | Actual http code: %s "
% ('405', httpCode))
self.dbaas_creator.root.is_root_enabled(self.creator_instance_id)
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '200',
"Expected http code: %s | Actual http code: %s "
% ('200', httpCode))
# resize instance
self.dbaas_creator.instances.resize_instance(self.creator_instance_id, next_flavor)
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '202',
"DB Resize instance: Expected http code: %s | Actual http code: %s "
% ('202', httpCode))
status = testutil.getInstanceStatus(self.dbaas_creator, self.creator_instance_id)
self.assertEqual(status, "RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas_creator, instanceId=self.creator_instance_id)
#get the new flavorId
flavorId = self.dbaas_creator.instances.get(self.creator_instance_id).flavor["id"]
self.assertEqual(str(next_flavor), flavorId,
"Error: Flavors do not match: %s != %s"
% (next_flavor, flavorId))
#resize again
self.dbaas_creator.instances.resize_instance(self.creator_instance_id, final_flavor)
status = testutil.getInstanceStatus(self.dbaas_creator, self.creator_instance_id)
self.assertEqual(status, "RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas_creator, instanceId=self.creator_instance_id)
#get the new flavorId
flavorId = self.dbaas_creator.instances.get(self.creator_instance_id).flavor["id"]
self.assertEqual(str(final_flavor), flavorId,
"Error: Flavors do not match: %s != %s"
% (final_flavor, flavorId))
#restart instance
self.dbaas_creator.instances.restart(self.creator_instance_id)
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '202',
"DB Restart: Expected http code: %s | Actual http code: %s "
% ('202', httpCode))
status = testutil.getInstanceStatus(self.dbaas_creator, self.creator_instance_id)
self.assertEqual(status,
"REBOOT", "Error: instance is not REBOOT, it is: %s" % status)
testutil.waitForActive(self.dbaas_creator, instanceId=self.creator_instance_id)
#resize instance volume
self.dbaas_creator.instances.resize_volume(self.creator_instance_id, resize_vol)
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '202',
"DB Resize volume: Expected http code: %s | Actual http code: %s "
% ('202', httpCode))
status = testutil.getInstanceStatus(self.dbaas_creator, self.creator_instance_id)
self.assertEqual(status,
"RESIZE", "Error: instance is not RESIZE, it is: %s" % status)
testutil.waitForActive(self.dbaas_creator, instanceId=self.creator_instance_id)
#Get the new volume size
volume_size = self.dbaas_creator.instances.get(self.creator_instance_id).volume["size"]
self.assertEqual(resize_vol, volume_size,
"Error: Flavors do not match: %s != %s"
% (resize_vol, volume_size))
#Delete an instance
try:
self.dbaas_creator.instances.get(self.creator_instance_id).delete()
except Exception as e:
httpCode = testutil.get_last_response_code(self.dbaas_creator)
self.assertTrue(httpCode == '405',
"DB Instance Delete: Expected http code: %s | Actual http code: %s "
% ('405', httpCode))
except Exception as e:
self.fail(e)
def test_reboot_instance(self):
expected_status = "REBOOT"
expected_status_found = False
expected_task_desc = "No tasks for the instance."
initial_updated = ""
# list instance details and store updated time value
instance_details = test_actions.mgmt_dbaas.management.show( \
self.instance)
httpCode = testutil.get_last_response_code(test_actions.mgmt_dbaas)
if httpCode != '200':
raise Exception("List instance details failed with code %s" %
httpCode)
initial_updated = instance_details.updated
self.fixture_log.debug("\t\tInstance %r initial update on %r" %
(instance_details.id, initial_updated))
# call reboot instance
try:
self.mgmt_dbaas.management.reboot(self.instance_id)
httpCode = testutil.get_last_response_code(self.mgmt_dbaas)
self.assertTrue(httpCode == '202',
"Reboot instance failed with code %s" %
httpCode)
except Exception as e:
self.fixture_log.debug("\tException: %r" % (e))
raise
# check instance for Reboot status
current_status, elapsed = testutil.wait_for_status(self.mgmt_dbaas,
self.instance_id,
expected_status)
self.fixture_log.debug("\t\tInstance status encountered: %r" %
(current_status))
self.assertEqual(current_status, expected_status,
"Expected status %r , Actual status %r" %
(expected_status, current_status))
if current_status == expected_status:
expected_status_found = True
self.fixture_log.debug("\t\tExpected status found? %r" %
(expected_status_found))
# verify it comes up in an Active state
status, elapsed = testutil.waitForActive(self.mgmt_dbaas,
instanceId=self.instance_id)
self.fixture_log.debug("\t\tInstance status encountered: %r" %
(status))
self.assertEqual(status, 'ACTIVE',
"Expected status %r , Actual status %r" %
('ACTIVE', status))
# make final checks
self.assertTrue(expected_status_found,
"Expected status %r was not seen!" %
(expected_status))
instance_details = test_actions.mgmt_dbaas.management.show( \
self.instance)
httpCode = testutil.get_last_response_code(test_actions.mgmt_dbaas)
if httpCode != '200':
raise Exception("List instance details failed with code %s" %
httpCode)
self.assertTrue(initial_updated != instance_details.updated,
"Instance %r was not updated!" %
(instance_details.id))
self.fixture_log.debug("\t\tInstance %r final update on %r" %
(instance_details.id, instance_details.updated))
