def move(self, card_id, payload):
url = MOVE_URL.format(protocol=self.protocol, host_name=self.host_name)
response = self.req_session.post(url,
json=payload,
headers=self.headers)
dct_expected = payload['destination']
self.verify_move(card_id, response, dct_expected)
DataStore.update(Card.tbl_name, dct_expected, id=card_id)
print("*****LK_CARD TABLE*****\n", DataStore.read_all('LK_Card'))
def update_lk_details_in_ds():
lst_prj_details = DataStore.read_all('PRM_Project')
for prj_details in lst_prj_details:
if 'external_id' not in prj_details:
project_key = prj_details.get('id')
prm_verify_obj = PRMVerify()
external_id = prm_verify_obj.verify_lk_ext_id_in_prm(project_key)
update_external_id(Project.tbl_name, external_id, project_key)
update_card_details_in_ds(external_id, project_key)
print("*****update_lk_details_in_ds*****\n",
DataStore.read_all('PRM_Project'))
def update(self, payload):
soap_update_action, soap_payload = self.payload_gen.get_soap_details(
'project', 'update', payload)
soap = self.initialize_soap_request(self.cert, soap_payload,
soap_update_action)
response = self.request.post(self.soap_wsdl,
soap.body,
soap.header,
encoding='utf-8')
project_key = self.verify_create_update(response, dct_expected=payload)
DataStore.update(Project.tbl_name, payload, id=project_key)
print("*****PRM_PROJECT TABLE*****\n",
DataStore.read_all('PRM_Project'))
return response
def exists(self):
scode = helper.get_scode(self.project_key)
project_details = DataStore.read(self.table_name, id=self.project_key)
name = project_details['name']
self.prm_verify.project_name(scode, name)
return self
def create(self, payload):
create_url = CREATE_URL.format(protocol=self.protocol,
host_name=self.host_name)
response = self.req_session.post(url=create_url,
json=payload,
headers=self.headers)
card_id = self.verify_create_update(response, payload)
DataStore.insert(Card.tbl_name,
id=card_id,
name=payload['title'],
scope=self.scope,
test_id=self.id,
**payload)
print("*****LK_CARD TABLE*****\n", DataStore.read_all('LK_Card'))
return card_id
def teardown(self, scope):
lst_record = DataStore.read_by_scope(self.table_name, scope=scope)
for record in lst_record:
project_key = record['id']
self.project.delete(project_key)
return self
def verify_lk_card_text(self):
project_details = DataStore.read(self.table_name, id=self.project_key)
card_id = project_details['external_id']
scode = helper.get_scode(self.project_key)
dct_expected = {'LK_CARD_LINK_TXT': card_id}
self.prm_verify.project_details(scode, dct_expected)
return self
def _get_project_id(self, name, lk_flag):
if name:
project_details = DataStore.read(self.table_name, name=name)
if project_details:
project_key = project_details['id']
else:
project_key = self.create(name, lk_flag)
return project_key
def update_card_details_in_ds(card_id, project_key):
card = Card()
tbl_name = card.tbl_name
lk_verify_obj = LKVerify()
card_name = lk_verify_obj.verify_prm_ext_link_in_lk(card_id, project_key)
card_details = {
'id': card_id,
'name': card_name,
'external_id': project_key,
'scope': TestDetails.scope,
'test_id': TestDetails.test_id
}
DataStore.insert(tbl_name, **card_details)
print("*****update_card_details_in_ds*****\n",
DataStore.read_all('LK_Card'))
def delete(self, project_key):
dct_del_prj_values = {'string': project_key}
soap_del_action, soap_payload = self.payload_gen.get_soap_details(
'project', 'delete', dct_del_prj_values)
soap = self.initialize_soap_request(self.cert, soap_payload,
soap_del_action)
self.request.post(self.soap_wsdl,
soap.body,
soap.header,
encoding='utf-8')
self.verify_delete(project_key)
DataStore.delete(Project.tbl_name, id=project_key)
print("*****PRM_PROJECT TABLE*****\n",
DataStore.read_all('PRM_Project'))
def _get_card_id(self, name, board):
if name:
card_details = DataStore.read('LK_Card', name=name)
if card_details:
card_id = card_details['id']
else:
card_id = self.create(name, board)
return card_id
def verify_details(self):
card_id = self.card_id
card_details = DataStore.read('LK_Card', id=card_id)
board_id = card_details['boardId']
name = card_details['name']
dct_expected = {'title': name, 'boardId': board_id}
self.verify.card_details(card_id, dct_expected)
return self
def get_actual_finish(self, name):
"""
returns: date in format: 2018-10-04T06:01:58Z
"""
card_details = DataStore.read('LK_Card', name=name)
card_id = card_details['id']
read_resp = self.card.read(card_id).json()
actual_finish_key = 'actualFinish'
actual_finish_date = objectpath_wrapper.get_dct_value(actual_finish_key, read_resp)
actual_finish_date = actual_finish_date[0] if actual_finish_date else None
return actual_finish_date
def get_earliest_actual_start(self, name):
"""
returns: date in format: 2018-10-04T06:01:58Z
"""
card_details = DataStore.read('LK_Card', name=name)
card_id = card_details['id']
read_resp = self.card.read(card_id).json()
earliest_actual_start_key = 'connectedCardStats.actualStart'
earliest_actual_start_date = objectpath_wrapper.get_dct_value(earliest_actual_start_key, read_resp)
earliest_actual_start_date = earliest_actual_start_date[0] if earliest_actual_start_date else None
return earliest_actual_start_date
def create(self, payload):
soap_create_action, soap_payload = self.payload_gen.get_soap_details(
'project', 'create', payload)
soap = self.initialize_soap_request(self.cert, soap_payload,
soap_create_action)
response = self.request.post(self.soap_wsdl,
soap.body,
soap.header,
encoding='utf-8')
project_key = self.verify_create_update(response, dct_expected=payload)
name = payload.get('Description')
DataStore.insert(Project.tbl_name,
id=project_key,
name=name,
scope=self.scope,
test_id=self.id,
dct_expected=payload)
print("*****PRM_PROJECT TABLE*****\n",
DataStore.read_all('PRM_Project'))
return project_key
def verify_lk_latest_actual_finish(self):
project_details = DataStore.read(self.table_name, id=self.project_key)
name = project_details['name']
from automation.fluent_ml.leankit.atoms.card import CardAtom
card_obj = CardAtom()
latest_actual_finish = card_obj.get_latest_actual_finish(name)
prm_date_format = TimeTestCaseHelper.date_formatter_prm(
latest_actual_finish)
scode = helper.get_scode(self.project_key)
dct_expected = {'LK_LATEST_ACT_FINISH': prm_date_format}
self.prm_verify.project_details(scode, dct_expected)
return self
def verify_lk_earliest_actual_start(self):
project_details = DataStore.read(self.table_name, id=self.project_key)
name = project_details['name']
from automation.fluent_ml.leankit.atoms.card import CardAtom
card_obj = CardAtom()
earliest_actual_start = card_obj.get_earliest_actual_start(name)
prm_date_format = TimeTestCaseHelper.date_formatter_prm(
earliest_actual_start)
scode = helper.get_scode(self.project_key)
dct_expected = {'LK_EARLIEST_ACT_STRT': prm_date_format}
self.prm_verify.project_details(scode, dct_expected)
return self
def update(self, card_id, payload):
update_url = UPDATE_READ_DEL_URL.format(protocol=self.protocol,
host_name=self.host_name,
card_id=card_id)
response = self.req_session.patch(update_url,
json=payload,
headers=self.headers)
expected_dct = {}
for dct in payload:
expected_key = dct['path'].split('/')[-1]
expected_value = dct['value']
expected_dct[expected_key] = expected_value
self.verify_create_update(response, expected_dct)
if 'title' in expected_dct:
dct_update_ds = {'name': expected_dct['title']}
DataStore.update(Card.tbl_name, dct_update_ds, id=card_id)
else:
DataStore.update(Card.tbl_name, expected_dct, id=card_id)
print("*****LK_CARD TABLE*****\n", DataStore.read_all('LK_Card'))
def create(self, payload):
# url = CREATE_URL.format(card_id)
# resp = self.req_session.post(url=CREATE_URL, json=payload, headers=self.headers)
# self.verify_create(payload, resp)
test_id = TestDetails.test_id
scope = TestDetails.scope
dct_details = {'test_id': test_id, 'scope': scope}
self.status = True
self.step_desc = 'Leankit Task create verification'
self.remarks = '\n Inside class: create method:'
self.step_input = 'Expected response is {}'.format(payload)
self.id = TestDetails.test_id
self.uuid = TestDetails.test_uuid
scope = TestDetails.scope
self.db_logger.log_into_steps(self)
list(map(lambda dct_payload: dct_payload.update(dct_details), payload))
DataStore.insert_many('LK_Task', payload)
print(DataStore.read_all('LK_Task'))
def create(self, name, lk_flag):
project_key = None
project_details = DataStore.read(self.table_name, name=name)
if not project_details:
payload_create = {
'FatherKey': self.father_key,
'Description': name
}
project_key = self.project.create(payload_create)
if lk_flag:
self._set_lk_flag(project_key)
return project_key
def update_scheduled_start_and_finish(self, scheduled_start,
scheduled_finish):
project_key = self.project_key
project_details = DataStore.read(self.table_name, id=project_key)
name = project_details['name']
payload_update = {
'Key': project_key,
'Description': name,
'FatherKey': self.father_key,
'ScheduleStartDate': scheduled_start,
'ScheduleFinishDate': scheduled_finish
}
self.project.update(payload_update)
return self
def create_with_description(self, name, description, lk_flag=False):
project_details = DataStore.read(self.table_name, name=name)
if not project_details:
payload_create = {
'FatherKey': self.father_key,
'Description': name
}
self.project_key = self.project.create(payload_create)
self.update_description(description)
if lk_flag:
self._set_lk_flag(self.project_key)
return self
def delete(self, artifact_id):
delete_url = UPDATE_READ_DEL_URL.format(protocol=self.protocol,
host_name=self.host_name,
card_id=artifact_id)
self.req_session.delete(delete_url, headers=self.headers)
self.verify_delete(artifact_id)
DataStore.delete(Card.tbl_name, id=artifact_id)
# On explicit deletion of a card, corresponding external_id column should be removed in PRM_Project Table
DataStore.delete_column('PRM_Project',
'external_id',
external_id=artifact_id)
print("*****LK_CARD TABLE*****\n", DataStore.read_all('LK_Card'))
print("*****PRM_PROJECT TABLE AFTER EXTERNAL_ID POP UP*****\n",
DataStore.read_all('PRM_Project'))
def update_external_id(table, external_id, project_key):
dct_update = {'external_id': external_id}
DataStore.update(table, dct_update, id=project_key)
def goto_project(self, name):
project_details = DataStore.read(self.table_name, name=name)
self.project_key = project_details['id']
return self
def goto_card(self, name, board='board1'):
card_details = DataStore.read(self.table_name, name=name)
self.card_id = card_details['id']
self.board = board
return self
def teardown(self, scope):
lst_record = DataStore.read_by_scope(self.table_name, scope=scope)
for record in lst_record:
card_id = record['id']
self.card.delete(card_id)
return self
