def role_update(self, companyname, rolename, valuedict, expectation="pass"):
self.start_test(locals())
companyname, rolename, key, value, expectation = self.process_update_input(companyname=companyname,
rolename=rolename,
valuedict=valuedict,
expectation=expectation)
self.login_company_admin()
self.choose_company(companyname=companyname)
self.role_manage_enter()
found_role = self.role_search(rolename=rolename)
if found_role == {}:
self.assertTrue(False, "Cannot find role: " + rolename)
found_correct = found_role["rolename"] == rolename
print("Found info: \n" + str(found_role))
self.assert_true(found_correct,
"Found info doesn't match \n" + "Try to find: " + rolename + "\n But find " + str(
found_role))
edit_selector = str(found_role["edit_selector"])
self.role_update_start(edit_selector)
role_entity = Role()
role = rolename
service_list = None
user_list = None
if "rolename" in key:
role = str(value["rolename"])
self.role_create_update_set_rolename(role)
if "service" in key:
service_list = str(value["service"])
service_list = utilities.str_to_list(service_list)
fail_msg = None
self.role_create_update_set_service_list(service_list=service_list, fail_msg=fail_msg, expectation=expectation)
if "user" in key:
user_list = str(value["user"])
user_list = utilities.str_to_list(user_list)
fail_msg = None
self.role_create_update_set_user_list(user_list=user_list, fail_msg=fail_msg, expectation=expectation)
self.role_create_update_submit(expectation)
if expectation == "pass":
time.sleep(10) # Too slowly to refresh record in page
self.verify_role_info(role, service_list, user_list)
self.logout(COMPANYADMIN_ACCOUNT)
self.end_test(self._testMethodName)
def get_flat_authority_info(self, column="site"):
df = self.df[["email", "company", column]]
#print("Original df: " + str(df))
flat_authority_df = pd.DataFrame(columns=["company", column, "email"])
for index, row in df.iterrows():
email = row["email"]
company_list = utilities.str_to_list(row["company"])
site_dict = utilities.str_to_dict(row[column])
if company_list is None or company_list == []:
continue
for company in company_list:
to_append_list = ["", "", ""]
to_append_list[0] = company
to_append_list[2] = email
if site_dict is None or site_dict == {}:
continue
site_list = site_dict[company]
for site in site_list:
to_append_list[1] = site
flat_authority_df = flat_authority_df.append(
pd.Series(to_append_list,
index=['company', column, 'email']),
ignore_index=True)
return flat_authority_df
def update_authority_list_value_column(self,
email,
column,
value: list,
action="add"):
if value is None:
return False
existing_value = utilities.str_to_list(
list(self.df.loc[self.df.email == email, column])[0])
if existing_value is None:
existing_value = []
print("existing_value: " + str(existing_value))
print("value to process: " + str(value))
if action == "add":
existing_value.extend(value)
dest_value = existing_value
print(dest_value)
dest_value = list(set(dest_value))
elif action == "remove":
dest_value = list(set(existing_value) - set(value))
else:
print("Wrong action")
return False
dest_value = utilities.list_to_str(dest_value)
self.df.loc[self.df.email == email, column] = dest_value
return True
def replace_any_with_specific_site(self, flat_authority_df):
entity = Entity()
entity_df = entity.df
columns = flat_authority_df.keys()
dest_flat_authority_df = pd.DataFrame(columns=columns)
for index, row in flat_authority_df.iterrows():
to_append_list = ["", "", ""]
if row["site"] == SITE_ANY_SITE:
#print("get site record")
#print(list(entity_df[entity_df["company"] == row["company"]]))
site_value = list(
entity_df[entity_df["company"] == row["company"]]["site"])
if site_value != [] and site_value is not None:
site_list = utilities.str_to_list(site_value[0])
if site_list is not None and len(site_list) > 0:
for site in site_list:
to_append_list[0] = row["company"]
to_append_list[1] = site
to_append_list[2] = row["email"]
dest_flat_authority_df = dest_flat_authority_df.append(
pd.Series(to_append_list, index=columns),
ignore_index=True)
else:
dest_flat_authority_df = dest_flat_authority_df.append(
pd.Series(row, index=columns), ignore_index=True)
#print("anysite_processed_flat_authority_df: " + str(dest_flat_authority_df))
return dest_flat_authority_df
def update_entity_key_list_value_column(self, company, column, value: dict, action="add"):
if value is None:
return False
print("Start update_entity_profile_key_list_value_column")
print(locals())
existing_key_value = list(self.df.loc[self.df.company == company, column])[0]
print("existing_key_value from df: " + str(existing_key_value))
if existing_key_value is None:
existing_key_value = {}
else:
existing_key_value = eval(existing_key_value)
print("existing_key_value from df: " + str(existing_key_value))
for ex_key, ex_value in existing_key_value.items():
existing_key_value[ex_key] = utilities.str_to_list(str(ex_value))
print("existing_key_value_list: " + str(existing_key_value))
print("value to process: " + str(value))
(to_key, to_value), = dict(value).items()
if existing_key_value == {}:
if action == "add":
dest_key_value = dict(value)
if action == "remove":
dest_key_value = existing_key_value
if (existing_key_value != {}) and (to_key not in existing_key_value.keys()):
if action == "add":
dest_key_value = {**existing_key_value, **dict(value)}
if action == "remove":
dest_key_value = existing_key_value
if (existing_key_value != {}) and (to_key in existing_key_value.keys()):
for ex_key, ex_value in existing_key_value.items():
if ex_key == to_key:
if action == "add":
ex_value.extend(to_value)
existing_key_value[ex_key] = list(set(ex_value))
if action == "remove":
existing_key_value[ex_key] = list(set(ex_value) - set(to_value))
dest_key_value = existing_key_value
print("dest_key_value: " + str(dest_key_value))
dest_value = utilities.dict_to_str(dest_key_value)
print("dest_value: " + str(dest_value))
self.df.loc[self.df.company == company, column] = dest_value
print(self.df)
return True
def get_user_info(self, email, column):
if column not in AUTHORITY_COLUMNS:
return None
info = list(self.df[self.df["email"] == email][column])
if len(info) > 0:
if column in AUTHORITY_SINGLE_VALUE_COLUMNS:
return str(info[0])
if column in AUTHORITY_LIST_VALUE_COLUMNS:
return utilities.str_to_list(str(info[0]))
if column in AUTHORITY_KEY_LIST_VALUE_COLUMNS:
return utilities.str_to_dict(str(info[0]))
def verify_company_info(self, companyname, status, email_list):
print("Start to verify company info")
print(locals())
found_company = self.company_search(companyname)
if found_company == {}:
self.assertTrue(False, "Cannot find company: " + companyname)
correct_info = found_company["companyname"] == companyname
if correct_info and status != None:
correct_info = correct_info and found_company["status"] == status
if correct_info and email_list != None:
companyadmin_list = found_company["companyadmin"]
companyadmin_list = utilities.str_to_list(companyadmin_list)
email_list = list(set(email_list))
correct_info = correct_info and sorted(companyadmin_list) == sorted(email_list)
# print(found_company)
if not correct_info:
print("Company info doesn't match")
print("Expected: " + companyname + " " + str(status) + " " + str(email_list))
print("Got: " + str(found_company))
self.assertTrue(correct_info, "Company info doesn't match \n" + "Expected: " + companyname + " " + str(status) + " " + str(email_list) + "\n" + "Got: " + str(found_company))
def get_email_list(self, bycolumn=None, value=None, company=None):
print("In Authority get_email_list")
print(locals())
df = pd.DataFrame(columns=self.df.keys())
for id, row in self.df.iterrows():
if company in row["company"]:
df = df.append(row)
if bycolumn not in AUTHORITY_COLUMNS:
return None
if bycolumn is None and value is None:
email_list = list(df["email"])
if bycolumn in AUTHORITY_SINGLE_VALUE_COLUMNS:
email_list = list(df[df[bycolumn] == value]["email"])
if bycolumn in AUTHORITY_LIST_VALUE_COLUMNS:
email_list = []
for index, item in df.iterrows():
if value in utilities.str_to_list(item[bycolumn]):
email_list.append(item["email"])
if bycolumn in AUTHORITY_KEY_LIST_VALUE_COLUMNS:
email_list = []
for index, item in df.iterrows():
print("Content of item: " + str(item))
info_dict = utilities.str_to_dict(item[bycolumn])
for info_key, info_value in info_dict.items():
print("item['email']: " + str(item["email"]))
print("info_value in item: " + str(info_value))
if value in info_value:
email_list.append(item["email"])
return email_list
def user_search(self, username):
# Only return one user with latest date
#Todo: use option selector
print("Search: " + username)
total_selector = "#pane-2 > div > div:nth-child(2) > div:nth-child(2) > div > span.el-pagination__total"
total, perpage, pages, next_page_selector_str, previous_page_selector_str = self.get_page_navigation_info(
total_selector)
if username == "":
return {}
info_dict = {}
max_date = "Jan 01, 2020"
dest_page = 0
for i in range(pages):
page = i + 1
if page > 1:
self.click(next_page_selector_str)
print("Start search in page: " + str(page))
if page == pages:
rows = total % perpage
if rows == 0:
rows = perpage
else:
rows = perpage
print("In page: " + str(page) + " " + str(rows) + " rows exist")
"""
'//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[1]/td[1]/div'
'//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[1]/td[2]/div'
'//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[2]/td[1]/div'
'//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[2]/td[1]/div'
'//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[1]/td[7]/div/button[1]/span'
'//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[1]/td[7]/div/button[2]/span'
"""
selector_str_1 = '//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr['
selector_str_2 = ']/td['
selector_str_3 = ']/div'
for r in range(rows):
date_selector_str = selector_str_1 + str(
r + 1) + selector_str_2 + '1' + selector_str_3
name_selector_str = selector_str_1 + str(
r + 1) + selector_str_2 + '2' + selector_str_3
display_name_selector_str = selector_str_1 + str(
r + 1) + selector_str_2 + '3' + selector_str_3
status_selector_str = selector_str_1 + str(
r + 1) + selector_str_2 + '4' + selector_str_3
site_selector_str = selector_str_1 + str(
r + 1) + selector_str_2 + '5' + selector_str_3
role_selector_str = selector_str_1 + str(
r + 1) + selector_str_2 + '6' + selector_str_3
edit_selector_str = selector_str_1 + str(
r + 1
) + selector_str_2 + '7' + selector_str_3 + "/button[1]/span"
# edit_selector_str = '//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[' + str(r+1) + ']/td[7]/div/button[1]/span'
delete_selector_str = selector_str_1 + str(
r + 1
) + selector_str_2 + '7' + selector_str_3 + "/button[2]/span"
# delete_selector_str = '//*[@id="pane-2"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[' + str(r+1) + ']/td[7]/div/button[2]/span'
if self.is_element_present(name_selector_str):
row_date = self.get_text(date_selector_str)
row_username = self.get_text(name_selector_str)
print("In row: " + str(r + 1) + " username: "******" date: " + row_date)
if row_username == username and datetime.datetime.strptime(
str(row_date),
'%b %d, %Y').date() > datetime.datetime.strptime(
str(max_date), '%b %d, %Y').date():
max_date = row_date
dest_page = page
print("Got one match max_date: " + max_date +
" dest_page: " + str(dest_page))
info_dict["date"] = row_date
info_dict["username"] = row_username
info_dict["display_name"] = self.get_text(
display_name_selector_str)
info_dict["status"] = self.get_text(
status_selector_str)
info_dict["site_list"] = utilities.str_to_list(
self.get_text(site_selector_str))
info_dict["role_list"] = utilities.str_to_list(
self.get_text(role_selector_str))
info_dict["edit_selector"] = edit_selector_str
info_dict["delete_selector"] = delete_selector_str
info_dict["name_selector"] = name_selector_str
info_dict["date_selector"] = date_selector_str
else:
print("Selector str doesn't match")
if int(dest_page) > 0:
for i in range(pages - dest_page):
# self.type(".el-pagination__editor > .el-input__inner", str(dest_page) + Keys.ENTER)
self.click(previous_page_selector_str)
# self.wait_for_ready_state_complete()
print("Go to page: " + str(pages - i - 1))
print("Finally got max_date: " + max_date + " dest_page: " +
str(dest_page))
print("return info_dict: " + str(info_dict))
return info_dict
def company_update(self, companyname, valuedict, expectation):
self.start_test(locals())
companyname, key, value, expectation = self.process_update_input(
companyname, valuedict, expectation)
self.login_sysadmin()
found_company = self.company_search(companyname)
if found_company == {}:
self.assertTrue(False, "Cannot find company: " + companyname)
found_correct = found_company["companyname"] == companyname \
and self.get_text(found_company["name_selector"]) == found_company["companyname"] \
and self.get_text(found_company["id_selector"]) == found_company["id"]
print("Found info: \n" + str(found_company))
self.assert_true(
found_correct,
"Found info doesn't match what show on user interface \n" +
"Try to find: " + companyname + "\n But find " +
str(found_company))
edit_selector = str(found_company["edit_selector"])
if True:
self.company_update_start(edit_selector)
authority = Authority()
company = companyname
if "companyname" in key:
company = str(value["companyname"])
self.company_create_update_set_companyname(company)
email_list = authority.get_email_list(bycolumn="company",
value=companyname)
for email in email_list:
authority.update_authority_list_value_column(
email=email,
column="company",
value=[companyname],
action="remove")
authority.update_authority_list_value_column(
email=email,
column="company",
value=[company],
action="add")
if "status" in key:
status = str(value["status"])
self.company_create_update_set_status(status)
else:
status = None
if "email" in key:
email_list = str(value["email"])
email_list = utilities.str_to_list(email_list)
if expectation == "illegal_email_msg":
fail_msg = "The email address is invalid"
else:
fail_msg = None
self.company_create_update_set_email(email_list=email_list,
fail_msg=fail_msg,
expectation=expectation)
# deal with user profile
# email list connected with target company
existing_connected_email_list = authority.get_email_list(
bycolumn="company", value=company)
to_add_connection_email_list = [
i for i in email_list
if i not in existing_connected_email_list
]
print("To_add_connection_email_list: " +
str(to_add_connection_email_list))
for email in to_add_connection_email_list:
authority.add_authority(email=email, company=[company])
to_delete_email_list = [
i for i in existing_connected_email_list
if i not in email_list
]
print("To_delete_email_list: " +
str(to_delete_email_list)) #remove connection
for email in to_delete_email_list:
authority.update_authority_list_value_column(
email=email,
column="company",
value=[company],
action="remove")
else:
email_list = None
self.company_create_update_submit(expectation)
if expectation == "pass":
self.verify_company_info(company, status, email_list)
print("start to update user profile with: \n" +
str(authority.df))
authority.commit()
self.logout()
self.end_test(self._testMethodName)
def role_search(self, rolename):
# Only return one role with latest date
# Todo: use option selector
print("Search: " + rolename)
if rolename == "":
return {}
total_selector = "#pane-1 > div > div:nth-child(2) > div:nth-child(2) > div > span.el-pagination__total"
total, perpage, pages, next_page_selector_str, previous_page_selector_str = self.get_page_navigation_info(
total_selector)
info_dict = {}
max_date = "Jan 01, 2020"
dest_page = 0
for i in range(pages):
page = i + 1
if page > 1:
self.click(next_page_selector_str)
print("Start search in page: " + str(page))
if page == pages:
rows = total % perpage
if rows == 0:
rows = perpage
else:
rows = perpage
print("In page: " + str(page) + " " + str(rows) + " rows exist")
source = self.get_page_source()
soup = self.get_beautiful_soup(source)
tables = soup.find_all(name="table", class_="el-table__body")
# print("Get " + str(len(tables)) + " tables") table for site admin, role admin, user admin are together
table = tables[1]
tr = table.find('tr')
for r in range(rows):
tds = tr.find_all('td', recursive=False)
#print(tds[0].get_text(separator=';'))
#print(tds[1].get_text(separator=';'))
#print(tds[2].get_text(separator=';'))
#print(tds[3].get_text(separator=';'))
#print(tds[4].get_text(separator=';'))
row_date = tds[0].get_text(separator=';').strip()
row_rolename = tds[1].get_text(separator=';').strip()
print("In row: " + str(r + 1) + " rolename: " + row_rolename +
" date: " + row_date)
if row_rolename == rolename and datetime.datetime.strptime(
str(row_date),
'%b %d, %Y').date() > datetime.datetime.strptime(
str(max_date), '%b %d, %Y').date():
max_date = row_date
dest_page = page
print("Got one match max_date: " + max_date +
" dest_page: " + str(dest_page))
info_dict["rolename"] = row_rolename
info_dict["date"] = row_date
info_dict["preset"] = tds[2].get_text(
separator=';').strip()
info_dict["service_list"] = utilities.str_to_list(
tds[3].get_text(separator=';').strip())
info_dict["user_list"] = utilities.str_to_list(
tds[4].get_text(separator=';').strip())
edit_selector_str = ".el-table__row:nth-child(" + str(
r + 1) + ") .el-button:nth-child(1) > span"
delete_selector_str = ".el-table__row:nth-child(" + str(
r + 1) + ") .el-button:nth-child(2) > span"
info_dict["edit_selector"] = edit_selector_str
info_dict["delete_selector"] = delete_selector_str
info_dict["name_selector"] = None
info_dict["date_selector"] = None
tr = tr.find_next_sibling()
if int(dest_page) > 0:
for i in range(pages - dest_page):
# self.type(".el-pagination__editor > .el-input__inner", str(dest_page) + Keys.ENTER)
self.click(previous_page_selector_str)
# self.wait_for_ready_state_complete()
print("Go to page: " + str(pages - i - 1))
print("Finally got max_date: " + max_date + " dest_page: " +
str(dest_page))
print("Got info_dict: " + str(info_dict))
return info_dict
def site_search(self, sitename):
# Only return one site with latest date
#Todo: use option selector
print("Search: " + sitename)
total_selector = "#pane-0 > div > div:nth-child(2) > div:nth-child(2) > div > span.el-pagination__total"
total, perpage, pages, next_page_selector_str, previous_page_selector_str = self.get_page_navigation_info(
total_selector)
if sitename == "":
return {}
info_dict = {}
max_date = "Jan 01, 2020"
dest_page = 0
for i in range(pages):
page = i + 1
if page > 1:
self.click(next_page_selector_str)
print("Start search in page: " + str(page))
if page == pages:
rows = total % perpage
if rows == 0:
rows = perpage
else:
rows = perpage
print("In page: " + str(page) + " " + str(rows) + " rows exist")
for r in range(rows):
date_selector_str = "//tr[" + str(r + 1) + "]/td[1]/div"
name_selector_str = "//tr[" + str(r + 1) + "]/td[2]/div"
address_selector_str = "//tr[" + str(r + 1) + "]/td[3]/div"
label_selector_str = "//tr[" + str(r + 1) + "]/td[4]/div"
user_selector_str = "//tr[" + str(r + 1) + "]/td[5]/div"
# user_selector_str = '//*[@id="pane-0"]/div/div[2]/div[1]/div[1]/div[3]/table/tbody/tr[' + str(r + 1) + ']/td[5]/div/table'
edit_selector_str = ".el-table__row:nth-child(" + str(
r + 1) + ") .el-button:nth-child(1) > span"
# edit_selector_str = "/tr[" + str(r+1) +"]/td[7]/div/button[1]/span"
delete_selector_str = ".el-table__row:nth-child(" + str(
r + 1) + ") .el-button:nth-child(2) > span"
# delete_selector_str = "/tr[" + str(r+1) +"]/td[7]/div/button[2]/span"
if self.is_element_present(name_selector_str):
row_sitename = self.get_text(name_selector_str)
row_date = self.get_text(date_selector_str)
print("In row: " + str(r + 1) + " sitename: " +
row_sitename + " date: " + row_date)
if row_sitename == sitename and datetime.datetime.strptime(
str(row_date),
'%b %d, %Y').date() > datetime.datetime.strptime(
str(max_date), '%b %d, %Y').date():
max_date = row_date
dest_page = page
print("Got one match max_date: " + max_date +
" dest_page: " + str(dest_page))
info_dict["sitename"] = row_sitename
info_dict["date"] = row_date
info_dict["address"] = self.get_text(
address_selector_str)
info_dict["label_list"] = utilities.str_to_list(
self.get_text(label_selector_str))
if not self.is_element_present(user_selector_str):
time.sleep(10)
print("Got user list from page: " +
self.get_text(user_selector_str))
info_dict["user_list"] = utilities.str_to_list(
self.get_text(user_selector_str))
info_dict["edit_selector"] = edit_selector_str
info_dict["delete_selector"] = delete_selector_str
info_dict["name_selector"] = name_selector_str
info_dict["date_selector"] = date_selector_str
if int(dest_page) > 0:
for i in range(pages - dest_page):
# self.type(".el-pagination__editor > .el-input__inner", str(dest_page) + Keys.ENTER)
self.click(previous_page_selector_str)
# self.wait_for_ready_state_complete()
print("Go to page: " + str(pages - i - 1))
print("Finally got max_date: " + max_date + " dest_page: " +
str(dest_page))
return info_dict
