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))