def verify_create(self, response): """ Verification is done only for the response status code :param response: Create response which needs to be verified """ self.status = True self.step_desc = 'Innotas Asset create verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) read_response = '' if response.status_code == 201: entity_id = response.json()['id'] read_response = self.read({'entity_id': entity_id}) if read_response.status_code == 200: self.remarks += 'Asset is created' else: self.status = False self.remarks += 'asset creation failed \n failure traceback : {}'.format( response.text) else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return read_response, entity_id
def verify_import(self, response): """ Verification is done only for the response status code :param response: Create response which needs to be verified """ self.status = True self.step_desc = 'Innotas Data Import verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) if response.status_code == 200: json_resp = response.json() err_count = json_resp.get('errCount') if err_count == 'Sheet1 unable to be created : 0' or err_count == 'Sheet1 unable to be updated : 0': self.remarks += '\nDataImport is executed' else: self.status = False err_msg = json_resp.get('err_msg') self.remarks += '\n Import error \n{}'.format(err_msg) else: self.status = False self.remarks += 'Data Import failed \n Response status is not 200 \n Failure response : {}'.format( response.text) db_wrapper.log_into_steps(self.request, self) assert self.status
def verify(self): """ This mehod will generate expected dict from the data store and actual dict is generated from read operation of the project entity :return: status """ self.status = True self.step_desc = 'Task update verification' from core import utils self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) expected_dct = self.db_store.search_by_key(ENTITY, 'taskRoleId', str(self.task_role_id))[0] self.step_input = '\n Expected Dictionary\n{}'.format( json.dumps(expected_dct)) response = super().read(entity_id=self.task_id) actual_dct = utils.get_sub_dct(response, expected_dct) self.step_input += '\n Actual Dictionary\n{}'.format( json.dumps(actual_dct)) try: self.status, remark = self.asserter.verify( actual_dct, expected_dct=expected_dct) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) assert self.status return self
def verify_create(self, response, **data): self.status = True self.step_desc = 'Innotas Resource create verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = response.text read_response = '' if response.status_code == 200: read_response = self.read(data['firstname'], 'auto_bots') expected_title = ", ".join(['auto_bots', data['firstname']]) if read_response.status_code == 200: data = read_response.json()['data'] is_resource_created = False for resource in data: if expected_title.lower() == resource['t_title'].lower(): id = resource['id'] self.remarks += 'Resource is created' is_resource_created = True if not is_resource_created: self.status = False self.remarks += 'resource creation failed \n failure traceback : {}'.format( response.text) else: self.status = False self.remarks += 'resource creation failed \n failure traceback : {}'.format( response.text) else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return read_response, id
def verify(self): """ This mehod will generate expected dict from the data store and actual dict is generated from read operation of the task entity :return: status """ self.status = True self.step_desc = 'Task update verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) data_store = self.request.getfixturevalue('data_store').get() expected_dct = data_store[ENTITY][self.task_id] title = expected_dct.get('title') encoded_title = utils.html_encode(title) expected_dct.update({'title': encoded_title}) if expected_dct.get('description'): description = expected_dct.get('description') encoded_desc = utils.html_encode(description) expected_dct.update({'description': encoded_desc}) self.step_input = json.dumps(expected_dct) response = super().read(entity_id=self.task_id) actual_dct = response.json()['data'][0] try: self.status, remark = self.asserter.verify( actual_dct, expected_dct=expected_dct) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) assert self.status return self
def verify_create(self, response): self.status = True self.step_desc = 'Innotas Task create verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() self.step_input = '\n Response \n{}\n'.format(response.text) read_response = '' entity_id = '' if response.status_code == 200: entity_id = response.json()['newTaskId'] read_response = self.read(entity_id=entity_id) if read_response.status_code == 200: self.remarks += 'Task is created' else: self.status = False self.remarks += 'task creation failed \n failure traceback : {}'.format( response.text) else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return read_response, entity_id
def _verify_asset(self, expected_dct): """ Verification of single issue creation via data-import using new-asset-template. 1) Read details, additional-details and settings of projects and combine them to form actual_dct 2) Verify the expected_dct with actual_dct """ self.status = True self.step_desc = 'Data Import of Asset verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() self.step_input = '\n Expected Dictionary\n{}'.format(json.dumps(expected_dct)) asset = Asset(self.request) read_category_resp = asset.read_category() class_id = utils.filter_dct_for_key('title', expected_dct['asset category'], 'classId.value', read_category_resp.json())[0] read_response = asset.read_title(expected_dct['title'], class_id) actual_dct = helper.get_formatted_dct(read_response.json()) self.step_input += '\n Actual Dictionary\n{}'.format(json.dumps(actual_dct)) asset.asset_id = read_response.json()['id'] expected_dct = helper.lower_keys(expected_dct) actual_dct = helper.lower_keys(actual_dct) try: self.status, remark = self.asserter.verify(actual_dct, expected_dct) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) return
def _verify_issue(self, expected_dct): """ Verification of single issue creation via data-import using new-issue-template. 1) Read details, additional-details and settings of projects and combine them to form actual_dct 2) Verify the expected_dct with actual_dct """ self.status = True self.step_desc = 'Data Import of Issue verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() self.step_input = '\n Expected Dictionary\n{}'.format(json.dumps(expected_dct)) issue = Issue(self.request) read_response = issue.read_title(expected_dct['title']) actual_dct = helper.get_formatted_dct(read_response.json()) self.step_input += '\n Actual Dictionary\n{}'.format(json.dumps(actual_dct)) issue.issue_id = read_response.json()['id'] expected_dct = helper.lower_keys(expected_dct) actual_dct = helper.lower_keys(actual_dct) # TODO: Removal of this ignore_keys ignore_keys = ['udf issu multi-select list'] try: self.status, remark = self.asserter.verify(actual_dct, expected_dct, ignore_keys) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) return
def verify_create(self, response, timesheet_id): self.status = True self.step_desc = 'Timesheet create verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) read_response = '' if response.status_code == 200: # Read the timesheet and corresponding internal rates from timeadmin perspective read_response = self.read_by_timeadmin(timesheet_id) if read_response.status_code == 200: self.remarks += 'Timesheet is created' else: self.status = False self.remarks += 'project creation failed \n failure traceback : {}'.format( response.text) else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return read_response
def verify_update(self, entity_id, response): self.status = True self.step_desc = 'Task update verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() self.step_input = '\n Response \n{}\n'.format(response.text) if response.status_code == 200: self.remarks += 'Task updated successfully' else: self.status = False self.remarks += 'Task updation failed : {}'.format(response.text) db_wrapper.log_into_steps(self.request, self) assert self.status
def verify_update(self, response, **data): self.status = True self.step_desc = 'User rate update verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) ds = self.db_store.search_by_key('user', 'resource_id', data['resource_id']) if ds: rates = ds[0]['rates'] if not rates: rates = [] else: rates = [] if response.status_code == 200: read_response = self.read(**data) if read_response.status_code == 200: actual_dct = read_response.json() expected_dct = data status = False for effectiverate in actual_dct['effectiveRates']: # TODO: effective date verification if effectiverate['rateId'] == int(expected_dct['rate_id']): user_rate_row_id = effectiverate['id'] effective_date = expected_dct['effective_date'] rate_id = effectiverate['rateId'] rates.append({ 'rate_id': rate_id, 'generated_id': user_rate_row_id, 'effective_date': effective_date }) status = True self.remarks += 'User rate is updated' assert status else: self.status = False self.remarks += 'User rate updation failed \n failure traceback : {}'.format( response.text) else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return rates
def _verify_portfolio(self, expected_dct): """ Verification of portfolio creation via data-import using new-portfolio-template. 1) Read details, finance of portfolio and combine them to form actual_dct 2) Verify the expected_dct with actual_dct """ self.status = True self.step_desc = 'Data Import of Portfolio verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() self.step_input = '\n Expected Dictionary\n{}'.format(json.dumps(expected_dct)) portfolio = Portfolio(self.request) read_category_resp = portfolio.read_category() category = expected_dct['category'].replace('Portfolio - ', '') category = category.replace('Port - ', '') class_id = utils.filter_dct_for_key('title', category, 'classId.value', read_category_resp.json())[0] read_title_resp = portfolio.read_title(expected_dct['title'], class_id) act_portfolio_details = helper.get_formatted_dct(read_title_resp.json()) portfolio.portfolio_id = read_title_resp.json()['id'] read_finance_resp = portfolio.read_finance( {'entity_id': portfolio.portfolio_id}) act_portfolio_details_finance = helper.get_formatted_dct( read_finance_resp.json()) # Combine all the details to form the actual_dct actual_dct = OrderedDict() actual_dct.update( {act_portfolio_details, act_portfolio_details_finance}) self.step_input += '\n Actual Dictionary\n{}'.format(json.dumps(actual_dct)) expected_dct = helper.lower_keys(expected_dct) actual_dct = helper.lower_keys(actual_dct) ignore_keys = ['parent portfolio'] try: self.status, remark = self.asserter.verify(actual_dct, expected_dct, ignore_keys) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) return
def verify_create(self, response): self.status = True self.step_desc = 'Innotas Resource create verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) if response.status_code == 201: self.remarks += 'User is created' else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return response
def _verify_project(self, expected_dct): """ Verification of single project creation via data-import using new-project-template. 1) Read details, additional-details and settings of projects and combine them to form actual_dct 2) Verify the expected_dct with actual_dct """ self.status = True self.step_desc = 'Data Import of Project verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() self.step_input = '\n Expected Dictionary\n{}'.format(json.dumps(expected_dct)) project = Project(self.request) # Read details of project based on title. In UI, these details can be seen under 'Details' of project read_response = project.read_title(expected_dct['title']) act_project_details = helper.get_formatted_dct(read_response.json()) project.project_id = read_response.json()['id'] # Read additional details of project. In UI, these additional details can be seen under 'Executive Summary' of project read_response = project.read_more(project.project_id) act_project_details_more = helper.get_formatted_dct( read_response.json()) # Read settings of project. In UI, these additional details can be seen under 'Settings' of project read_response = project.read_settings(project.project_id) act_project_details_settings = helper.get_formatted_dct(read_response.json()) # Combine all the details to form the actual_dct actual_dct = OrderedDict() actual_dct.update({act_project_details, act_project_details_more, act_project_details_settings}) self.step_input += '\n Actual Dictionary\n{}'.format(json.dumps(actual_dct)) expected_dct = helper.lower_keys(expected_dct) actual_dct = helper.lower_keys(actual_dct) # ignore_keys = helper.get_ignore_keys(expected_dct, actual_dct) try: self.status, remark = self.asserter.verify(actual_dct, expected_dct) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) return
def verify_rollups(self): self.status = True self.step_desc = 'Project Rollup verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names() expected_dct = self.get_expected() self.step_input = '\n Expected Dictionary\n{}'.format(json.dumps(expected_dct)) actual_dct = self.get_actual() self.step_input += '\n Actual Dictionary\n{}'.format(json.dumps(actual_dct)) try: self.status, remark = Asserter().verify(actual_dct, expected_dct=expected_dct) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) assert self.status
def verify_update(self, response): """ verification of the response after the update on user rate in timesheet by timeadmin entity for the given timesheet row on a specific day and specific task :param response: response after update call """ self.status = True self.step_desc = 'Timeadmin updation of user rate in timesheet - verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) if response.status_code == 200: self.remarks += 'Timeadmin updated successfully' else: self.status = False self.remarks += 'Timeadmin updation of user rate in timesheet failed : {}'.format( response.text) db_wrapper.log_into_steps(self.request, self) assert self.status
def verify_create(self, response): self.status = True self.step_desc = 'Innotas Schedule verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) self.step_input = '\n Response \n{}\n'.format(response.text) taskRoleId = '' resourceTaskScheduleId = '' if response.status_code == 200: taskRoleId = response.json()['taskRoles'][1]['taskRoleId'] resourceTaskScheduleId = response.json( )['taskRoles'][1]['resourceTaskScheduleId'] else: self.status = False self.remarks += response.text db_wrapper.log_into_steps(self.request, self) assert self.status return taskRoleId, resourceTaskScheduleId
def verify(self): """ This mehod will generate expected dict from the data store and actual dict is generated from read operation of the project entity :return: status """ self.status = True self.step_desc = 'Project update verification' self.remarks = '\n Inside class: %s method: %s \n' % utils.get_method_class_names( ) expected_dct = self.db_store.search_by_key(ENTITY, 'id', self.project_id)[0] title = expected_dct.get('title') encoded_title = utils.html_encode(title) expected_dct.update({'title': encoded_title}) if expected_dct.get('description'): description = expected_dct.get('description') encoded_desc = utils.html_encode(description) expected_dct.update({'description': encoded_desc}) self.step_input = '\n Expected Dictionary\n{}'.format( json.dumps(expected_dct)) response = super().read(entity_id=self.project_id) actual_dct = response.json()['data'][0] self.step_input += '\n Actual Dictionary\n{}'.format( json.dumps(actual_dct)) try: self.status, remark = self.asserter.verify( actual_dct, expected_dct=expected_dct) self.remarks += remark except KeyError: self.status = False self.remarks += 'KeyError Exception occurred, please see stack trace below: \n %s' \ % traceback.format_exc() finally: db_wrapper.log_into_steps(self.request, self) assert self.status return self