def test_default_state(browser: webdriver.Remote):
browser.get('https://the-internet.herokuapp.com/checkboxes')
first_checkbox = browser.find_element_by_xpath('//input[1]')
second_checkbox = browser.find_element_by_xpath('//input[2]')
assert not first_checkbox.is_selected()
assert second_checkbox.is_selected()
def test_state_after_checked(browser: webdriver.Remote):
browser.get('https://the-internet.herokuapp.com/checkboxes')
first_checkbox = browser.find_element_by_xpath(
'//input[@type="checkbox"][1]')
second_checkbox = browser.find_element_by_xpath(
'//input[@type="checkbox"][2]')
first_checkbox.click()
second_checkbox.click()
assert first_checkbox.is_selected()
assert not second_checkbox.is_selected()
def get_sso_session(
self,
selenium: webdriver.Remote,
impersonate_user=settings.TEST_IMPERSONATE_USER
) -> webdriver.Remote:
cookies = self.keycloak.impersonate(impersonate_user).cookies
# Note(knikolla): We must open a page in order to set cookies.
# Doesn't have to exist, but must be in same domain as SSO.
selenium.get(f'{settings.KEYCLOAK_URL}/auth/test')
for k in [x for x in cookies.keys() if 'KEYCLOAK' in x]:
selenium.add_cookie({
'name':
k,
'value':
cookies[k],
'domain':
parse.urlparse(settings.KEYCLOAK_URL).netloc.split(':')[0],
})
selenium.get(f'{settings.KEYCLOAK_URL}/auth/realms/master/account/')
selenium.implicitly_wait(5)
username = selenium.find_element_by_xpath('//*[@id="username"]')
assert username.get_attribute('value') == impersonate_user
return selenium
def test_removing(browser: webdriver.Remote):
browser.get('https://the-internet.herokuapp.com/add_remove_elements/')
btn_add = browser.find_element_by_xpath('//button[text()="Add Element"]')
max_add = random.randint(2, 15)
print(f"will add button for {max_add} times ")
for x in range(0, max_add):
btn_add.click()
time.sleep(
0.1
) # make little bit visible ahaha :D believe me you wont see it, try to remark
btns_delete = browser.find_elements_by_css_selector('#elements button')
print('total btns_delete: ', len(btns_delete))
print(btns_delete)
for btn_delete in btns_delete:
btn_delete.click()
time.sleep(
0.1
) # make little bit visible ahaha :D believe me you wont see it, try to remark
# before getting not found items, we should reduce implicit time to make selenium wait shorter
browser.implicitly_wait(1)
btns_delete = browser.find_elements_by_css_selector('#elements button')
assert len(btns_delete) == 0
def login_succeed(ip, browser):
driver = Remote(command_executor=ip,
desired_capabilities={'platform': 'ANY',
'browserName': browser,
'version': '',
'javascriptEnabled': True,
})
url = "http://192.168.117.9:8080/jforum/forums/list.page"
driver.get(url)
try:
driver.find_element_by_name('username').send_keys('admin')
driver.find_element_by_name('password').send_keys('admin')
driver.find_element_by_name('login').click()
request = driver.find_element(By.ID, 'myprofile').text
print(request)
find_digit = driver.find_element_by_xpath("//table[@cellpadding='2']/tbody/tr[4]/td[4]").text
print(find_digit)
"""截图"""
driver.save_screenshot(filename='loginSucceed.png')
except NoSuchElementException as e:
print(e)
finally:
sleep(2)
driver.quit()
def test_adding(browser: webdriver.Remote):
browser.get('https://the-internet.herokuapp.com/add_remove_elements/')
btn_add = browser.find_element_by_xpath('//button[text()="Add Element"]')
# Check default state
browser.implicitly_wait(
0.3
) # before getting not found items, we should reduce implicit time to make selenium wait shorter
btns_delete = browser.find_elements_by_css_selector('#elements button')
assert len(btns_delete) == 0
browser.implicitly_wait(5) # restore it
btn_add.click()
btns_delete = browser.find_elements_by_css_selector('#elements button')
assert len(btns_delete) > 0
class ManageRestaurantTagsTest(unittest.TestCase):
LOGIN = os.environ['ADMIN_LOGIN']
PASSWORD = os.environ['ADMIN_PASSWORD']
ADDRESS = 'Россия, Москва, 2-я Бауманская улица, 5с1'
LONGITUDE = 55.765985
LATITUDE = 37.68456
TAG_NAME = ('Test Tag%s' % time.asctime()).replace(' ', '')
MAIN_URL = 'http://skydelivery.site/restaurant_list/1'
REST_ELEMENT = '//div[contains(@class, "restaurant-list__restaurant-{}")]'
REST_LIST = '//div[@id="restaurant-list"]'
REST_NAME = './/span[@class="restaurant__name"]'
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
AddressPage(self.driver).open()
storage = LocalStorage(self.driver)
storage.set('deliveryGeo', self.ADDRESS)
storage.set('longitude', self.LONGITUDE)
storage.set('latitude', self.LATITUDE)
self.driver.refresh()
self.driver.maximize_window()
main_page = MainPage(self.driver)
main_page.wait_visible()
main_page.auth(self.LOGIN, self.PASSWORD)
self.filler = DatabaseFiller()
self.filler.admin_auth()
self.filler.create_test_restaurants(1)
self.filler.create_tag(self.TAG_NAME)
self.tag_id = self.filler.get_tag_by_name(self.TAG_NAME)
self.rest_id = self.filler.get_restaurant_id_by_name(
self.filler.TEST_REST_NAME.format(0))
self.rest_list_page = AdminRestaurantsPage(self.driver)
self.rest_list_page.open()
self.rest_list_page.wait_visible()
self.rest_list_page.open_manage_tags(self.rest_id)
self.form = self.rest_list_page.manage_tags_form
self.form.wait_visible()
def tearDown(self):
self.filler.delete_all_rests()
self.filler.delete_tag(self.TAG_NAME)
self.driver.quit()
def testAddTagToRestaurant(self):
self.form.set_tag(self.tag_id)
self.form.submit()
self.form.wait_visible()
WebDriverWait(self.driver, 5,
0.1).until(lambda d: self.form.message() != '')
self.assertEqual(self.form.message(), 'Теги успешно изменены')
main_page = MainPage(self.driver)
main_page.open()
main_form = main_page.main_form
main_form.wait_open()
main_form.set_tag(self.tag_id)
WebDriverWait(self.driver, 5,
0.3).until(lambda d: d.current_url == self.MAIN_URL)
main_page.wait_visible()
WebDriverWait(
self.driver, 5, 0.3).until(lambda d: d.find_element_by_xpath(
self.REST_LIST).find_element_by_xpath(
self.REST_ELEMENT.format(self.rest_id)).is_displayed())
rest_el = self.driver.find_element_by_xpath(
self.REST_LIST).find_element_by_xpath(
self.REST_ELEMENT.format(self.rest_id))
self.assertEqual(
rest_el.find_element_by_xpath(self.REST_NAME).text,
self.filler.TEST_REST_NAME.format(0))
def testDeleteTagFromRestaurant(self):
self.filler.add_tag_to_restaurant(self.TAG_NAME,
self.filler.TEST_REST_NAME.format(0))
self.driver.refresh()
self.form.wait_visible()
self.form.unset_tag(self.tag_id)
self.form.submit()
WebDriverWait(self.driver, 5,
0.1).until(lambda d: self.form.message() != '')
self.assertEqual(self.form.message(), 'Теги успешно изменены')
main_page = MainPage(self.driver)
main_page.open()
main_form = main_page.main_form
main_form.wait_open()
main_form.set_tag(self.tag_id)
WebDriverWait(self.driver, 5,
0.1).until(lambda d: d.current_url == self.MAIN_URL)
self.driver.refresh()
main_page.wait_visible()
self.assertEqual(
self.driver.find_element_by_xpath(self.REST_LIST).text,
'К сожалению, мы пока не доставляем в ваш район 🙁')
def attach(sid, url):
driver = Remote(command_executor=url, desired_capabilities={})
driver.session_id = sid
driver.find_element_by_xpath("//input[contains(@value, 'Lucky')]").click()
class AddProductTest(unittest.TestCase):
LOGIN = os.environ['ADMIN_LOGIN']
PASSWORD = os.environ['ADMIN_PASSWORD']
ADDRESS = 'Россия, Москва, 2-я Бауманская улица, 5с1'
LONGITUDE = 55.765985
LATITUDE = 37.68456
TITLE = "Test product"
TITLE_MAX_SIZE = 80
TITLE_MIN_SIZE = 4
UNVALID_SHORT_TITLE = ''.join(['a' for i in range(TITLE_MIN_SIZE - 1)])
UNVALID_LONG_TITLE = ''.join(['a' for i in range(TITLE_MAX_SIZE + 1)])
PRICE = 100
UNVALID_PRICE_NEGATIVE = -10
UNVALID_PRICE_MAX = 10001
UNVALID_PRICE_STRING = '{}string'.format(PRICE)
PHOTO = 'data/test_rest_photo.jpg'
NON_PHOTO = 'data/test_non_photo_file'
BIG_PHOTO = 'data/test_big_photo.jpg'
URL_FORM = 'http://skydelivery.site/admin/restaurants/{}/add/product'
URL_RESTAURANT = 'http://skydelivery.site/restaurants/{}'
PRODUCT_LIST = '//div[@class="restaurant-view__product-list"]'
PRODUCT_CARD = '//div[@class="product-card__container"]'
PRODUCT_CARD_TITLE = '//span[@class="product-card__name"]'
PRODUCT_CARD_PRICE = '//span[@class="product-card__description"]'
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
AddressPage(self.driver).open()
storage = LocalStorage(self.driver)
storage.set('deliveryGeo', self.ADDRESS)
storage.set('longitude', self.LONGITUDE)
storage.set('latitude', self.LATITUDE)
self.driver.refresh()
self.driver.maximize_window()
main_page = MainPage(self.driver)
main_page.wait_visible()
main_page.auth(self.LOGIN, self.PASSWORD)
self.filler = DatabaseFiller()
self.filler.admin_auth()
self.filler.create_test_restaurants(1)
self.rest_id = self.filler.get_restaurant_id_by_name(
self.filler.TEST_REST_NAME.format(0))
self.rest_list_page = AdminRestaurantsPage(self.driver)
self.rest_list_page.open()
self.rest_list_page.wait_visible()
def tearDown(self):
self.filler.delete_all_rests()
self.driver.quit()
def testUnvlaidTitle(self):
url_form = self.URL_FORM.format(self.rest_id)
self.rest_list_page.add_product(self.rest_id, '', self.PRICE,
self.PHOTO)
form = self.rest_list_page.add_product_form
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.title_error(), 'Обязательное поле')
form.set_title(self.UNVALID_SHORT_TITLE)
form.submit()
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.title_error(), 'Минимальная длина: 4')
form.clear_title()
form.set_title(self.UNVALID_LONG_TITLE)
self.assertNotEqual(form.title_value(), self.UNVALID_LONG_TITLE)
def testUnvalidPrice(self):
url_form = self.URL_FORM.format(self.rest_id)
self.rest_list_page.add_product(self.rest_id, self.TITLE, '',
self.PHOTO)
form = self.rest_list_page.add_product_form
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.price_error(), 'Обязательное поле')
form.set_price(self.UNVALID_PRICE_NEGATIVE)
form.submit()
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.price_error(), 'Минимальное значение: 0.1')
form.clear_price()
form.set_price(self.UNVALID_PRICE_MAX)
form.submit()
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.price_error(), 'Максимальное значение: 10000')
form.clear_price()
form.set_price(self.UNVALID_PRICE_STRING)
self.assertEqual(form.price_value(), '')
def testUnvalidBigPhoto(self):
url_form = self.URL_FORM.format(self.rest_id)
self.rest_list_page.add_product(self.rest_id, self.TITLE, self.PRICE,
self.BIG_PHOTO)
form = self.rest_list_page.add_product_form
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.photo_error(), 'Максимальный размер файла - 1МБ')
def testUnvalidPhotoFormat(self):
url_form = self.URL_FORM.format(self.rest_id)
self.rest_list_page.add_product(self.rest_id, self.TITLE, self.PRICE,
self.NON_PHOTO)
form = self.rest_list_page.add_product_form
self.assertEqual(self.driver.current_url, url_form)
self.assertEqual(form.photo_error(),
'Выберите изображение (.png, .jpg)')
def testAddProduct(self):
self.rest_list_page.add_product(self.rest_id, self.TITLE, self.PRICE,
self.PHOTO)
WebDriverWait(self.driver, 5, 0.1).until(
lambda d: d.current_url == self.URL_RESTAURANT.format(self.rest_id)
and d.find_element_by_xpath(self.PRODUCT_LIST).is_displayed(
) and d.find_element_by_xpath(self.PRODUCT_CARD).is_displayed())
card = self.driver.find_element_by_xpath(self.PRODUCT_CARD)
self.assertEqual(
card.find_element_by_xpath(self.PRODUCT_CARD_TITLE).text,
self.TITLE)
self.assertEqual(
card.find_element_by_xpath(self.PRODUCT_CARD_PRICE).text,
'{}₽'.format(self.PRICE))
def _get_element_by_xpath(self, xpath: str, browser: webdriver.Remote):
return browser.find_element_by_xpath(xpath)
class BasePage(object):
def __init__(self, project_name):
self.driver = ''
self.loc = ''
self.project_name = project_name
yamlPath = "user.yaml"
yaml.load(yamlPath, Loader=yaml.BaseLoader)
yaml.warnings({'YAMLLoadWarning': False})
f = open(yamlPath, 'r')
temp = yaml.load(f.read())
self.url = temp[project_name]['url']
self.username = temp[project_name]['username']
self.password = temp[project_name]['password']
def open(self,
browser="chrome",
host='http://localhost:8081/wd/hub'
): # 初始化 打开浏览器 并最大化 self 与java中的this中一样，调用时不用传入self参数
try:
self.driver = Remote(command_executor=host,
desired_capabilities={
'platform': 'ANY',
'browserName': browser,
'version': '',
'javascriptEnabled': True
})
self.driver.maximize_window()
except Exception as e:
print(e)
logger_cls.info(u"打开{0}浏览器".format(browser))
logger_cls.info(u"最大化")
def get(self):
try:
self.driver.get(self.url)
self.driver.implicitly_wait(10) # 隐性等待，最长等10秒
logger_cls.info(u'打开:{0}'.format(self.url))
except BaseException:
logger_cls.error(u'打开{0}失败'.format(self.url))
self.loc = loc.Analyze(self.project_name) #初始化，读取xml 赋值给loc
def find(self, name): #元素定位，并返回定位好的元素
try:
el = WebDriverWait(self.driver, 3,
0.5).until( #设置显示等待时间，每0.5秒检查一次，如果超出指定值就报错
EC.presence_of_element_located(
(self.loc[name].type,
self.loc[name].UIIdentifier)))
logger_cls.info(u'定位元素:{0}'.format(name))
# logger_cls.info(loc[name].value)
except BaseException:
logger_cls.error(u'定位元素:{0}失败'.format(name))
return el
def send_keys(self, name, text):
try:
self.find(name).send_keys(text)
logger_cls.info(u'在:{0}输入{1}'.format(name, text))
time.sleep(3)
except BaseException:
logger_cls.error(u'在：{0}输入{1}失败'.format(name, text))
def click(self, name):
try:
self.find(name).click()
logger_cls.info(u'点击:{0}'.format(name))
time.sleep(3)
except BaseException:
logger_cls.error(u'点击:{0}失败'.format(name))
def being(self, name):
t = False
try:
self.driver.find_element_by_xpath(self.loc[name].UIIdentifier)
t = True
logger_cls.info(u'{0}元素存在'.format(name))
except BaseException:
logger_cls.info(u'{0}元素不存在'.format(name))
return t
def login(self):
self.get()
self.send_keys(u'用户名', self.username)
self.send_keys(u'密码', self.password)
self.click(u'登录')
time.sleep(3)
if self.being(u'不再提示'):
self.click(u'不再提示')
# self.get_version()
def clearmonitor(self):
names = [u'博主', u'博主圈']
self.click(u'事件')
if self.being(u'是否有事件'):
self.focus(u'找回')
self.click(u'多选')
self.click(u'全选')
self.click(u'删除')
for name in names:
self.click(name)
if self.being(u'是否有博主'):
self.focus(u'找回')
self.click(u'多选')
self.click(u'全选')
self.click(u'删除')
def randomclick(self, name, div=None):
text = ''
i = len(self.driver.find_elements_by_xpath(
self.loc[name].UIIdentifier))
logger_cls.info(u'{0}列表中有{1}个参数'.format(name, i))
y = random.randint(1, i)
if div == None:
path = self.loc[name].UIIdentifier + '[' + str(y) + ']'
text = self.driver.find_element_by_xpath(path).text
self.driver.find_element_by_xpath(path).click()
logger_cls.info(u'随机选择列表中的{0}第个参数并点击'.format(y))
else:
i2 = len(
self.driver.find_elements_by_xpath(
self.loc[name].UIIdentifier + '[' + str(y) + ']'))
y2 = random.randint(1, i2)
path = self.loc[name].UIIdentifier + '[' + str(y2) + ']' + div
text = self.driver.find_element_by_xpath(path).text
self.driver.find_element_by_xpath(path).click()
logger_cls.info(u'随机选择列表中的{0}第个参数并点击'.format(y2))
logger_cls.info(u'{0}:文本的值为:{1}'.format(name, text))
time.sleep(3)
return text
def close(self):
logger_cls.info(u'3秒后关闭当前页面')
time.sleep(3)
self.driver.close()
def quit(self):
logger_cls.info(u'3秒后关闭浏览器')
time.sleep(3)
self.driver.quit()
def get_url(self):
url = self.driver.current_url
logger_cls.info(u'当前页面url:' + url)
return url
def get_text(self, name):
text = self.find(name).text
logger_cls.info(u'{0}文本框的值为:{1}'.format(name, text))
return text
def back(self):
self.driver.back()
logger_cls.info(u'返回上一页面')
def clear(self, name):
self.find(name).clear()
logger_cls.info(u'清空文本框:{0}'.format(name))
def get_name(self):
name = self.driver.name
logger_cls.info(u'浏览器名称：{0}'.format(name))
def get_driver(self):
return self.driver
def get_version(self):
version = self.driver.capabilities['version']
logger_cls.info(u'浏览器版本：{0}'.format(version))
return version
def switch_to(self):
self.driver.switch_to.window(self.driver.window_handles[-1])
logger_cls.info(u'切换页面')
def focus(self, name):
ele = self.find(name)
ActionChains(self.driver).move_to_element(ele).perform()
logger_cls.info(u'鼠标悬停到元素:{0}'.format(name))
def refresh(self):
self.driver.refresh()
logger_cls.info(u'刷新页面')
def title(self):
title = self.driver.title
logger_cls.info(u'当前页面标题' + title)
return title
def Slide(self, height):
js = "var q=document.documentElement.scrollTop={0}".format(str(height))
self.driver.execute_script(js)
logger_cls.info(u'上下滑动' + str(height))
def sleep(self, i):
logger_cls.info(u'暂停{0}秒'.format(i))
time.sleep(int(i))
def Screenshot(self, name):
# name='screenshot_'
isExists = os.path.exists("../images\\")
# 判断结果
if not isExists:
# 如果不存在则创建目录
# 创建目录操作函数
os.makedirs("../images\\")
print u'创建images目录'
timestrmap = time.strftime('%Y%m%d_%H%M%S')
imgPath = os.path.join('../images\\', str(timestrmap) + name + '.png')
self.driver.save_screenshot(imgPath)
logger_cls.info(u'截图:{0}{1}.png'.format(str(timestrmap), name))
class Browser:
__AWAIT_TIMEOUT = 60
__browser = None
__browser_kwargs = {}
__config = {}
__refs_num = 0
def get_browser(self):
return self.__browser
def __init__(self, headless=True, config={}, **kwargs):
self.__config = config
self.__config['SELENIUM_HEADLESS'] = headless
self.__browser_kwargs = kwargs
if self.__config.get('SELENIUM_URL'):
self.__create_browser_session()
else:
self.__create_browser_instanse()
def __del__(self):
if self.__browser:
self.__browser.quit()
logging.debug("%s: Quitted browser at __del__()",
self.__config['CELERY_TASK_DEFAULT_QUEUE'])
del self.__browser
def __create_browser_instanse(self):
options = Options()
if self.__config.get('SELENIUM_HEADLESS'):
options.headless = True
if self.__config.get('SELENIUM_BROWSER'):
options.add_experimental_option("debuggerAddress",
self.__config['SELENIUM_BROWSER'])
if self.__config.get('SELENIUM_DRIVER'):
self.__browser_kwargs['executable_path'] = self.__config[
'SELENIUM_DRIVER']
if self.__config.get(
'LOG_LEVEL') and self.__config['LOG_LEVEL'] == logging.DEBUG:
if self.__config.get('SELENIUM_LOG_PATH'):
self.__browser_kwargs['service_log_path'] = self.__config[
'SELENIUM_LOG_PATH']
self.__browser_kwargs['service_args'] = ['--verbose']
if not self.__browser_kwargs.get('executable_path'):
self.__browser_kwargs['executable_path'] = '/usr/bin/chromedriver'
self.__browser = Chrome(options=options, **self.__browser_kwargs)
logging.debug("%s: Created browser instance",
self.__config['CELERY_TASK_DEFAULT_QUEUE'])
def __create_browser_session(self):
options = Options()
if self.__config.get('SELENIUM_HEADLESS'):
options.headless = True
self.__browser = Remote(command_executor=self.__config['SELENIUM_URL'],
options=options)
logging.debug("Connected to remote browser")
def __get_by(self, criterium, value):
ignored_exceptions = (
NoSuchElementException,
StaleElementReferenceException,
)
try:
return WebDriverWait(self.__browser,
self.__AWAIT_TIMEOUT,
ignored_exceptions=ignored_exceptions).until(
EC.presence_of_element_located(
(criterium, value)))
except UnexpectedAlertPresentException as ex:
raise ex
except TimeoutException as ex:
raise NoSuchElementException(
f"No element with {criterium} {value} was found", ex)
def click_by_id(self, element_id):
self.__browser.execute_script(f'$("#{element_id}").click()')
def doubleclick(self, element):
ActionChains(self.__browser).double_click(element).perform()
def execute_script(self, script, *args):
return self.__browser.execute_script(script, *args)
def dismiss_alert(self):
try:
self.__browser.switch_to_alert().dismiss()
except NoAlertPresentException:
pass
def find_element_by_xpath(self, xpath):
return self.__browser.find_element_by_xpath(xpath)
def find_elements_by_xpath(self, xpath):
return self.__browser.find_elements_by_xpath(xpath)
def find_elements_by_css_selector(self, css):
return self.__browser.find_elements_by_css_selector(css)
def get(self, url):
exception = None
for attempt in range(3):
try:
self.__browser.get(url)
exception = None
break
except Exception as ex:
self.quit()
self.__create_browser_instanse()
exception = ex
if exception:
raise exception
def get_alert(self):
try:
alert = self.__browser.switch_to_alert()
text = alert.text
alert.dismiss()
return text
except NoAlertPresentException:
return None
def get_element_by_class(self, class_name):
return self.__get_by(By.CLASS_NAME, class_name)
def get_element_by_css(self, css):
return self.__get_by(By.CSS_SELECTOR, css)
def get_element_by_id(self, id):
return self.__get_by(By.ID, id)
def get_element_by_name(self, name):
return self.__get_by(By.NAME, name)
def switch_to_alert(self):
return self.__browser.switch_to.alert
def wait_for_url(self, url):
try:
WebDriverWait(self.__browser, 20).until(EC.url_to_be(url))
except UnexpectedAlertPresentException as ex:
raise UnexpectedAlertPresentException(ex.alert_text,
f"Didn't get URL {url}")
except Exception as ex:
raise Exception(f"Didn't get URL {url}", ex)
def close(self):
self.__browser.get('about:blank')
def quit(self):
if self.__browser:
self.__browser.quit()
logging.debug("%s: Quitted browser at quit()",
self.__config['CELERY_TASK_DEFAULT_QUEUE'])
del self.__browser
@property
def title(self):
return self.__browser.title
class ExampleTest(unittest.TestCase):
LOGIN = '******'
PASSWORD = os.environ['PASSWORD']
TEXT = 'lalalallalalalalaa'
TEXT2 = ''
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
def tearDown(self):
self.driver.quit()
def test_create_new_post(self):
main_page = MainPage(self.driver)
main_page.open()
auth_form = main_page.form
auth_form = AuthForm(self.driver)
auth_form.set_login(self.LOGIN)
auth_form.set_password(self.PASSWORD)
auth_form.submit()
post_page = PostPage(self.driver)
post_page.open()
topic_text = post_page.create_post
topic_text.add_text(self.TEXT)
topic_text.submit()
def test_create_empty_topic(self):
main_page = MainPage(self.driver)
main_page.open()
auth_form = main_page.form
auth_form = AuthForm(self.driver)
auth_form.set_login(self.LOGIN)
auth_form.set_password(self.PASSWORD)
auth_form.submit()
post_page = PostPage(self.driver)
post_page.open()
flag = True
try:
self.driver.find_element_by_xpath(Create_Topic.SUBMIT)
except NoSuchElementException:
flag = False
self.assertEquals(flag, False)
def test_repost_topic(self):
main_page = MainPage(self.driver)
main_page.open()
auth_form = main_page.form
auth_form = AuthForm(self.driver)
auth_form.set_login(self.LOGIN)
auth_form.set_password(self.PASSWORD)
auth_form.submit()
feed_page = FeedPage(self.driver)
feed_page.open()
feed_page.repost_click()
feed_page.repost_submit()
self.driver.refresh()
def Unicode():
val = random.randint(0x4e00, 0x9fbf)
return chr(val)
dr.get("https://mail.qq.com")
sleep(2)
#进入frame框架内部
dr.switch_to.frame(0)
#通过a链接去定位登录
dr.find_element_by_link_text("帐号密码登录").click()
sleep(1)
#通过xpath用ID去定位用户名框
dr.find_element_by_xpath("//*[@id='u']").send_keys("*****@*****.**")
sleep(1)
#通过xpath用ID去定位密码
dr.find_element_by_xpath("//*[@id='p']").send_keys("liuhe.1015")
sleep(1)
#通过xpath用class去定位登录按钮
dr.find_element_by_xpath("//*[@id='login_button']").click()
sleep(3)
while True:
s = ''
while True:
g = Unicode()
s = s + g
if len(s) == 8:
break
class AdminSeleniumWebDriverTestCase(LiveServerTestCase):
available_apps = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.sites",
]
def _get_remote_capabilities(self, specs):
platforms = {
"s": "Windows 2008",
"x": "Windows 2003",
"e": "Windows 2012",
"l": "Linux",
"m": "Mac 10.6",
"i": "Mac 10.8",
}
browsers = {
"ff": "firefox",
"op": "opera",
"ie": "internet explorer",
"sa": "safari",
"ip": "ipad",
"ih": "iphone",
"an": "android",
"gc": "chrome",
}
browser = browsers[specs[:2]]
if specs[-1] in platforms:
platform = platforms.get(specs[-1])
version = specs[2:-1]
else:
platform = None
version = specs[2:]
caps = {"browserName": browser, "version": version, "platform": platform, "public": "public"}
if "BUILD_NUMBER" in os.environ:
caps["build"] = os.environ["BUILD_NUMBER"]
elif "TRAVIS_BUILD_NUMBER" in os.environ:
caps["build"] = os.environ["TRAVIS_BUILD_NUMBER"]
return caps
def _get_local_webdriver_class(self, specs):
browsers = {
"ff": "selenium.webdriver.Firefox",
"op": "selenium.webdriver.Opera",
"ie": "selenium.webdriver.Ie",
"gc": "selenium.webdriver.Chrome",
}
return import_by_path(browsers[specs[:2]])
def setUp(self):
test_method = getattr(self, self._testMethodName)
if not hasattr(test_method, "spec"):
raise SkipTest("Please make sure your test class is decorated with @browserize")
elif not test_method.spec:
raise SkipTest("Selenium tests not requested")
try:
selenium_specs = test_method.spec
if os.environ.get("DJANGO_SELENIUM_REMOTE", False):
webdriver_class = import_by_path("selenium.webdriver.Remote")
else:
webdriver_class = self._get_local_webdriver_class(selenium_specs)
except Exception as e:
raise SkipTest(
'Selenium specifications "%s" not valid or '
"corresponding WebDriver not installed: %s" % (selenium_specs, str(e))
)
from selenium.webdriver import Remote
if webdriver_class is Remote:
if not (os.environ.get("REMOTE_USER") and os.environ.get("REMOTE_KEY")):
raise self.failureException(
"Both REMOTE_USER and REMOTE_KEY environment variables are required for remote tests."
)
capabilities = self._get_remote_capabilities(selenium_specs)
capabilities["name"] = self.id()
auth = "%(REMOTE_USER)s:%(REMOTE_KEY)s" % os.environ
hub = os.environ.get("REMOTE_HUB", "ondemand.saucelabs.com:80")
self.selenium = Remote(
command_executor="http://%s@%s/wd/hub" % (auth, hub), desired_capabilities=capabilities
)
else:
self.selenium = webdriver_class()
super(AdminSeleniumWebDriverTestCase, self).setUp()
def tearDown(self):
if hasattr(self, "selenium"):
from selenium.webdriver import Remote
if isinstance(self.selenium, Remote):
self._report_sauce_pass_fail()
self.selenium.quit()
super(AdminSeleniumWebDriverTestCase, self).tearDown()
def _report_sauce_pass_fail(self):
# Sauce Labs has no way of knowing if the test passed or failed, so we
# let it know.
base64string = base64.encodestring("%s:%s" % (os.environ.get("REMOTE_USER"), os.environ.get("REMOTE_KEY")))[:-1]
result = json.dumps({"passed": sys.exc_info() == (None, None, None)})
url = "/rest/v1/%s/jobs/%s" % (os.environ.get("REMOTE_USER"), self.selenium.session_id)
connection = httplib.HTTPConnection("saucelabs.com")
connection.request("PUT", url, result, headers={"Authorization": "Basic %s" % base64string})
result = connection.getresponse()
return result.status == 200
def wait_until(self, callback, timeout=10):
"""
Helper function that blocks the execution of the tests until the
specified callback returns a value that is not falsy. This function can
be called, for example, after clicking a link or submitting a form.
See the other public methods that call this function for more details.
"""
from selenium.webdriver.support.wait import WebDriverWait
WebDriverWait(self.selenium, timeout).until(callback)
def wait_loaded_tag(self, tag_name, timeout=10):
"""
Helper function that blocks until the element with the given tag name
is found on the page.
"""
self.wait_until(lambda driver: driver.find_element_by_tag_name(tag_name), timeout)
def wait_page_loaded(self):
"""
Block until page has started to load.
"""
from selenium.common.exceptions import TimeoutException
try:
# Wait for the next page to be loaded
self.wait_loaded_tag("body")
except TimeoutException:
# IE7 occasionnally returns an error "Internet Explorer cannot
# display the webpage" and doesn't load the next page. We just
# ignore it.
pass
def admin_login(self, username, password, login_url="/admin/"):
"""
Helper function to log into the admin.
"""
self.selenium.get("%s%s" % (self.live_server_url, login_url))
username_input = self.selenium.find_element_by_name("username")
username_input.send_keys(username)
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys(password)
login_text = _("Log in")
self.selenium.find_element_by_xpath('//input[@value="%s"]' % login_text).click()
self.wait_page_loaded()
def get_css_value(self, selector, attribute):
"""
Helper function that returns the value for the CSS attribute of an
DOM element specified by the given selector. Uses the jQuery that ships
with Django.
"""
return self.selenium.execute_script('return django.jQuery("%s").css("%s")' % (selector, attribute))
def get_select_option(self, selector, value):
"""
Returns the <OPTION> with the value `value` inside the <SELECT> widget
identified by the CSS selector `selector`.
"""
from selenium.common.exceptions import NoSuchElementException
options = self.selenium.find_elements_by_css_selector("%s > option" % selector)
for option in options:
if option.get_attribute("value") == value:
return option
raise NoSuchElementException('Option "%s" not found in "%s"' % (value, selector))
def assertSelectOptions(self, selector, values):
"""
Asserts that the <SELECT> widget identified by `selector` has the
options with the given `values`.
"""
options = self.selenium.find_elements_by_css_selector("%s > option" % selector)
actual_values = []
for option in options:
actual_values.append(option.get_attribute("value"))
self.assertEqual(values, actual_values)
def has_css_class(self, selector, klass):
"""
Returns True if the element identified by `selector` has the CSS class
`klass`.
"""
return self.selenium.find_element_by_css_selector(selector).get_attribute("class").find(klass) != -1
