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
