def setUp(self) -> None:
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_browser_max()
self.base_page.implicitly_wait()
self.base_page.open_url(local_config.url)
self.test_data = TestDataUtils('main_suite',
'main_suite').get_test_data()
def request(self):
try:
with Database() as session:
with Browser() as browser_session:
url = self.url(Category.NEWSLETTER.value)
response = browser_session.get(url)
response.raise_for_status()
soup = bs4.BeautifulSoup(response.content, 'html.parser')
elements = soup.select('#content-left a')
LOGGER.info('{} newsletters have been found'.format(
len(elements)))
if len(elements) == 0:
LOGGER.info('Done, no more newsletters')
return
for element in reversed(elements):
href = element['href']
title = element.text
model, created = session.get_or_create(Newsletter,
url=href,
title=title)
if not created:
LOGGER.info(
f'Newsletter "{href}" ...skipped (duplicate)')
else:
LOGGER.info(f'{href} ...added')
except requests.exceptions.HTTPError as exc:
LOGGER.warning('Scraping {} {} ...skipping'.format(
url, exc.response.status_code))
raise exc
def request(self):
with Database() as session:
with Browser() as browser_session:
url = self.url(Category.INVOICE.value)
loop = True
while loop:
try:
response = browser_session.get(url)
response.raise_for_status()
soup = bs4.BeautifulSoup(response.content,
'html.parser')
elements = soup.select(
'#dokumenty table.tabulka tr:not(.hlavicka)')
if len(elements) == 0:
LOGGER.info('Done, no more invoices')
return
for element in elements:
published, _, title, _, _, _, document = element.findChildren(
'td')
link = document.findChild('a').attrs.get('href')
size_in_mb = re.search(r'([0-9\.]+)',
document.text).groups()[0]
is_pdf = re.search(r'\.pdf$', url)
if is_pdf:
model, created = session.get_or_create(
Invoice,
published=datetime.date.fromisoformat(
published.text),
title=title.text,
url=link,
size_in_mb=size_in_mb)
if not created:
LOGGER.info(
f'Invoice {model.url} ...skipped (duplicate)'
)
loop = False
else:
LOGGER.info(f'{model.url} ...added')
else:
LOGGER.warning(
f'Invoice {model.url} ...skipped (not PDF)'
)
next_url = soup.select_one(
'#dokumenty table:first-of-type [align="right"] a:nth-last-child(2)'
).attrs.get('href')
next_url = urljoin(self.base_url(response.url),
next_url)
# FIXME: first page can be w/o the page number
if next_url == url:
return
url = next_url
except requests.exceptions.HTTPError as exc:
LOGGER.warning('Scraping {} {} ...skipping'.format(
url, exc.response.status_code))
raise exc
def setUp(self):
'''
测试用例的初始化
:return:
'''
logger.info('--------测试方法初始化---------------')
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_browser_max()
self.base_page.implicitly_wait()
self.base_page.open_url(local_config.url)
def request(self):
try:
with Database() as session:
with Browser() as browser_session:
url = self.url(Category.PROCUREMENT.value)
response = browser_session.get(url)
response.raise_for_status()
soup = bs4.BeautifulSoup(response.content, 'html.parser')
main_element = soup.select_one('#content-left ol')
procurements = main_element.select('a')
offers = main_element.find_next_siblings('a')
LOGGER.info('{} procurements have been found'.format(
len(procurements)))
if len(procurements) == 0:
LOGGER.info('Done, no more procurements')
for element in procurements:
href = element['href']
title = element.text
model, created = session.get_or_create(Procurement,
url=href,
title=title)
if not created:
LOGGER.info(
f'Procurement "{href}" ...skipped (duplicate)')
else:
LOGGER.info(f'{href} ...added')
LOGGER.info('{} offers have been found'.format(
len(offers)))
if len(offers) == 0:
LOGGER.info('Done, no more offers')
return
for element in offers:
href = element['href']
title = element.text
model, created = session.get_or_create(Procurement,
url=href,
title=title,
is_offer=True)
if not created:
LOGGER.info(
f'Offer "{href}" ...skipped (duplicate)')
else:
LOGGER.info(f'{href} ...added')
except requests.exceptions.HTTPError as exc:
LOGGER.warning('Scraping {} {} ...skipping'.format(
url, exc.response.status_code))
raise exc
def setUpClass(cls):
serino = "MDEVICE"
#serino = "adede7a6"
cls.url = "http://122.225.253.188/"
if len(sys.argv) > 1:
serino = sys.argv[1]
if Configs("common").get("product", "Info") == "Sprints":
cls.mod = Chrome(serino, "Browser")
else:
cls.mod = Browser(serino, "Browser")
cls.set = Settings(cls.mod.device, "Settings")
def __init__(self, device, mod):
self.device = connect_device(device)
self.logger = createlogger(mod)
self.log_path = create_folder()
self.camera = Camera(self.device, "task_camera")
self.product = Configs("common").get("product", "Info")
if self.product == "Sprints":
from common.chrome import Chrome
self.browser = Chrome(self.device, "task_browser")
else:
self.browser = Browser(self.device, "Browser")
self.tel = Telephony(self.device, "task_tel")
self.message = Message(self.device, "task_message")
self.settings = Settings(self.device, "switch_nw")
self.suc_times = 0
self.mod_cfg = GetConfigs(mod)
self.test_times = 0
self.dicttesttimes = self.mod_cfg.get_test_times()
for test_time in self.dicttesttimes:
self.test_times += int(self.dicttesttimes[test_time])
self.test_times = self.test_times * 2 + 4
self.logger.info("Trace Total Times " + str(self.test_times))
def request(self):
try:
with Database() as session:
with Browser() as browser_session:
url = self.url(Category.BUDGET.value)
response = browser_session.get(url)
response.raise_for_status()
soup = bs4.BeautifulSoup(response.content, 'html.parser')
elements = soup.select('#content-left a')
LOGGER.info('{} budgets have been found'.format(
len(elements)))
if len(elements) == 0:
LOGGER.info('Done, no more budgets')
return
for element in reversed(elements):
href = element['href']
title = element.text
if not re.search(r'\d', title):
sufix = element.findPreviousSibling('h2').text
title = f'{title} {sufix}'
model, created = session.get_or_create(Budget,
url=href,
title=title)
if not created:
LOGGER.info(
f'Budget "{href}" ...skipped (duplicate)')
else:
LOGGER.info(f'{href} ...added')
except requests.exceptions.HTTPError as exc:
LOGGER.warning('Scraping {} {} ...skipping'.format(
url, exc.response.status_code))
raise exc
def request(self):
try:
with Database() as session:
with Browser() as browser_session:
url = self.url(Category.REPORT.value)
response = browser_session.get(url)
response.raise_for_status()
soup = bs4.BeautifulSoup(response.content, 'html.parser')
elements = soup.select('#content-left tr')
LOGGER.info('{} reports have been found'.format(
len(elements)))
if len(elements) == 0:
LOGGER.info('Done, no more reports')
return
for element in elements:
date, title = element.findChildren('td')
title = re.sub(r'[\n\s]+', ' ', title.text)
model, created = session.get_or_create(
Report,
date=date.text.strip(),
title=title.strip())
if not created:
LOGGER.info(
f'Report "{model.title[:30]}..." ...skipped (duplicate)'
)
else:
LOGGER.info(f'"{model.title[:40]}..." ...added')
except requests.exceptions.HTTPError as exc:
LOGGER.warning('Scraping {} {} ...skipping'.format(
url, exc.response.status_code))
raise exc
self.input(self.password_inputbox, password)
def click_keeplogin(self):
self.click(self.keeplogin_checkbox)
def click_login(self):
self.click(self.login_button)
if __name__ == '__main__':
# webdriver = webdriver.Chrome()
# login_page = LoginPage(webdriver)
# webdriver.get('http://127.0.0.1/biz/user-login.html')
# login_page.set_browser_max()
# time.sleep(3)
# login_page.input_username('admin')
# login_page.input_password('admin123456')
# login_page.click_keeplogin()
# login_page.click_login()
# driver = Browser().get_chrome() # 调用二次封装chromedriver
driver = Browser().get_driver() # 调用二次封装的driver，根据配置改浏览器
login_page = LoginPage(driver)
login_page.open_url('http://127.0.0.1/biz/user-login.html')
login_page.set_browser_max()
time.sleep(3)
login_page.input_username('admin')
login_page.input_password('admin123456')
login_page.click_keeplogin()
login_page.click_login()
def setUp(self) -> None: # 针对方法级别的
print('SeleniumBaseCase.setUp')
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_browser_max()
self.base_page.implicitly_wait()
self.base_page.open_url(self.url)
def delete_attribute01(self, content):
self.delete_element_attribute01(self.show_select_result, content)
def execute_js1(self, js_str):
self.execute_script(js_str, self.show_select_result)
def execute_js2(self, js_str):
self.execute_script(js_str)
def update_attribute(self, attribute_name, attribute_value):
self.update_element_attribute(self.show_select_result, attribute_name,
attribute_value)
if __name__ == '__main__':
sample04_page = Sample04(Browser().get_driver())
sample04_page.set_browser_max()
sample04_page.open_url('file://' + page_path)
sample04_page.implicitly_wait()
# sample04_page.delete_attribute('value')
sample04_page.delete_attribute01('value')
# sample04_page.update_attribute('value','newdream')
# js_str1= 'arguments[0].removeAttribute("value");'
# sample04_page.execute_js1(js_str1)
# js_str2='document.body.scrollTop=%d;'
# sample04_page.execute_js2(js_str2%5000)
super().__init__(driver)
elements = ElementDataUtils('sample02', 'sample02_page').get_element()
self.frame_xpath = elements['frame_xpath']
self.input01_inputbox = elements['input01_inputbox']
self.input02_inputbox = elements['input02_inputbox']
self.span_text = elements['span_text']
def frame_info(self):
self.switch_to_frame(self.frame_xpath)
def input_text01(self, content):
self.input(self.input01_inputbox, content)
def input_text02(self, content):
self.input(self.input02_inputbox, content)
def get_span_text(self):
self.get_text(self.span_text)
if __name__ == '__main__':
sample02_page = Sample02(Browser().get_driver())
sample02_page.open_url('file://' + page_path)
sample02_page.implicitly_wait()
sample02_page.frame_info()
# sample02_page.switch_to_frame_id_or_name('frame１')
sample02_page.input_text01('newdream')
sample02_page.input_text02('test')
sample02_page.switch_to_default_content()
sample02_page.get_span_text()
def setUp(self):
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_maxwindow()
self.base_page.implicitly_wait()
self.base_page.open_url(self.url)
#调用父类方法
def clickzaotao(self):
self.click(self.caotao_button)
def inputusername(self,username):
self.input(self.username_inputbox,username)
def inputuserpassword(self,password):
self.input(self.userpassword_inputbox,password)
def clicklogin(self):
self.click(self.login_button)
def switch_accept(self):
self.accept()
if __name__=="__main__":
try:
dri=Browser('chrome').getdriver()
driver=LoginPage(dri)
driver.openurl('http://106.53.50.202:8999/zentao3/www/user-login-L3plbnRhbzYvd3d3Lw==.html')
driver.waittime()
driver.setmaxbrowser()
driver.inputusername('admin')
driver.inputuserpassword('a12345678')
driver.clicklogin()
driver.waittime(2)
finally:
driver.quitbrowsr()
def setUp(self) -> None:
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_maxwindow()
self.base_page.implicitly_wait()
self.base_page.open_url(conf.get_chandao_path)
def setUp(self) -> None:
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_browser_max()
self.base_page.implicitly_wait()
self.base_page.open_url(local_config.url)
self.input(self.iterative_description,description)
def switchto_default_content(self): # 切换到默认frame
self.switch_to_default_content()
def slide_element(self): # 滑到保存按钮
self.slide_specified_element(self.preservation)
def click_preservation(self): # 点击保存按钮
self.click(self.preservation)
def click_close_button(self): # 点击关闭按钮
self.click(self.close_button)
if __name__ == '__main__':
base_page = BasePage(Browser().get_driver())
base_page.open_url(local_config.url)
login_action = LoginAction(base_page.driver)
main_page = login_action.default_login()
main_page.goto_project()
createnewiterationpage = CreateNewIterationPage(base_page.driver)
createnewiterationpage.click_create_iteration()
createnewiterationpage.input_iteration_name('公共研发组sprint3')
createnewiterationpage.input_iteration_code('sprint3')
createnewiterationpage.clear_data_content()
createnewiterationpage.input_start_date('2020-04-24')
createnewiterationpage.click_start_date()
createnewiterationpage.input_close_date('2020-05-20')
createnewiterationpage.click_close_date()
createnewiterationpage.input_team_name('公共研发组sprint3')
createnewiterationpage.click_iteration_type()
def setUp(self) -> None:
logger.info('♥❤♥❤测试方法开始执行♥❤♥❤!')
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_driver()
current_path = os.path.dirname(__file__)
page_path = os.path.join(current_path, '../../pages/element_samples.html')
class Sample06(BasePage):
def __init__(self, driver):
super().__init__(driver)
elements = ElementDataUtils('sample06', 'sample06_page').get_element()
self.select_menu = elements['select_menu']
self.government_service_link = elements['government_service_link']
def select_government(self, government_name):
self.select_by_visible_text(self.select_menu, government_name)
def click_government_service_link(self, nemu_name):
self.government_service_link[
'locator_value'] = self.government_service_link[
'locator_value'] % nemu_name
self.click(self.government_service_link)
if __name__ == '__main__':
sample06_page = Sample06(Browser().get_driver())
sample06_page.open_url('file://' + page_path)
sample06_page.implicitly_wait()
sample06_page.set_browser_max()
sample06_page.select_government('开封教育网')
sample06_page.switch_to_handle_by_title('开封市教育体育局')
# sample06_page.switch_to_handle_by_url('http://jtj.kaifeng.gov.cn/')
sample06_page.click_government_service_link('政务服务')
# encoding:utf-8
# @author: lvhuayan
# @file: login_page.py
# @time: 2021/3/16 13:33
# @desc:
import os
from selenium import webdriver
from common.base_page import BasePage
from common.browser import Browser
from common.element_data_utils import ElementDataUtils
#测试base_page中switch_to_alert方法是否封装正确
current_path=os.path.dirname(__file__)
page_path=os.path.join(current_path,'../../pages/element_samples.html')
class Sample01(BasePage):
def __init__(self,driver):
super().__init__(driver)
elements=ElementDataUtils('sample01','sample01_page').get_element()
self.button_toalert=elements['button_toalert']
def click_alert_button(self):#点击测试alert弹框按钮
self.click(self.button_toalert)
if __name__=='__main__':
sample01_page=Sample01(Browser().get_driver())
sample01_page.open_url('file://'+page_path)
sample01_page.implicitly_wait()
sample01_page.click_alert_button()
sample01_page.switch_to_alert()
def setUp(self) -> None:
self.base_page = Basepage(Browser().get_chrome_dirver())
self.base_page.set_browser_max()
self.base_page.implicitly_wait()
self.base_page.open_url(config.get_url_path)
def login_action(self, username, password):
self.login_page.input_username(username)
self.login_page.input_password(password)
self.login_page.click_login()
def login_success(self, username, password):
self.login_action(username, password)
return MainPage(self.login_page.driver)
def default_login(self):
self.login_success(username=config.user_name,
password=config.pass_word)
def login_fail(self, username, password):
self.login_action(username, password)
value = self.login_page.get_login_fail_alert(type='yes',
selector='alert')
return value
def login_by_cookie(self):
pass
if __name__ == '__main__':
driver1 = Browser().get_driver()
loginaction = LoginAction(driver1)
driver1.get(
'http://106.53.50.202:8999/zentao2/www/user-login-L3plbnRhbzYvd3d3Lw==.html'
)
loginaction.login_success('chenjuan', '1q2w3e4r,')
def setUpClass(cls):
print('==========测试类开始初始化================')
cls.base_page = BasePage(Browser().get_driver())
cls.base_page.set_browser_max()
cls.base_page.implicitly_wait()
cls.base_page.open_url(local_config.url)
from elements_infos.login.login_page import LoginPage
from elements_infos.main.main_page import MainPage
from common.config_utils import local_config
from common.browser import Browser
class QuitAction:
def __init__(self, driver):
self.main_page = MainPage(driver)
def quit(self):
self.main_page.click_username()
self.main_page.click_quit_button()
return LoginPage(self.main_page.driver)
if __name__ == '__main__':
driver = Browser().get_driver()
driver.get('http://47.107.178.45/zentao/www/index.php?m=user&f=login')
#测试base_page中select下拉框方法是否封装正确
current_path = os.path.dirname(__file__)
page_path = os.path.join(current_path, '../../pages/element_samples.html')
class Sample03(BasePage):
def __init__(self, driver):
super().__init__(driver)
elements = ElementDataUtils('sample03', 'sample03_page').get_element()
self.select_menu = elements['select_menu']
def select_menu_value1(self, content):
self.select_by_visible_text(self.select_menu, content)
def select_menu_value2(self, content):
self.select_by_value(self.select_menu, content)
def select_menu_value3(self, content):
self.select_by_index(self.select_menu, content)
if __name__ == '__main__':
sample03_page = Sample03(Browser().get_driver())
sample03_page.set_browser_max()
sample03_page.open_url('file://' + page_path)
sample03_page.implicitly_wait()
# sample03_page.select_menu_value1('香蕉')
# sample03_page.select_menu_value2('peach')
sample03_page.select_menu_value3(4)
def setUp(self) -> None:
logger.info('-------------测试方法开始执行------------')
self.base_page = BasePage(Browser().get_driver())
self.base_page.set_browser_max()
self.base_page.implicitly_wait()
self.base_page.open_url(self.url)
def setUp(self) -> None:
self.basepage = BasePage(Browser('chrome').getdriver())
self.basepage.waittime(10)
self.basepage.openurl(self.url)
self.basepage.setmaxbrowser()
