def _send_answer(remote: Remote, link: str, answer_to_send: str) -> None:
def wait_textarea(_remote: Remote):
return _remote.find_element_by_css_selector("textarea.textarea")
def wait_textarea_enabled(_remote: Remote):
return _remote.find_element_by_tag_name("textarea").is_enabled()
def wait_correct(_remote: Remote):
return _remote.find_element_by_class_name("correct")
remote.get(link)
WebDriverWait(remote, 3).until(wait_textarea)
try:
remote.find_element_by_class_name("again-btn").click()
WebDriverWait(remote, 3).until(wait_textarea_enabled)
except NoSuchElementException:
pass
remote.find_element_by_css_selector("textarea.textarea").send_keys(
answer_to_send)
remote.find_element_by_class_name("submit-submission").click()
try:
WebDriverWait(remote, 3).until(wait_correct)
expected = "Correct!"
result = remote.find_element_by_class_name(
"smart-hints__hint").text
assert result == expected, f"{expected} != {result}"
except NoSuchElementException:
assert False, "No smart-hints__hint element on the page after submission"
def __check(self, remote: webdriver.Remote):
first_required = remote.find_element_by_css_selector(
"div.first_block .form-control.first")
second_required = remote.find_element_by_css_selector(
"div.first_block .form-control.second")
third_required = remote.find_element_by_css_selector(
"div.first_block .form-control.third")
required_input = ["Name", "Surname", "*****@*****.**"]
for input_element, test_input in zip(
(first_required, second_required, third_required), required_input):
input_element.send_keys(test_input)
# Отправляем заполненную форму
button = remote.find_element_by_css_selector("button.btn")
button.click()
# Проверяем, что смогли зарегистрироваться
# ждем загрузки страницы
WebDriverWait(remote,
3).until(lambda x: x.find_element_by_tag_name("h1"))
# находим элемент, содержащий текст
welcome_text_elt = remote.find_element_by_tag_name("h1")
# записываем в переменную welcome_text текст из элемента welcome_text_elt
welcome_text = welcome_text_elt.text
expect = "Поздравляем! Вы успешно зарегистировались!"
# с помощью assert проверяем, что ожидаемый текст совпадает с текстом на странице сайта
self.assertEqual(expect, welcome_text,
f"{welcome_text} is not {expect}")
def _load_family_urls(driver: Remote, url: str):
page_url_pattern = url + "?page={}"
result = []
page_number = 1
page_count = 1
while page_number <= page_count:
page_url = page_url_pattern.format(page_number)
driver.get(page_url)
div_element = driver.find_element_by_css_selector(
"div.breadcrumb-collection div.breadcrumb_text")
page_count = int(
re.match(".*Page \d+ of (?P<page_count>\d+)$",
div_element.get_property("innerText"),
re.IGNORECASE).group("page_count"))
a_elements = driver.find_elements_by_css_selector(
"div.product-list div.product-wrap a.product-info__caption")
for a_element in a_elements:
result.append(a_element.get_attribute("href"))
logger.debug("Loaded %d products family URLs from '%s'",
len(a_elements), page_url)
page_number += 1
return result
def logoff(driver: Remote) -> None:
"""
Helper method to logoff a driver.
"""
# Click on user icon
driver.find_element_by_css_selector(
"body > div.header-top-area > div > div > div.col-lg-4.col-md-4.col-sm-12.col-xs-12 > div > ul > li:nth-child(1) > a"
).click()
logoff_selector = "body > div.header-top-area > div > div > div.col-lg-4.col-md-4.col-sm-12.col-xs-12 > div > ul > li.nav-item.dropdown.open > ul > li:nth-child(2) > a"
WebDriverWait(driver, PAGE_LOAD_TIMEOUT).until(
EC.element_to_be_clickable((By.CSS_SELECTOR, logoff_selector)),
"Can't locate logoff button")
# then click on logoff
driver.find_element_by_css_selector(logoff_selector).click()
WebDriverWait(driver, PAGE_LOAD_TIMEOUT).until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, "#content > p:nth-child(3) > a")),
"Can't locate django admin panel 'Log in again' button.")
def login(driver: Remote) -> None:
"""
Helper method to authenticate a driver.
"""
# Manually login into Saskatoon
driver.implicitly_wait(PAGE_LOAD_TIMEOUT)
# TODO: README.md
saskatoon_url = os.getenv('SASKATOON_URL')
saskatoon_email = os.getenv('SASKATOON_ADMIN_EMAIL')
saskatoon_pass = os.getenv('SASKATOON_ADMIN_PASSWORD')
assert saskatoon_email is not None
assert saskatoon_pass is not None
driver.get(saskatoon_url + "/accounts/login/?next=/")
# Wait for the login form to show up
# HTML TAG
WebDriverWait(driver, PAGE_LOAD_TIMEOUT).until(
EC.element_to_be_clickable(
(By.CSS_SELECTOR, "#l-login > form > div.nk-form > button")),
"Can't locate login form")
# Fill username / password
driver.find_element_by_id("id_username").send_keys(saskatoon_email)
driver.find_element_by_id("id_password").send_keys(saskatoon_pass)
# Click on login button
time.sleep(0.25)
driver.find_element_by_css_selector(
"#l-login > form > div.nk-form > button").click()
try:
WebDriverWait(driver, PAGE_LOAD_TIMEOUT).until(
EC.visibility_of_element_located(
(By.CLASS_NAME, "main-menu-area")), "Can't locate main menu")
except Exception as e:
# We are still at the login page
if '/accounts/login/' in driver.current_url:
raise RuntimeError("Login failed") from e
else:
raise
class AudioMessagesTest(unittest.TestCase):
USERS_COUNT = u'3 участника'
def setUp(self):
browser = os.environ.get('BROWSER', 'FIREFOX')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
auth_page = AuthPage(self.driver) # Auth here
auth_page.authorize()
self.message_page = GroupMessagesPage(self.driver)
def tearDown(self):
self.driver.quit()
def test_audiomessage_window_opens(self):
self.message_page.open()
self.message_page.messages_menu.get_button_attach()
self.message_page.messages_menu.get_button_videomessage()
audio_msg_popup = self.message_page.messages_menu.get_videomessage_popup(
)
#проверяем выскочил ли object с флешом
self.assertIsNotNone(audio_msg_popup)
def test_audiomessage_play_and_stop_message(self):
PLAY_STOP_BUTTON = '//div[@class="msg_audio_play"]'
self.message_page.open()
last_audio_msg = self.driver.find_element_by_css_selector(
'.msg_audio:last-child')
play_button = last_audio_msg.find_element_by_xpath(PLAY_STOP_BUTTON)
WebDriverWait(
last_audio_msg, 60,
0.1).until(lambda d: d.find_element_by_xpath(PLAY_STOP_BUTTON))
play_button.click()
# проверяем иконка стоп
self.assertNotEqual(
last_audio_msg.get_attribute("class").rfind("st_play"), -1)
stop_button = last_audio_msg.find_element_by_xpath(PLAY_STOP_BUTTON)
WebDriverWait(
last_audio_msg, 60,
0.1).until(lambda d: d.find_element_by_xpath(PLAY_STOP_BUTTON))
stop_button.click()
# проверяем иконка плей
self.assertNotEqual(
last_audio_msg.get_attribute("class").rfind("st_stop"), -1)
def click(remote: webdriver.Remote, s):
remote.find_element_by_css_selector(s).click()
def send(remote: webdriver.Remote, s, keys):
remote.find_element_by_css_selector(s).send_keys(keys)
def get_text(remote: webdriver.Remote, s):
return remote.find_element_by_css_selector(s).text
def wait_textarea(remote: Remote):
return remote.find_element_by_css_selector("textarea.textarea")
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
