def setUp(self):
super().setUp()
self.test_unit_page = TstUnit()
self.test_units_page = TstUnits()
self.test_plan = TstPlan()
self.article_api = ArticleAPI()
self.test_unit_api = TestUnitAPI()
self.set_authorization(auth=self.article_api.AUTHORIZATION_RESPONSE)
self.test_unit_api.set_configuration()
self.test_unit_page.get_test_units_page()
def create_testplan_from_test_unit_id(self, test_unit_id):
testunit_data = TestUnitAPI().get_testunit_form_data(
id=test_unit_id)[0]['testUnit']
if testunit_data['materialTypesObject'][0]['name'] == 'All':
response, _ = GeneralUtilitiesAPI().list_all_material_types()
_formatted_material = random.choice(response['materialTypes'])
else:
_formatted_material = testunit_data['materialTypesObject'][0]
formatted_material = {
'id': _formatted_material['id'],
'text': _formatted_material['name']
}
# tu_response, tu_payload = TestUnitAPI().create_qualitative_testunit()
testunit_data = TestUnitAPI().get_testunit_form_data(
id=test_unit_id)[0]['testUnit']
formated_testunit = TstUnit().map_testunit_to_testplan_format(
testunit=testunit_data)
formatted_article = ArticleAPI(
).get_formatted_article_with_formatted_material_type(
formatted_material)
testplan, payload = self.create_testplan(
testUnits=[formated_testunit],
selectedArticles=[formatted_article],
materialType=[formatted_material],
materialTypeId=[formatted_material['id']])
if testplan['message'] == 'operation_success':
return self.get_testplan_form_data(id=payload['number'])
else:
self.info(testplan)
def get_active_tst_unit_with_material_type(self,
search,
material_type='Raw Material'):
self.test_unit_page = TstUnit()
self.info('Get Test Unit with type {} .'.format(search))
self.test_unit_page.get_test_units_page()
test_units = self.test_unit_page.search(search)
test_units_dict = [
self.base_selenium.get_row_cells_dict_related_to_header(
row=test_unit) for test_unit in test_units[:-1]
]
for test_unit_dict in test_units_dict:
if test_unit_dict[
'Type'] == search and material_type in test_unit_dict[
'Material Type']:
return test_unit_dict
return {}
def create_order_with_double_test_plans(self, only_test_plans=False):
testplan1 = TestPlanAPI().create_completed_testplan_random_data()
article = testplan1['selectedArticles'][0]['text']
article_id = testplan1['selectedArticles'][0]['id']
if article == 'all':
article, article_id = ArticleAPI().get_random_article_articleID()
material_type = testplan1['materialType'][0]
tu_response1, tu_payload1 = TestUnitAPI().create_qualitative_testunit()
testunit1 = TestUnitAPI().get_testunit_form_data(id=tu_response1['testUnit']['testUnitId'])[0]['testUnit']
tu_response2, tu_payload2 = TestUnitAPI().create_qualitative_testunit()
testunit2 = TestUnitAPI().get_testunit_form_data(id=tu_response2['testUnit']['testUnitId'])[0]['testUnit']
if only_test_plans:
testunit_list = []
else:
testunit_list = [testunit1, testunit2]
formated_testunit = TstUnit().map_testunit_to_testplan_format(testunit=testunit2)
formatted_article = {'id': article_id, 'text': article}
testplan2, _ = TestPlanAPI().create_testplan(testUnits=[formated_testunit],
selectedArticles=[formatted_article],
materialTypes=material_type)
first_testPlan_data = TestPlanAPI()._get_testplan_form_data(id=testplan1['testPlan']['id'])
testPlan1 = {
'testPlan': {'id': int(first_testPlan_data[0]['testPlan']['testPlanEntity']['id']),
'text': first_testPlan_data[0]['testPlan']['testPlanEntity']['name']},
'number': int(first_testPlan_data[0]['testPlan']['number'])}
second_testPlan_data = TestPlanAPI()._get_testplan_form_data(id=testplan2['testPlanDetails']['id'])
testPlan2 = {
'testPlan': {'id': int(second_testPlan_data[0]['testPlan']['testPlanEntity']['id']),
'text': second_testPlan_data[0]['testPlan']['testPlanEntity']['name']},
'number': int(second_testPlan_data[0]['testPlan']['number'])}
testplan_list = [testPlan1, testPlan2]
payload = {
'testPlans': testplan_list,
'testUnits': testunit_list,
'materialType': material_type,
'materialTypeId': material_type['id'],
'article': {'id': article_id, 'text': article},
'articleId': article_id
}
return self.create_new_order(**payload)
def create_completed_testplan(self, material_type, formatted_article):
material_type_id = GeneralUtilitiesAPI().get_material_id(material_type)
formatted_material = {'id': material_type_id, 'text': material_type}
tu_response, tu_payload = TestUnitAPI().create_qualitative_testunit()
testunit_data = TestUnitAPI().get_testunit_form_data(
id=tu_response['testUnit']['testUnitId'])[0]['testUnit']
formated_testunit = TstUnit().map_testunit_to_testplan_format(
testunit=testunit_data)
testplan, payload = self.create_testplan(
testUnits=[formated_testunit],
selectedArticles=[formatted_article],
materialType=[formatted_material],
material_type_id=material_type_id)
if testplan['message'] == 'operation_success':
return self.get_testplan_form_data(
id=int(testplan['testPlanDetails']['id']))
else:
self.info(testplan)
def create_double_completed_testplan_same_name_diff_material(
self, **kwargs):
self.info("create completed test plan with random data")
testplan1 = self.create_completed_testplan_random_data()
test_plan_name_dict = {
'id': 'new',
'text': testplan1['testPlan']['text']
}
new_material = random.choice(
GeneralUtilitiesAPI().get_material_types_without_duplicate(
testplan1['materialType'][0]['text']))
new_material_id = GeneralUtilitiesAPI().get_material_id(new_material)
formatted_material = {'id': new_material_id, 'text': new_material}
tu_response, _ = TestUnitAPI().create_qualitative_testunit(
selectedMaterialTypes=[formatted_material])
testunit_data = TestUnitAPI().get_testunit_form_data(
id=tu_response['testUnit']['testUnitId'])[0]['testUnit']
formated_testunit = TstUnit().map_testunit_to_testplan_format(
testunit=testunit_data)
self.info(
"create completed test plan with same name {} and new material {}".
format(testplan1['testPlan']['text'], new_material))
formatted_article = ArticleAPI(
).get_formatted_article_with_formatted_material_type(
material_type=formatted_material)
response, testplan2 = self.create_testplan(
selectedTestPlan=test_plan_name_dict,
testPlan=test_plan_name_dict,
testUnits=[formated_testunit],
selectedArticles=[formatted_article],
materialType=[formatted_material],
materialTypeId=[new_material_id])
if response['message'] == 'name_already_exist':
testplan2['testPlan']['id'] = response['testPlanDetails'][
'testPlanId']
testplan2['selectedTestPlan']['id'] = response['testPlanDetails'][
'testPlanId']
return [testplan1, testplan2]
else:
raise Exception(
f'cant create the test plan with payload {testplan2}')
def create_testplan_with_multiple_materials(self, no_materials=3):
all_material_types = GeneralUtilitiesAPI().list_all_material_types(
)[0]['materialTypes']
formatted_materials = random.sample(all_material_types, no_materials)
material_type_ids = [
material['id'] for material in formatted_materials
]
selected_material_types = [
material['name'] for material in formatted_materials
]
tu_response, _ = TestUnitAPI().create_quantitative_testunit(
selectedMaterialTypes=formatted_materials[0])
testunit_data = TestUnitAPI().get_testunit_form_data(
id=tu_response['testUnit']['testUnitId'])[0]['testUnit']
formatted_testunit = TstUnit().map_testunit_to_testplan_format(
testunit=testunit_data)
testplan = self.create_testplan(testUnits=[formatted_testunit],
materialType=formatted_materials,
materialTypeId=material_type_ids)
return testplan[1]['testPlan']['text'], selected_material_types
def create_completed_testplan_random_data(self, no_testunits=1):
random_article = random.choice(ArticleAPI().get_all_articles_json())
formatted_article = {
'id': random_article['id'],
'text': random_article['name']
}
material_type_id = GeneralUtilitiesAPI().get_material_id(
random_article['materialType'])
formatted_material = {
'id': material_type_id,
'text': random_article['materialType']
}
# creates test unit with values in it
formatted_testunits = []
for testunit in range(no_testunits):
tu_response, _ = TestUnitAPI().create_quantitative_testunit(
selectedMaterialTypes=[formatted_material])
testunit_data = TestUnitAPI().get_testunit_form_data(
id=tu_response['testUnit']['testUnitId'])[0]['testUnit']
formatted_testunit = TstUnit().map_testunit_to_testplan_format(
testunit=testunit_data)
formatted_testunits.append(formatted_testunit)
testplan, payload = self.create_testplan(
testUnits=formatted_testunits,
selectedArticles=[formatted_article],
materialType=[formatted_material],
materialTypeId=[material_type_id])
if testplan['message'] == 'operation_success':
payload['testPlan']['id'] = testplan['testPlanDetails'][
'testPlanId']
payload['selectedTestPlan']['id'] = testplan['testPlanDetails'][
'testPlanId']
return payload
else:
return None
def test014_create_role_with_master_data_permissions_then_create_user_by_it(self):
"""
Roles & Permissions: when I create user with master data permissions then create user wit it
when I login with this user the master data only should appear in the menu
LIMS-6440
"""
self.login_page = Login()
self.info('create role with random name with master data permissions')
random_role_name = self.generate_random_string()
self.header_page.create_role_with_mater_data_permissions(role_name=random_role_name)
self.info('go to the user section to create user with this role')
self.header_page.get_users_page()
random_user_name = self.generate_random_string()
random_user_email = self.header_page.generate_random_email()
random_user_password = self.generate_random_string()
self.header_page.create_new_user(user_name=random_user_name,
user_email=random_user_email,
user_role=random_role_name,
user_password=random_user_password,
user_confirm_password=random_user_password)
self.login_page.logout()
self.info('login with role & user {}:{}'.format(random_user_name, random_user_password))
self.login_page.login(username=random_user_name, password=random_user_password)
self.header_page.sleep_medium()
# make sure that all the master data pages appear(articles & test units & test plans & contacts)
self.info('get the test unit url')
self.assertTrue('Test Units', TstUnit().get_test_units_page())
self.info('get the articles url')
self.assertTrue('Articles', Article().get_articles_page())
self.info('get the test plan url')
self.assertTrue('Test Plans', TstPlan().get_test_plans_page())
self.info('get the contacts url')
self.assertTrue('Contacts', Contacts().get_contacts_page())
class BaseTest(TestCase):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@classmethod
def setUpClass(cls) -> None:
cls.create_screenshots_dir()
cls.base_selenium = BaseSelenium()
cls.base_selenium.get_driver()
cls.base_selenium.get(url=cls.base_selenium.url)
cls.pass_refresh_feature()
cls.set_authorization(auth=BaseAPI().AUTHORIZATION_RESPONSE)
def setUp(self):
print('\t')
self.info('Test case : {}'.format(self._testMethodName))
# self.base_selenium.get(url=self.base_selenium.url)
# self.base_selenium.wait_until_page_load_resources()
def tearDown(self):
self.screen_shot()
self.info('go to dashboard page')
self.base_selenium.get(url=f"{self.base_selenium.url}dashboard")
self.info('TearDown. \t')
@classmethod
def tearDownClass(cls) -> None:
cls.base_selenium.quit_driver()
def screen_shot(self):
try:
method, error = self._outcome.errors[0]
if error:
screen_shot = f"./screenshots/screenshot_{method._testMethodName}_.png"
self.info(f"saved error screen shot : {screen_shot}")
self.base_selenium.driver.get_screenshot_as_file(
f"./screenshots/screenshot_{method._testMethodName}_.png")
except:
pass
def generate_random_string(self):
return str(uuid4()).replace("-", "")[:10]
def generate_random_number(self, lower=1, upper=100000):
return randint(lower, upper)
def fix_data_format(self, data_list):
tmp = []
for item in data_list:
if len(str(item)) > 0:
if re.search(r'\d{2}.\d{2}.\d{4},\s\d{1,2}:\d{1,2}\s(A|P)M',
str(item)):
tmp.append(
datetime.datetime.strptime(item, '%d.%m.%Y, %H:%M %p'))
elif re.search(r'\d{2}\.\d{2}\.\d{4}', str(item)):
tmp.append(datetime.datetime.strptime(item, '%d.%m.%Y'))
elif str(item) in ["-", "nan", "N/A"]:
continue
elif ',' in str(item) and '&' in str(item):
item = str(item).replace('&', ',')
tmp.extend(str(item).split(','))
elif ',' in str(item):
tmp.extend(str(item).split(','))
elif ', ' in str(item):
tmp.extend(str(item).split(', '))
elif '&' in str(item):
tmp.extend(str(item).split('&'))
elif ' ' == str(item)[-1]:
tmp.append(item[:-1])
elif 'all' == str(item)[-1]:
tmp.append('All')
else:
tmp.append(
str(item).replace(',',
'&').replace("'",
"").replace(' - ', '-'))
return tmp
def reformat_data(self, data_list):
tmp = []
for item in data_list:
if len(str(item)) > 0:
tmp.append(str(item).replace(',', ' &').replace("'", ""))
return tmp
def get_active_article_with_tst_plan(self, test_plan_status='complete'):
self.test_plan = TstPlan()
self.article_page = Article()
self.info(
'Get Active article with {} test plan.'.format(test_plan_status))
self.test_plan.get_test_plans_page()
complete_test_plans = self.test_plan.search(test_plan_status)
complete_test_plans_dict = [
self.base_selenium.get_row_cells_dict_related_to_header(
row=complete_test_plan)
for complete_test_plan in complete_test_plans[:-1]
]
self.article_page.get_articles_page()
for complete_test_plan_dict in complete_test_plans_dict:
self.info('Is {} article in active status?'.format(
complete_test_plan_dict['Article Name']))
if self.article_page.is_article_in_table(
value=complete_test_plan_dict['Article Name']):
self.info('Active.')
return complete_test_plan_dict
else:
self.info('Archived.')
else:
return {}
def get_multiple_active_article_with_tst_plan(self,
test_plan_status='complete'):
self.test_plan = TstPlan()
self.article_page = Article()
self.info(
'Get Active articles with {} test plans.'.format(test_plan_status))
self.test_plan.get_test_plans_page()
complete_test_plans = self.test_plan.search(test_plan_status)
complete_test_plans_dict = [
self.base_selenium.get_row_cells_dict_related_to_header(
row=complete_test_plan)
for complete_test_plan in complete_test_plans[:-1]
]
self.article_page.get_articles_page()
test_plans_list = []
for complete_test_plan_dict in complete_test_plans_dict:
self.info('Is {} article in active status?'.format(
complete_test_plan_dict['Article Name']))
if self.article_page.is_article_in_table(
value=complete_test_plan_dict['Article Name']):
self.info('Active.')
test_plans_list.append(complete_test_plan_dict)
else:
self.LOGGER.info('Archived.')
else:
return {}
return test_plans_list
def get_active_tst_unit_with_material_type(self,
search,
material_type='Raw Material'):
self.test_unit_page = TstUnit()
self.info('Get Test Unit with type {} .'.format(search))
self.test_unit_page.get_test_units_page()
test_units = self.test_unit_page.search(search)
test_units_dict = [
self.base_selenium.get_row_cells_dict_related_to_header(
row=test_unit) for test_unit in test_units[:-1]
]
for test_unit_dict in test_units_dict:
if test_unit_dict[
'Type'] == search and material_type in test_unit_dict[
'Material Type']:
return test_unit_dict
return {}
'''
Removes the data that was changed in the duplication process in order to compare
between the objects to make sure that the duplication was done correcly.
'''
def remove_unduplicated_data(self,
data_changed=[],
first_element=[],
second_element=[]):
for data in data_changed:
if data in first_element and data in second_element:
if first_element[data] != None:
del first_element[data]
if second_element[data] != None:
del second_element[data]
return first_element, second_element
@property
def info(self):
return self.base_selenium.LOGGER.info
@property
def debug(self):
return self.base_selenium.LOGGER.debug
@classmethod
def set_authorization(cls, auth):
if "Admin" == auth.get('role'):
del auth['role']
auth['roles'] = ["Admin"]
cls.base_selenium.set_local_storage('modeso-auth-token', auth)
@classmethod
def pass_refresh_feature(cls):
with cls.base_selenium._change_implicit_wait(new_value=2):
try:
cls.base_selenium.driver.find_element_by_xpath(
"//button[@class='btn btn-primary']").click()
except:
pass
@staticmethod
def create_screenshots_dir():
dir = 'screenshots'
if os.path.exists(dir):
shutil.rmtree(dir, ignore_errors=True)
os.mkdir(dir)
def test027_test_unit_update_version_in_testplan(self):
"""
Test plan: Test unit Approach: In case I update category & iteration of
test unit that used in test plan with new version, when go to test plan
to add the same test unit , I found category & iteration updated
LIMS-3703
"""
self.test_unit_page = TstUnit()
self.info("select random test unit to create the test plan with it")
testunit = random.choice(TestUnitAPI().get_testplan_valid_test_unit())
self.info(
'A random test unit is chosen, its name: {}, category: {} and number of iterations: {}'
.format(testunit['name'], testunit['categoryName'],
testunit['iterations']))
self.info("create the first testplan")
first_testplan_name, payload1 = self.test_plan_api.create_testplan()
self.info('First test plan create with name: {}'.format(
payload1['testPlan']['text']))
self.info(
"go to testplan edit to get the number of iterations and test unit category"
)
first_testplan_testunit_category, first_testplan_testunit_iteration = \
self.test_plan.get_testunit_category_iterations(payload1['testPlan']['text'], testunit['name'])
self.info(
"go to test units' active table and search for this test unit")
self.test_unit_page.get_test_units_page()
self.info('Navigating to test unit {} edit page'.format(
testunit['name']))
self.test_unit_page.open_test_unit_edit_page_by_id(testunit['id'])
self.test_unit_page.sleep_small()
new_iteration = str(int(first_testplan_testunit_iteration) + 1)
new_category = self.generate_random_string()
self.info("update the iteration to {} and category to {}".format(
new_iteration, new_category))
self.test_unit_page.set_category(new_category)
self.test_unit_page.set_testunit_iteration(new_iteration)
self.info("press save and complete to create a new version")
self.test_unit_page.save_and_create_new_version()
self.info(" go back to test plans active table")
self.test_plan.get_test_plans_page()
self.info(
" create new testplan with this testunit after creating the new version"
)
response, payload2 = self.test_plan_api.create_testplan()
self.assertEqual(response["status"], 1)
second_testplan_name = payload2['testPlan']['text']
self.info('Second test plan create with name: {}'.format(
second_testplan_name))
self.info(
"check the iteration and category to be the same as the new version"
)
self.info(
"go to testplan edit to get the number of iterations and testunit category"
)
second_testplan_testunit_category, second_testplan_testunit_iteration = \
self.test_plan.get_testunit_category_iterations(second_testplan_name, testunit['name'])
self.info(
'Asserting that the category of the test unit in the first test plan is not updated'
)
self.assertNotEqual(first_testplan_testunit_category, new_category)
self.info(
'Asserting that the iterations of the test unit in the first test plan is not updated'
)
self.assertNotEqual(first_testplan_testunit_iteration,
second_testplan_testunit_iteration)
self.info(
'Asserting that the category of the test unit in the second new_iteration is the '
'same as the updated category')
self.assertEqual(second_testplan_testunit_category, new_category)
self.info(
'Asserting that the iterations of the test unit in the second testplan is the '
'same as the updated iterations')
self.assertEqual(second_testplan_testunit_iteration, new_iteration)
class TestPlansTestCases(BaseTest):
def setUp(self):
super().setUp()
self.test_plan = TstPlan()
self.test_plan_api = TestPlanAPI()
self.article_api = ArticleAPI()
self.test_plan.get_test_plans_page()
self.test_plan_api.set_configuration()
def test001_test_plan_delete_testunit(self):
"""
Testing deleting a test unit from test-plan create or update step two
It deletes the first test unit in the chosen test plan and saves this,
then refreshes the page and checks if the deletion was done correctly.
LIMS-3504
"""
self.info("get random completed test plan")
random_completed_test_plan = random.choice(
self.test_plan_api.get_completed_testplans())
self.info("navigate to the test-plan No. {} edit page".format(
random_completed_test_plan['number']))
self.test_plan.get_test_plan_edit_page_by_id(
random_completed_test_plan['id'])
old_testunits = self.test_plan.get_all_testunits_in_testplan()
self.assertTrue(old_testunits,
"There's no test units in this test plan")
deleted_test_unit = (old_testunits[0])[0]
self.info("delete the first test unit with name {}".format(
deleted_test_unit))
self.test_plan.delete_the_first_testunit_from_the_tableview()
self.info(
"save the changes and refresh to make sure test unit deleted")
self.test_plan.save_and_confirm_popup()
all_testunits = self.test_plan.get_all_testunits_in_testplan()
self.info('Checking if the changes were saved successfully')
deleted_test_unit_found = self.test_plan.check_if_deleted_testunit_is_available(
all_testunits=all_testunits, deleted_test_unit=deleted_test_unit)
self.assertFalse(deleted_test_unit_found)
@parameterized.expand(['InProgress', 'Completed'])
def test002_test_plan_edit_status(self, status):
"""
Creation Approach: when the status converted from completed to completed, new version created
when the status converted from In-Progress to completed, no new version created
LIMS-3502
LIMS-3501
"""
self.info(
"create test unit of material type = All to complete test plan")
response, test_unit = TestUnitAPI().create_qualitative_testunit()
self.assertEqual(response['status'], 1, 'can not create test unit')
testplan = random.choice(
self.test_plan_api.get_testplans_with_status(status=status))
self.assertTrue(testplan, 'No test plan selected')
self.info(
'Navigate to edit page of test plan: {} with version: {}'.format(
testplan['testPlanName'], testplan['version']))
self.test_plan.get_test_plan_edit_page_by_id(testplan['id'])
self.info('Going to step 2 to add test unit to this test plan')
self.test_plan.sleep_tiny()
self.test_plan.set_test_unit(test_unit=test_unit['name'])
if status == 'InProgress':
self.info('Saving and completing the test plan')
self.test_plan.save(save_btn='test_plan:save_and_complete',
sleep=True)
else:
self.info('Saving and confirm pop up')
self.test_plan.save_and_confirm_popup()
self.info(
"go back to the active table and get test plan to check its version and status"
)
self.test_plan.get_test_plans_page()
new_test_plan_version, test_plan_row_data_status = \
self.test_plan.get_testplan_version_and_status(search_text=testplan['testPlanName'])
if status == 'InProgress':
self.assertEqual(int(new_test_plan_version), testplan['version'])
else:
self.assertGreater(int(new_test_plan_version),
int(testplan['version']))
self.assertEqual(test_plan_row_data_status, 'Completed')
def test003_archive_test_plan_one_record(self):
"""
Archive one record
LIMS-3506 Case 1
"""
self.info('choosing a random test plan table row')
selected_test_plan = self.test_plan.select_random_table_row()
self.assertTrue(selected_test_plan)
self.info(f'selected_test_plan : {selected_test_plan}')
testplan_number = selected_test_plan['Test Plan No.']
self.info(
'Archive the selected item and navigating to the archived items table'
)
self.test_plan.archive_selected_items()
self.test_plan.get_archived_items()
archived_row = self.test_plan.search(testplan_number)
self.info(
'Checking if test plan number: {} is archived correctly'.format(
testplan_number))
self.assertIn(selected_test_plan['Test Plan Name'],
archived_row[0].text)
self.info('Test plan number: {} is archived correctly'.format(
testplan_number))
def test004_restore_test_plan_one_record(self):
"""
Restore one record
LIMS-3506 Case 1
"""
self.info("Navigate to archived test plan table")
self.test_plan.get_archived_items()
self.info('Choosing a random testplan table row')
self.test_plan.sleep_tiny()
selected_test_plan = self.test_plan.select_random_table_row()
self.info(f"selected_test_plan : {selected_test_plan}")
self.assertTrue(selected_test_plan)
testplan_number = selected_test_plan['Test Plan No.']
self.info('select Testplan number: {} to be restored'.format(
testplan_number))
self.info(
'Restoring the selected item then navigating to the active items table'
)
self.test_plan.restore_selected_items()
self.test_plan.get_active_items()
self.test_plan.filter_by_testplan_number(filter_text=testplan_number)
restored_row = self.test_plan.result_table()
self.info(
'Checking if testplan number: {} is restored correctly'.format(
testplan_number))
self.assertIn(selected_test_plan['Test Plan Name'],
restored_row[0].text)
self.info('Testplan number: {} is restored correctly'.format(
testplan_number))
def test005_archive_test_plan_multiple_records(self):
"""
Archive multiple records
LIMS-3506 Case 2
"""
self.info('Choosing random multiple test plans table rows')
self.test_plan.sleep_small()
rows_data, rows = self.test_plan.select_random_multiple_table_rows()
self.assertTrue(rows_data)
testplans_numbers = [row['Test Plan No.'] for row in rows_data]
self.info(
'Testplan numbers: {} will be archived'.format(testplans_numbers))
self.info(
'Archiving the selected items and navigating to the archived items table'
)
self.test_plan.archive_selected_items()
self.test_plan.sleep_small()
self.info('Checking if testplans are archived correctly')
self.test_plan.get_archived_items()
archived_rows = self.test_plan.filter_multiple_rows_by_testplans_numbers(
testplans_numbers)
self.assertIsNotNone(archived_rows)
self.assertEqual(len(archived_rows), len(testplans_numbers))
self.info('Testplan numbers: {} are archived correctly'.format(
testplans_numbers))
def test006_restore_test_plan_multiple_records(self):
"""
Rstore multiple records
LIMS-3506 Case 2
"""
self.info("Navigate to archived test plan table")
self.test_plan.sleep_tiny()
self.test_plan.get_archived_items()
self.info('Choosing random multiple test plans table rows')
self.test_plan.sleep_tiny()
rows_data, rows = self.test_plan.select_random_multiple_table_rows()
self.assertTrue(rows_data)
testplans_numbers = [row['Test Plan No.'] for row in rows_data]
self.info(
'Restore Test plans with numbers: {}'.format(testplans_numbers))
self.test_plan.restore_selected_items()
self.test_plan.sleep_small()
self.info('Navigate to active table and make sure test plans restored')
self.test_plan.get_active_items()
restored_rows = self.test_plan.filter_multiple_rows_by_testplans_numbers(
testplans_numbers)
self.assertIsNotNone(restored_rows)
self.assertEqual(len(restored_rows), len(testplans_numbers))
self.info('Test plans numbers: {} are restored correctly'.format(
testplans_numbers))
@skip('https://modeso.atlassian.net/browse/LIMS-6403')
def test007_exporting_test_plan_one_record(self):
"""
Exporting one record
LIMS-3508 Case 1
"""
self.info('choosing a random testplan table row')
row = self.test_plan.get_random_table_row('general:table')
row_data = self.base_selenium.get_row_cells_dict_related_to_header(
row=row)
testplan_number = row_data['Test Plan No.']
self.info(
'testplan number: {} will be exported'.format(testplan_number))
self.info('Selecting the test plan row')
self.test_plan.click_check_box(source=row)
self.info('download XSLX sheet of selected test plan')
self.test_plan.download_xslx_sheet()
row_data_list = list(row_data.values())
self.info('comparing the testplan no. {} '.format(testplan_number))
values = self.test_plan.sheet.iloc[0].values
fixed_sheet_row_data = self.fix_data_format(values)
fixed_row_data_list = self.fix_data_format(row_data_list)
for item in fixed_row_data_list:
self.assertIn(item, fixed_sheet_row_data)
@skip('https://modeso.atlassian.net/browse/LIMS-6403')
def test008_exporting_test_plan_multiple_records(self):
"""
Exporting multiple records
LIMS-3508 Case 2
"""
self.info('choosing random multiple testplans table rows')
row_data_list = self.test_plan.select_random_multiple_table_rows(
element='general:table')[0]
self.test_plan.download_xslx_sheet()
row_data = []
sheet_data = []
for index in range(len(row_data_list)):
row_data.append(self.fix_data_format(
row_data_list[index].values()))
sheet_data.append(
self.fix_data_format(self.test_plan.sheet.iloc[index].values))
row_data = sorted(row_data)
sheet_data = sorted(sheet_data)
for index in range(len(row_data)):
for item in row_data[index]:
self.assertIn(item, sheet_data[index])
def test009_test_plan_duplicate(self):
"""
Duplicate a test plan
LIMS-3679
"""
self.info('Choosing a random testplan table row')
testPlan = random.choice(self.test_plan_api.get_completed_testplans())
self.assertTrue(testPlan, "No completed test plan selected")
testunits = self.test_plan_api.get_testunits_in_testplan(
id=testPlan['id'])
self.assertTrue(
testunits,
"Completed test plan with id {} has no testunits!!".format(
testPlan['id']))
self.info("select test plan {}".format(testPlan['testPlanName']))
self.test_plan.filter_by_testplan_number(testPlan['number'])
row = self.test_plan.result_table()[0]
self.test_plan.click_check_box(source=row)
self.info('Duplicating testplan number: {}'.format(testPlan['number']))
self.test_plan.duplicate_selected_item()
duplicated_test_plan_number = self.test_plan.duplicate_testplan(
change=['name'])
self.info('testplan duplicated with number: {}'.format(
duplicated_test_plan_number))
self.info('get duplicated test plan data and child table data')
duplicated_testplan_data, duplicated_testplan_childtable_data = \
self.test_plan.get_specific_testplan_data_and_childtable_data(
filter_by='number', filter_text=duplicated_test_plan_number)
duplicated_test_units = []
for testunit in duplicated_testplan_childtable_data:
duplicated_test_units.append(testunit['Test Unit Name'])
self.info('Asserting that the data is duplicated correctly')
self.assertEqual(testPlan['materialTypes'][0],
duplicated_testplan_data['Material Type'])
self.assertEqual(testPlan['article'][0],
duplicated_testplan_data['Article Name'])
self.assertEqual(testPlan['articleNo'][0],
duplicated_testplan_data['Article No.'])
for testunit in testunits:
self.assertIn(testunit['name'], duplicated_test_units)
def test010_test_plan_completed_to_inprogress(self):
"""
When the test plan status is converted from completed to in progress a new version is created
LIMS-3503
"""
self.info('get random completed test plan')
completed_testplan = random.choice(
self.test_plan_api.get_completed_testplans())
self.assertTrue(completed_testplan, "There's no completed test plans!")
self.info(
'Navigating to edit page of testplan: {} with version: {}'.format(
completed_testplan['testPlanName'],
completed_testplan['version']))
self.test_plan.get_test_plan_edit_page_by_id(completed_testplan['id'])
self.info('Going to step 2 to remove all the test units from it')
self.test_plan.navigate_to_testunits_selection_page()
self.test_plan.sleep_tiny()
self.test_plan.delete_all_testunits()
self.test_plan.save_and_confirm_popup()
self.info("go back to active table")
self.test_plan.get_test_plans_page()
self.info(
'Getting the currently changed testplan to check its status and version'
)
inprogress_testplan_version, testplan_row_data_status = \
self.test_plan.get_testplan_version_and_status(search_text=completed_testplan['testPlanName'])
self.assertEqual(completed_testplan['version'] + 1,
int(inprogress_testplan_version))
self.assertEqual(testplan_row_data_status, 'In Progress')
@parameterized.expand(['same', 'All'])
def test011_create_testplans_same_name_article_materialtype(self, same):
"""
Testing the creation of two testplans with the same name, material type
and article, this shouldn't happen
LIMS-3499
New: Test plan: Creation Approach: I can't create two test plans
with the same name & same materiel type & one with any article
and the other one all
LIMS-3500
"""
payload = self.test_plan_api.create_completed_testplan_random_data()
self.test_plan.click_create_test_plan_button()
self.test_plan.set_test_plan(name=payload['testPlan']['text'])
self.assertFalse(
self.test_plan.is_material_type_existing(
material_type=payload['materialType'][0]['text']))
def test012_create_testplans_same_name_different_materialtype(self):
"""
Testing the creation of two testplans with the same name, but different material type
and article. It should be created successfully.
LIMS-3498
"""
self.info('create complete test plan')
payload = self.test_plan_api.create_completed_testplan_random_data()
self.assertTrue(payload, 'can not create a tesplan')
articles = self.article_api.get_all_articles_json()
for article in articles:
if article['name'] != payload['selectedArticles'][0]['text'] and article['materialType'] != \
payload['materialType'][0]['text']:
self.info(
'create another testplan with the same name, but with different material type and article name'
)
second_testplan_name = self.test_plan.create_new_test_plan(
name=payload['testPlan']['text'],
material_type=article['materialType'],
article=article['name'])
self.info(
'new testplan is created successfully with name: {}, article name: {} and material type: {}'
.format(second_testplan_name, self.test_plan.article,
self.test_plan.material_type))
self.assertEqual(payload['testPlan']['text'],
second_testplan_name)
data = self.test_plan.search(second_testplan_name)
self.assertGreaterEqual(len(data), 2)
break
def test013_delete_used_testplan(self):
"""
If a test plan is used, it can't be deleted
LIMS-3509
"""
self.info("create order with test plan")
response, payolad = OrdersAPI().create_new_order()
self.assertEqual(response['status'], 1, payolad)
self.info("created order no {} has testplan name {}".format(
payolad[0]['orderNo'], payolad[0]['testPlans'][0]['name']))
self.info('testplan name: {} will be archived'.format(
payolad[0]['testPlans'][0]['name']))
self.test_plan.base_selenium.refresh()
testplan_deleted = self.test_plan.delete_selected_item_from_active_table_and_from_archived_table(
item_name=payolad[0]['testPlans'][0]['name'])
self.info(
"check for the error popup that this testplan is used and can't be deleted"
)
self.assertFalse(testplan_deleted)
def test014_archived_testplan_shouldnot_appear_in_order(self):
"""
In case a testplan is archived, it shouldn't appear when creating a new order
LIMS-3708
"""
self.info("navigate to orders page")
self.order_page = Order()
self.info("get random archived testplan")
response, payload = self.test_plan_api.get_all_test_plans()
self.assertEqual(response['status'], 1, payload)
archived_test_plan = random.choice(response['testPlans'])
self.test_plan_api.archive_testplans(
ids=[str(archived_test_plan['id'])])
self.order_page.get_orders_page()
self.info("archived test plan data {}".format(archived_test_plan))
self.info(
"create a new order with material type and article of archived testplan"
)
if archived_test_plan['article'] != ['all']:
self.order_page.create_new_order(
material_type=archived_test_plan['materialTypes'][0],
article=archived_test_plan['article'][0],
test_plans=[archived_test_plan['testPlanName']])
else:
self.order_page.create_new_order(
material_type=archived_test_plan['materialTypes'][0],
test_plans=[archived_test_plan['testPlanName']])
order_data = self.order_page.get_suborder_data()
self.info(
"get the first suborder's testplan and make sure it's an empty string"
)
self.assertCountEqual(order_data['suborders'][0]['testplans'], [''])
def test015_testunit_sub_super_scripts(self):
"""
Create a testunit with sub/super scripts, use this testunit to create a testplan
and check the sub/super scripts in the card view
LIMS-5796
"""
self.info("create test unit with sub and super scripts")
response, payload = TestUnitAPI().create_qualitative_testunit(
unit='mg[2]{o}')
self.assertEqual(response['status'], 1, payload)
self.info("created test unit data {}".format(payload))
self.info("create test plan with same created test unit data")
if payload['selectedMaterialTypes'][0]['text'] == 'All':
self.test_plan.create_new_test_plan(test_unit=payload['name'],
save=False)
else:
self.test_plan.create_new_test_plan(
material_type=payload['selectedMaterialTypes'][0]['text'],
test_unit=payload['name'],
save=False)
unit = self.base_selenium.find_element('test_plan:testunit_unit').text
self.assertEqual(unit, 'mg2o')
def test016_filter_by_testplan_number(self):
"""
User can filter with testplan number
LIMS-6473
"""
self.info("select random test plan")
random_testplan = random.choice(
self.test_plan_api.get_all_test_plans_json())
self.info("selected_test_plan No {}".format(random_testplan['number']))
self.test_plan.filter_by_testplan_number(random_testplan['number'])
testplan_found = self.test_plan.result_table()
self.assertIn(str(random_testplan['number']),
(testplan_found[0].text).replace("'", ""))
self.info('Filtering by number was done successfully')
def test017_filter_by_testplan_name(self):
"""
User can filter with testplan name
LIMS-6470
"""
random_testplan = random.choice(
self.test_plan_api.get_all_test_plans_json())
self.assertTrue(random_testplan, "can't select random test plan !")
testplans_found_text = self.test_plan.filter_by_element_and_get_text(
'Testplan Name', 'test_plans:testplan_name_filter',
random_testplan['testPlanName'], 'drop_down')
for tp_text in testplans_found_text:
self.assertIn(str(random_testplan['testPlanName']),
tp_text.replace("'", ""))
@parameterized.expand(['Completed', 'In Progress'])
def test018_filter_by_testplan_status(self, status):
"""
User can filter with status
LIMS-6474
"""
testplans_found_text = \
self.test_plan.filter_by_element_and_get_text('Status', 'test_plans:testplan_status_filter',
status, 'drop_down')
for tp_text in testplans_found_text:
self.assertIn(status, tp_text)
if status == "In Progress":
self.assertNotIn('Completed', tp_text)
else:
self.assertNotIn('In Progress', tp_text)
def test019_filter_by_testplan_changed_by(self):
"""
User can filter with changed by field
LIMS-6475
"""
self.login_page = Login()
self.info('Calling the users api to create a new user with username')
response, payload = UsersAPI().create_new_user()
self.assertEqual(response['status'], 1, payload)
self.test_plan.sleep_tiny()
self.login_page.logout()
self.test_plan.sleep_tiny()
self.login_page.login(username=payload['username'],
password=payload['password'])
self.base_selenium.wait_until_page_url_has(text='dashboard')
self.test_plan.get_test_plans_page()
self.test_plan.sleep_tiny()
testplan_name = self.test_plan.create_new_test_plan()
self.info('New testplan is created successfully with name: {}'.format(
testplan_name))
self.test_plan.set_all_configure_table_columns_to_specific_value(
value=True)
testplan_found = self.test_plan.filter_by_element_and_get_results(
'Changed By', 'test_plans:testplan_changed_by_filter',
payload['username'], 'drop_down')
self.assertEqual(len(testplan_found), 2)
self.assertIn(payload['username'], testplan_found[0].text)
self.assertIn(testplan_name, testplan_found[0].text)
def test020_filter_by_testplan_material_type(self):
"""
User can filter with material type field
LIMS-6471
"""
random_testplan = random.choice(
self.test_plan_api.get_all_test_plans_json())
testplans_found_text = self.test_plan.filter_by_element_and_get_text(
'Material Type', 'test_plans:testplan_material_type_filter',
random_testplan['materialTypes'][0], 'drop_down')
for tp_text in testplans_found_text:
self.assertIn(str(random_testplan['materialTypes'][0]), tp_text)
def test021_filter_by_testplan_article(self):
"""
User can filter with article field
LIMS-6472
"""
random_testplan = random.choice(
self.test_plan_api.get_all_test_plans_json())
if random_testplan['article'][0] == 'all':
testplans_found_text = self.test_plan.filter_by_element_and_get_text(
'Article', 'test_plans:testplan_article_filter', 'All',
'drop_down')
else:
testplans_found_text = self.test_plan.filter_by_element_and_get_text(
'Article', 'test_plans:testplan_article_filter',
random_testplan['articleNo'][0], 'drop_down')
for tp_text in testplans_found_text:
self.assertIn(str(random_testplan['article'][0]), tp_text)
def test022_filter_by_testplan_created_on(self):
"""
User can filter with created on field
LIMS-6476
"""
random_testplan = random.choice(
self.test_plan_api.get_all_test_plans_json())
date = datetime.datetime.strptime(random_testplan['createdAt'],
"%Y-%m-%dT%H:%M:%S.%fZ")
date_formatted = datetime.datetime.strftime(date, '%d.%m.%Y')
testplans_found_text = self.test_plan.filter_by_element_and_get_text(
'Created On', 'test_plans:testplan_created_on_filter',
date_formatted, 'date')
for tp_text in testplans_found_text:
self.assertIn(date_formatted, tp_text)
@parameterized.expand(['ok', 'cancel'])
def test023_create_approach_overview_button(self, ok):
"""
Master data: Create: Overview button Approach: Make sure
after I press on the overview button, it redirects me to the active table
LIMS-6203
"""
self.info("click on create test plan button")
self.test_plan.click_create_test_plan_button()
self.info("click on Overview, this will display an alert to the user")
self.test_plan.click_overview()
# switch to the alert
if 'ok' == ok:
self.info("confirm pop-up")
self.test_plan.confirm_overview_pop_up()
self.assertEqual(self.base_selenium.get_url(),
'{}testPlans'.format(self.base_selenium.url))
self.info('clicking on Overview confirmed')
else:
self.info("cancel pop-up")
self.test_plan.cancel_overview_pop_up()
self.assertEqual(self.base_selenium.get_url(),
'{}testPlans/add'.format(self.base_selenium.url))
self.info('clicking on Overview cancelled')
def test024_edit_approach_overview_button(self):
"""
Edit: Overview Approach: Make sure after I press on
the overview button, it redirects me to the active table
LIMS-6202
"""
testplan = random.choice(self.test_plan_api.get_all_test_plans_json())
self.info('Navigate to edit page of test plan: {} '.format(
testplan['testPlanName']))
self.test_plan.get_test_plan_edit_page_by_id(testplan['id'])
testplans_url = self.base_selenium.get_url()
self.info('testplans_url : {}'.format(testplans_url))
self.info('click on Overview, it will redirect you to test plans page')
self.test_plan.click_overview()
self.test_plan.sleep_tiny()
self.assertEqual(self.base_selenium.get_url(),
'{}testPlans'.format(self.base_selenium.url))
self.info('clicking on Overview confirmed')
def test025_testplans_search_then_navigate(self):
"""
Search Approach: Make sure that you can search then navigate to any other page
LIMS-6201
"""
testplan = random.choice(self.test_plan_api.get_all_test_plans_json())
search_results = self.test_plan.search(testplan['testPlanName'])
self.assertGreater(
len(search_results), 1,
" * There is no search results for it, Report a bug.")
# Navigate to articles page
self.info('navigate to articles page')
Articles().get_articles_page()
self.assertEqual(self.base_selenium.get_url(),
'{}articles'.format(self.base_selenium.url))
def test026_hide_all_table_configurations(self):
"""
Table configuration: Make sure that you can't hide all the fields from the table configuration
LIMS-6288
"""
self.assertFalse(self.test_plan.deselect_all_configurations())
def test027_test_unit_update_version_in_testplan(self):
"""
Test plan: Test unit Approach: In case I update category & iteration of
test unit that used in test plan with new version, when go to test plan
to add the same test unit , I found category & iteration updated
LIMS-3703
"""
self.test_unit_page = TstUnit()
self.info("select random test unit to create the test plan with it")
testunit = random.choice(TestUnitAPI().get_testplan_valid_test_unit())
self.info(
'A random test unit is chosen, its name: {}, category: {} and number of iterations: {}'
.format(testunit['name'], testunit['categoryName'],
testunit['iterations']))
self.info("create the first testplan")
first_testplan_name, payload1 = self.test_plan_api.create_testplan()
self.info('First test plan create with name: {}'.format(
payload1['testPlan']['text']))
self.info(
"go to testplan edit to get the number of iterations and test unit category"
)
first_testplan_testunit_category, first_testplan_testunit_iteration = \
self.test_plan.get_testunit_category_iterations(payload1['testPlan']['text'], testunit['name'])
self.info(
"go to test units' active table and search for this test unit")
self.test_unit_page.get_test_units_page()
self.info('Navigating to test unit {} edit page'.format(
testunit['name']))
self.test_unit_page.open_test_unit_edit_page_by_id(testunit['id'])
self.test_unit_page.sleep_small()
new_iteration = str(int(first_testplan_testunit_iteration) + 1)
new_category = self.generate_random_string()
self.info("update the iteration to {} and category to {}".format(
new_iteration, new_category))
self.test_unit_page.set_category(new_category)
self.test_unit_page.set_testunit_iteration(new_iteration)
self.info("press save and complete to create a new version")
self.test_unit_page.save_and_create_new_version()
self.info(" go back to test plans active table")
self.test_plan.get_test_plans_page()
self.info(
" create new testplan with this testunit after creating the new version"
)
response, payload2 = self.test_plan_api.create_testplan()
self.assertEqual(response["status"], 1)
second_testplan_name = payload2['testPlan']['text']
self.info('Second test plan create with name: {}'.format(
second_testplan_name))
self.info(
"check the iteration and category to be the same as the new version"
)
self.info(
"go to testplan edit to get the number of iterations and testunit category"
)
second_testplan_testunit_category, second_testplan_testunit_iteration = \
self.test_plan.get_testunit_category_iterations(second_testplan_name, testunit['name'])
self.info(
'Asserting that the category of the test unit in the first test plan is not updated'
)
self.assertNotEqual(first_testplan_testunit_category, new_category)
self.info(
'Asserting that the iterations of the test unit in the first test plan is not updated'
)
self.assertNotEqual(first_testplan_testunit_iteration,
second_testplan_testunit_iteration)
self.info(
'Asserting that the category of the test unit in the second new_iteration is the '
'same as the updated category')
self.assertEqual(second_testplan_testunit_category, new_category)
self.info(
'Asserting that the iterations of the test unit in the second testplan is the '
'same as the updated iterations')
self.assertEqual(second_testplan_testunit_iteration, new_iteration)
def test028_childtable_limits_of_quantification(self):
"""
Limits of quantification should be viewed in the testplan's child table
LIMS-4179
New: Test plan: Limits of quantification Approach: In case I update the limits
of quantification this will trigger new version in the active table & version table
LIMS-4426
"""
self.info(
"Create new quantitative test unit with quantification limits")
self.test_unit_api = TestUnitAPI()
oldUpperLimit = self.generate_random_number(lower=50, upper=100)
oldLowerLimit = self.generate_random_number(lower=1, upper=49)
tu_response, tu_payload = self.test_unit_api.create_quantitative_testunit(
quantificationUpperLimit=oldUpperLimit,
quantificationLowerLimit=oldLowerLimit,
useQuantification=True,
useSpec=False)
self.assertEqual(tu_response['status'], 1, tu_payload)
testunit_display_old_quantification_limit = '{}-{}'.format(
tu_payload['quantificationLowerLimit'],
tu_payload['quantificationUpperLimit'])
test_plan = self.test_plan_api.create_testplan_from_test_unit_id(
tu_response['testUnit']['testUnitId'])
self.assertTrue(test_plan, "failed to create test plan")
testplan_childtable_data = self.test_plan.search_and_get_childtable_data_for_testplan(
test_plan['testPlanEntity']['name'])
self.info('Asserting the limits of quantification viewed correctly')
self.assertIn(testunit_display_old_quantification_limit,
testplan_childtable_data[0].values())
new_quantification_lower_limit, new_quantification_upper_limit = \
self.test_plan.update_upper_lower_limits_of_testunit(test_plan['id'])
testunit_display_new_quantification_limit = '{}-{}'.format(
new_quantification_lower_limit, new_quantification_upper_limit)
self.test_plan.get_test_plans_page()
testplan_childtable_data = self.test_plan.search_and_get_childtable_data_for_testplan(
test_plan['testPlanEntity']['name'])
self.info('Asserting the limits of quantification viewed correctly')
self.assertIn(testunit_display_new_quantification_limit,
testplan_childtable_data[0].values())
test_plan_data = self.test_plan.get_the_latest_row_data()
self.info('Asserting that new version created')
self.assertEqual(test_plan_data['Version'], '2')
class TestUnitsTestCases(BaseTest):
def setUp(self):
super().setUp()
self.test_unit_page = TstUnit()
self.test_units_page = TstUnits()
self.test_plan = TstPlan()
self.article_api = ArticleAPI()
self.test_unit_api = TestUnitAPI()
self.set_authorization(auth=self.article_api.AUTHORIZATION_RESPONSE)
self.test_unit_api.set_configuration()
self.test_unit_page.get_test_units_page()
@attr(series=True)
#@skip('waiting for API deleting')
def test036_archive_quantifications_limit_field(self):
"""
User can archive the quantification limits field from the configuration section if not used.
"Archive-allowed"
LIMS-4164
"""
self.test_unit_page.open_configurations()
self.test_unit_page.archive_quantification_limit_field()
if not self.test_unit_page.is_field_in_use():
self.assertFalse(
self.base_selenium.check_element_is_exist('test_unit:configuration_testunit_useQuantification'))
self.test_unit_page.get_archived_fields_tab()
self.assertTrue(self.base_selenium.check_element_is_exist('test_unit:configuration_testunit_useQuantification'))
self.test_unit_page.get_test_units_page()
self.test_unit_page.click_create_new_testunit()
self.test_unit_page.set_testunit_type(testunit_type='Quantitative')
self.assertFalse(self.base_selenium.check_element_is_exist(element='test_unit:use_quantification'))
@attr(series=True)
def test037_restore_quantifications_limit_field(self):
"""
User can archive the quantification limits field from the configuration section if not used.
"Restore"
LIMS-4164
"""
self.test_unit_page.open_configurations()
self.test_unit_page.archive_quantification_limit_field()
if not self.test_unit_page.is_field_in_use():
self.test_unit_page.restore_quantification_limit_field()
self.assertFalse(
self.base_selenium.check_element_is_exist('test_unit:configuration_testunit_useQuantification'))
self.test_unit_page.get_active_fields_tab()
self.assertTrue(self.base_selenium.check_element_is_exist('test_unit:configuration_testunit_useQuantification'))
self.test_unit_page.get_test_units_page()
self.test_unit_page.click_create_new_testunit()
self.test_unit_page.set_testunit_type(testunit_type='Quantitative')
self.assertTrue(self.base_selenium.check_element_is_exist(element='test_unit:use_quantification'))
@attr(series=True)
def test038_test_unit_name_is_mandatory(self):
"""
New: Test unit: Configuration: Test unit Name Approach: Make the test units field
as as mandatory field (This mean you can't remove it )
LIMS- 5651
"""
self.test_unit_page.open_configurations()
self.test_unit_page.open_testunit_name_configurations_options()
self.assertTrue(self.test_unit_page.check_all_options_of_search_view_menu())
@parameterized.expand(['Name', 'Method', 'Type', 'No'])
@attr(series=True)
@skip('https://modeso.atlassian.net/browse/LIMSA-382')
def test039_test_unit_name_allow_user_to_search_with_selected_options_testplan(self, search_view_option):
"""
New: Test Unit: Configuration: Test unit Name Approach: Allow user to search with
(name, number, type, method) in the drop down list of the test plan for.
LIMS- 6422
"""
self.test_unit_page.open_configurations()
self.test_unit_page.open_testunit_name_configurations_options()
old_values = self.test_unit_page.select_option_to_view_search_with(view_search_options=[search_view_option])
self.info('Create new testunit with qualitative and random generated data')
response, payload = self.test_unit_api.create_qualitative_testunit()
self.assertEqual(response['status'], 1, payload)
self.info('new testunit created with number {}'.format(payload['number']))
self.info('get random In Progrees test plan')
test_plan = random.choice(TestPlanAPI().get_inprogress_testplans())
self.assertTrue(test_plan, 'No test plan selected')
self.info('Navigate to test plan edit page')
self.test_plan.get_test_plan_edit_page_by_id(test_plan['id'])
is_name_exist = self.test_plan.search_test_unit_not_set(test_unit=payload['name'])
is_number_exist = self.test_plan.search_test_unit_not_set(test_unit=str(payload['number']))
is_type_exist = self.test_plan.search_test_unit_not_set(test_unit='Qualitative')
is_method_exist = self.test_plan.search_test_unit_not_set(test_unit=payload['method'])
if search_view_option == 'Name':
self.assertTrue(is_name_exist)
self.assertFalse(is_number_exist)
self.assertFalse(is_type_exist)
self.assertFalse(is_method_exist)
elif search_view_option == 'Type':
self.assertFalse(is_name_exist)
self.assertFalse(is_number_exist)
self.assertTrue(is_type_exist)
self.assertFalse(is_method_exist)
elif search_view_option == 'Method':
self.assertFalse(is_name_exist)
self.assertFalse(is_number_exist)
self.assertFalse(is_type_exist)
self.assertTrue(is_method_exist)
elif search_view_option == 'No':
self.assertFalse(is_name_exist)
self.assertTrue(is_number_exist)
self.assertFalse(is_type_exist)
self.assertFalse(is_method_exist)
@attr(series=True)
@skip('https://modeso.atlassian.net/browse/LIMSA-382')
def test040_test_unit_name_search_default_options_name_type_in_testplan(self):
"""
New: Test unit: Configuration: Test units field Approach: Allow name & type
to display by default in the test plan form In case I select them from the
test unit configuration
LIMS-6423
"""
# in set_configuration() I set search to be by name and type so I don't need to add this steps here
self.info('Create new test unit with qualitative and random generated data')
response, payload = self.test_unit_api.create_qualitative_testunit()
self.assertEqual(response['status'], 1, payload)
self.info('new test unit created with number {}'.format(payload['number']))
self.info('get random In Progress test plan')
test_plan = random.choice(TestPlanAPI().get_inprogress_testplans())
self.assertTrue(test_plan, 'No test plan selected')
self.info('Navigate to test plan edit page')
self.test_plan.get_test_plan_edit_page_by_id(test_plan['id'])
self.test_plan.sleep_small()
is_name_exist = self.test_plan.search_test_unit_not_set(test_unit=payload['name'])
is_number_exist = self.test_plan.search_test_unit_not_set(test_unit=str(payload['number']))
is_type_exist = self.test_plan.search_test_unit_not_set(test_unit='Qualitative')
is_method_exist = self.test_plan.search_test_unit_not_set(test_unit=payload['method'])
self.assertTrue(is_name_exist)
self.assertFalse(is_number_exist)
self.assertTrue(is_type_exist)
self.assertFalse(is_method_exist)
@attr(series=True)
@skip('https://modeso.atlassian.net/browse/LIMSA-382')
def test041_test_unit_name_view_method_option_multiple_line_in_testplan(self):
"""
New: Test Unit: Configuration: Test unit Name Approach: In case you select
the method to display and you entered long text in it, the method should
display into multiple lines (test plan)
LIMS-6424
"""
self.info('Generate random data for update')
new_random_method = self.generate_random_string() + \
self.generate_random_string() + \
self.generate_random_string()
self.test_unit_page.open_configurations()
self.test_unit_page.open_testunit_name_configurations_options()
self.test_unit_page.select_option_to_view_search_with(view_search_options=['Method'])
self.info('Create new testunit with qualitative and random generated data')
response, payload = self.test_unit_api.create_qualitative_testunit(method=new_random_method)
self.assertEqual(response['status'], 1, payload)
self.info('new testunit created with number {}'.format(payload['number']))
self.info('get random In Progrees test plan')
test_plan = random.choice(TestPlanAPI().get_inprogress_testplans())
self.assertTrue(test_plan, 'No test plan selected')
self.info('Navigate to test plan edit page')
self.test_plan.get_test_plan_edit_page_by_id(test_plan['id'])
self.test_plan.set_test_unit(test_unit=new_random_method)
multiple_lines_properties = self.test_plan.get_testunit_in_testplan_title_multiple_line_properties()
self.assertEquals(multiple_lines_properties['textOverflow'], 'clip')
self.assertEquals(multiple_lines_properties['lineBreak'], 'auto')
@parameterized.expand([('Name', 'Type'),
('Name', 'Method'),
('Name', 'No'),
('Type', 'Method'),
('Type', 'No'),
('Method', 'No')])
@attr(series=True)
@skip('https://modeso.atlassian.net/browse/LIMSA-382')
def test042_test_unit_name_allow_user_to_search_with_selected_two_options_testplan(self, search_view_option1,
search_view_option2):
"""
New: Test Unit: Configuration: Test unit Name Approach: Allow user to search with
(name, number, type, method) in the drop down list of the analysis for
LIMS- 6426
"""
self.test_unit_page.open_configurations()
self.test_unit_page.open_testunit_name_configurations_options()
self.test_unit_page.select_option_to_view_search_with(
view_search_options=[search_view_option1, search_view_option2])
self.info('Create new test unit with qualitative and random generated data')
response, payload = self.test_unit_api.create_qualitative_testunit()
self.assertEqual(response['status'], 1, payload)
self.info('new test unit created with number {}'.format(payload['number']))
self.info('get random In Progress test plan')
test_plan = random.choice(TestPlanAPI().get_inprogress_testplans())
self.assertTrue(test_plan, 'No test plan selected')
self.info('Navigate to test plan edit page')
self.test_plan.get_test_plan_edit_page_by_id(test_plan['id'])
self.test_plan.sleep_small()
is_name_exist = self.test_plan.search_test_unit_not_set(test_unit=payload['name'])
is_number_exist = self.test_plan.search_test_unit_not_set(test_unit=str(payload['number']))
is_type_exist = self.test_plan.search_test_unit_not_set(test_unit='Qualitative')
is_method_exist = self.test_plan.search_test_unit_not_set(test_unit=payload['method'])
if search_view_option1 == 'Name' and search_view_option2 == 'Type':
self.assertTrue(is_name_exist)
self.assertFalse(is_number_exist)
self.assertTrue(is_type_exist)
self.assertFalse(is_method_exist)
elif search_view_option1 == 'Name' and search_view_option2 == 'Method':
self.assertTrue(is_name_exist)
self.assertFalse(is_number_exist)
self.assertFalse(is_type_exist)
self.assertTrue(is_method_exist)
elif search_view_option1 == 'Name' and search_view_option2 == 'No':
self.assertTrue(is_name_exist)
self.assertTrue(is_number_exist)
self.assertFalse(is_type_exist)
self.assertFalse(is_method_exist)
elif search_view_option1 == 'Type' and search_view_option2 == 'Method':
self.assertFalse(is_name_exist)
self.assertFalse(is_number_exist)
self.assertTrue(is_type_exist)
self.assertTrue(is_method_exist)
elif search_view_option1 == 'Type' and search_view_option2 == 'No':
self.assertFalse(is_name_exist)
self.assertTrue(is_number_exist)
self.assertTrue(is_type_exist)
self.assertFalse(is_method_exist)
elif search_view_option1 == 'Method' and search_view_option2 == 'No':
self.assertFalse(is_name_exist)
self.assertTrue(is_number_exist)
self.assertFalse(is_type_exist)
self.assertTrue(is_method_exist)
@attr(series=True)
def test049_filter_by_testunit_changed_by(self):
"""
New: Test units: Filter Approach: Make sure you can filter by changed by
LIMS-6428
"""
self.login_page = Login()
self.info('Calling the users api to create a new user with username')
response, payload = UsersAPI().create_new_user()
self.assertEqual(response['status'], 1, payload)
self.login_page.logout()
self.login_page.login(username=payload['username'], password=payload['password'])
self.base_selenium.wait_until_page_url_has(text='dashboard')
self.test_units_page.get_test_units_page()
new_name = self.generate_random_string()
method = self.generate_random_string()
test_unit_no = self.test_unit_page.create_qualitative_testunit(name=new_name, method=method)
self.test_unit_page.save_and_wait()
self.assertTrue(test_unit_no, 'Test unit not created')
self.info('New unit is created successfully with number: {}'.format(test_unit_no))
self.test_units_page.sleep_tiny()
test_unit_found = self.test_units_page.filter_by_user_get_result(payload['username'])
self.assertTrue(test_unit_found)
@parameterized.expand([('Name', 'Type'),
('Name', 'Method'),
('Name', 'No'),
('Type', 'Method'),
('Type', 'No'),
('No', 'Method'),
('Unit', 'No'),
('Quantification Limit', '')
])
@attr(series=True)
def test051_test_unit_name_allow_user_to_search_with_selected_two_options_order(self, first_search_option,
second_search_option):
"""
Test Unit: Configuration: Test units Name Approach: When the user select any two options
from the test unit configuration, this action should reflect on the order form
LIMS-6672
Orders: Default filter test unit Approach: Allow the search criteria in the drop down list
in the filter section to be same as in the form
LIMS-7414
"""
options_exist = {}
order_page = Order()
self.test_unit_page.open_configurations()
self.test_unit_page.open_testunit_name_configurations_options()
self.test_unit_page.select_option_to_view_search_with(
view_search_options=[first_search_option, second_search_option])
self.info('create new quantitative test unit with unit and quantification')
response, payload = self.test_unit_api.create_quantitative_testunit(
useSpec=False, useQuantification=True, unit='m[g]{o}',
quantificationUpperLimit=self.generate_random_number(lower=50, upper=100),
quantificationLowerLimit=self.generate_random_number(lower=1, upper=49))
self.assertEqual(response['status'], 1, payload)
quantification_limit = '{}-{}'.format(payload['quantificationLowerLimit'],
payload['quantificationUpperLimit'])
self.info('new test unit created with number {}'.format(payload['number']))
self.info('get random order')
radndom_order = random.choice(OrdersAPI().get_all_orders_json())
self.assertTrue(radndom_order, 'No order selected')
self.info('navigate to order edit page')
order_page.get_order_edit_page_by_id(radndom_order['orderId'])
order_page.sleep_small()
if first_search_option == "Type":
if second_search_option == "Method":
checked_text = f'Quantitative: {payload["method"]}'
elif second_search_option == "No":
checked_text = f'Quantitative: {payload["number"]}'
else:
checked_text = f'{payload["name"]}: Quantitative'
self.info("is test unit options existing?")
options_exist['is_name_exist'] = order_page.is_test_unit_option_exist(search_field=payload['name'])
options_exist['is_no_exist'] = order_page.is_test_unit_option_exist(search_field=str(payload['number']))
options_exist['is_type_exist'] = order_page.is_test_unit_option_exist(search_field='Quantitative',
checked_text=checked_text)
options_exist['is_method_exist'] = order_page.is_test_unit_option_exist(search_field=payload['method'])
options_exist['is_unit_exist'] = order_page.is_test_unit_option_exist(search_field=payload['unit'])
options_exist['is_quantification_limit_exist'] = order_page.is_test_unit_option_exist(
search_field=quantification_limit)
for key, value in options_exist.items():
if (first_search_option.lower().replace(' ', '_') in key) or (len(second_search_option.lower()) > 0 and second_search_option.lower() in key):
self.assertTrue(value, f'{key} value should be True')
else:
self.assertFalse(value, f'{key} value should be False')