class BasicViewTests(unittest.TestCase):
"""
Just visit all the views and make sure they look okay
"""
def setUp(self):
self.selenium = WebDriver()
self.live_server_url = LIVE_SERVER_URL
# login boilerplate blah
self.selenium.get(self.live_server_url + '/login')
username_input = self.selenium.find_element_by_name("username_or_email")
username_input.send_keys(ADMIN_USERNAME)
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys(ADMIN_PASSWORD)
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
def test_home(self):
self.selenium.get(self.live_server_url + '/')
# two project links are there
self.selenium.find_element_by_link_text('1000 Genomes')
def test_project_home(self):
self.selenium.get(self.live_server_url + '/project/1kg')
def test_family_home(self):
self.selenium.get(self.live_server_url + '/project/1kg/family/HG1')
def tearDown(self):
self.selenium.quit()
class LoginMixin(object):
def wait(self, delay, element):
try:
myElem = WebDriverWait(self.selenium, delay).until(
EC.presence_of_element_located((By.NAME, element)))
except TimeoutException:
print('Loading took too much time!')
return myElem
def setUp(self):
super().setUp()
self.user = User.objects.create_user(
username='******',
password='******'
)
self.user.is_active = True
self.user.save()
self.selenium = WebDriver()
self.selenium.implicitly_wait(10)
self.selenium.get(f'{self.live_server_url}/')
username = self.selenium.find_element_by_name('username')
username.send_keys('usuario')
password = self.selenium.find_element_by_name('password')
password.send_keys('usuario')
self.selenium.find_element_by_name('login').click()
def tearDown(self):
self.selenium.quit()
super().tearDown()
class BaseLiveServerTestCase(LiveServerTestCase):
def setUp(self):
get_or_create_test_admin()
self.browser = WebDriver()
self.do_admin_login('test', 'test')
def tearDown(self):
self.browser.quit()
def do_admin_login(self, username, password):
self.browser.get('%s%s' % (self.live_server_url, '/admin/'))
username_input = self.browser.find_element_by_name("username")
username_input.send_keys(username)
password_input = self.browser.find_element_by_name("password")
password_input.send_keys(password)
self.browser.find_element_by_xpath('//input[@value="Log in"]').click()
def new_window(self, name='other'):
self.browser.execute_script('window.open("/admin/", "'+ name +'")')
self.browser.switch_to_window(self.browser.window_handles[1])
while self.warning_element() is False:
time.sleep(0.1)
self.browser.switch_to_window(self.browser.window_handles[0])
def press_space(self):
a = ActionChains(self.browser)
a.key_down(Keys.SPACE)
a.perform()
def wait_for_pages_loaded(self):
for win in self.browser.window_handles:
while self.warning_element() is False:
time.sleep(0.1)
class TestFirefox(LiveServerTestCase):
"""To test a user story using Firefox"""
def setUp(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(10)
self.selenium.maximize_window()
temp_user_creation()
db_init()
def tearDown(self):
self.selenium.close()
def test_login(self):
"""Test when the user wants to log in"""
self.selenium.get('%s%s' % (self.live_server_url, '/authentication/'))
username_input = self.selenium.find_element_by_name("username")
username_input.send_keys('*****@*****.**')
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys('test2020')
submit = self.selenium.find_element_by_id("submit-button")
submit.send_keys(Keys.RETURN)
def test_search_product_details(self):
"""To test when the user wants to search a prod and its details"""
self.selenium.get('%s%s' % (self.live_server_url, '/'))
query_input = self.selenium.find_element_by_id("query")
query_input.send_keys('nutella')
search = self.selenium.find_element_by_id("search-btn")
search.send_keys(Keys.RETURN)
product = WebDriverWait(self.selenium, 30).until(
EC.element_to_be_clickable((By.XPATH, "//*[@id='details-link']")))
product.click()
def test_save_product(self):
"""To test when the user wants to save a product"""
self.test_login()
query_input = self.selenium.find_element_by_id("query")
query_input.send_keys('nutella')
search = self.selenium.find_element_by_id("search-btn")
search.send_keys(Keys.RETURN)
product = WebDriverWait(self.selenium, 30).until(
EC.element_to_be_clickable((By.ID, "product-title")))
product.click()
substitute = WebDriverWait(self.selenium, 30).until(
EC.element_to_be_clickable((By.XPATH, "//*[@id='save-btn']")))
substitute.click()
def test_logout(self):
self.test_login()
logout = WebDriverWait(self.selenium, 30).until(
EC.element_to_be_clickable((By.XPATH, "//*[@id='logout']")))
logout.click()
def pass_xing_login(driver: WebDriver, xing_login: str,
xing_pass: str) -> bool:
"""
pass login on XING using driver and login/password
:Returns:
* True - login successfull
* False - can't login
"""
url = 'https://loginix.com/'
driver.get(url)
sleep(3)
try:
permission_accept: WebElement = driver.find_element_by_xpath(
'//*[@id="consent-accept-button"]')
permission_accept.click()
except NoSuchElementException:
# no question about privacy
pass
try:
driver.find_element_by_name("username").send_keys(xing_login)
except NoSuchElementException:
print("no element by name: username")
return False
try:
driver.find_element_by_name("password").send_keys(xing_pass)
except NoSuchElementException:
print("no element by name: password")
return False
try:
driver.find_element_by_xpath(
"/html/body/div[1]/div[2]/div/div[2]/section/div/main/div/div/div/div/div/form/div[5]/button/div"
).click()
except NoSuchElementException:
print("no element button login ")
return False
sleep(2)
try:
driver.find_element_by_xpath(
"/html/body/div[1]/div[2]/div/div[2]/section/div/main/div/div/div/div/div[2]/div[2]/button[1]/div/span"
).click()
sleep(2)
except NoSuchElementException:
# no element 'Try two factor authentication' with button Skip
pass
return True
class HomeTestCase(LiveServerTestCase):
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(3)
def test_home(self):
self.browser.get('{0}{1}'.format(self.live_server_url,reverse('index')))
body = self.browser.find_element_by_tag_name('body')
self.assertIn('username', body.text)
user = ModelTestFactory.getUser(password='******')
username_input = self.browser.find_element_by_name("username")
username_input.send_keys(user.username)
password_input = self.browser.find_element_by_name("password")
password_input.send_keys('test')
self.browser.find_element_by_id('loginBtn').click()
class MySeleniumTests(LiveServerTestCase):
def setUp(self):
self.selenium = WebDriver(executable_path='C:/geckodriver.exe')
self.selenium.implicitly_wait(10)
self.user = User.objects.create_user('wafistos4', '*****@*****.**', 'djamel2013')
self.profile = Profile.objects.get_or_create(user=self.user, image='picture/wafi.png')
def tearDown(self):
self.selenium.quit()
def test_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/register/login/'))
self.selenium.find_element_by_id("id_username").send_keys('wafistos4')
self.selenium.find_element_by_id("id_password").send_keys('djamel2013')
self.selenium.find_element_by_id('submitBtn').click()
self.assertEquals(self.selenium.title, 'Home')
def test_search(self):
self.selenium.get('%s%s' % (self.live_server_url, '/store'))
query = self.selenium.find_element_by_name("q")
query.send_keys('Pepsi')
self.selenium.find_element_by_id('submitId').click()
# todo ajouter le test du formulaire
class SeleniumTest(TestCase):
"""Testing google.com"""
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(5)
self.browser.get('http://google.com')
def tearDown(self):
self.browser.close()
def search(self, search_string):
q = self.browser.find_element_by_name('q')
q.send_keys(search_string)
q.submit()
results = self.browser.find_element_by_id('search')
return results.find_elements_by_tag_name('a')
def test_python(self):
for link in self.search('python'):
if 'https://www.python.org/' in (link.get_attribute('href') or ''):
break
else:
self.fail('python.com is not on google results page')
def test_python_in_title(self):
self.search('python django')
assert 'python' in self.browser.title
class BaseStoreTest(StaticLiveServerTestCase):
def by_id(self, id):
return self.selenium.find_element_by_id(id)
def by_css(self, selector):
return self.selenium.find_element_by_css_selector(selector)
def by_name(self, name: str):
return self.selenium.find_element_by_name(name)
def setUp(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(SELENIUM_WAIT_SEC)
create_user(TEST_USER, TEST_PASSWORD, TEST_EMAIL)
def tearDown(self):
delete_user(TEST_USER)
self.selenium.quit()
super().tearDown()
def go_to(self, url_name: str, kwargs: Dict[str, str] = None) -> None:
app_url = reverse(url_name, kwargs=kwargs)
self.selenium.get('%s%s' % (self.live_server_url, app_url))
def go_to_app(self, app_id):
self.go_to('app-detail', {'id': app_id})
def go_to_app_register(self):
self.go_to('app-register')
def go_to_app_upload(self):
self.go_to('app-upload')
def login(self, user: str = TEST_USER, password: str = TEST_PASSWORD):
self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
user_input = self.selenium.find_element_by_name("login")
user_input.send_keys(user)
pass_input = self.selenium.find_element_by_name("password")
pass_input.send_keys(password)
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
def wait_for(self, selector: str, then: Callable[[WebElement],
None]) -> None:
element = WebDriverWait(self.selenium, SELENIUM_WAIT_SEC).until(
EC.visibility_of_element_located((By.CSS_SELECTOR, selector)))
then(element)
class MySeleniumTests(StaticLiveServerTestCase):
def setUp(self):
super(MySeleniumTests, self).setUp()
self.selenium = WebDriver()
self.user = CustomUser.objects.create_user(id=1,
username='******',
password='******',
email='*****@*****.**',
adress='50 rue du test',
city='Test',
postal_code='00000')
self.temp = Temperature.objects.create(
id=1,
temperature=22.01,
date='29.85 2020-07-23 09:24:36.534325+00:00',
idUser=self.user)
self.user.save(), self.temp.save()
def tearDown(self):
self.selenium.quit()
super(MySeleniumTests, self).tearDown()
def test_login(self, username="******", password="******"):
self.selenium.get('%s%s' %
(self.live_server_url, "/authenticate/login/"))
self.selenium.implicitly_wait(1)
self.selenium.find_element_by_id('authenticate').is_displayed()
self.selenium.find_element_by_name("username").send_keys(username)
self.selenium.find_element_by_name("password").send_keys(password)
self.selenium.find_element_by_id("button_login").click()
self.selenium.implicitly_wait(1)
self.selenium.find_element_by_id(
"logout").is_displayed() # check if logout img is displayed
def test_dashboard_view(self, username="******", password="******"):
self.selenium.get('%s%s' %
(self.live_server_url, "/authenticate/login/"))
self.selenium.implicitly_wait(1)
self.selenium.find_element_by_id('authenticate').is_displayed()
self.selenium.find_element_by_name("username").send_keys(username)
self.selenium.find_element_by_name("password").send_keys(password)
self.selenium.find_element_by_id("button_login").click()
self.selenium.implicitly_wait(1)
self.selenium.find_element_by_id("my_temperatures").click()
self.selenium.implicitly_wait(1)
self.selenium.find_element_by_id("myChart")
class TestGroup(unittest.TestCase):
def setUp(self):
self.wd = WebDriver()
self.wd.implicitly_wait(60)
def test_create_group(self):
"""Validation of correct create test group"""
success = True
wd = self.wd
wd.get("http://localhost/addressbook/group.php")
wd.find_element_by_name("user").click()
wd.find_element_by_name("user").clear()
wd.find_element_by_name("user").send_keys("admin")
wd.find_element_by_id("LoginForm").click()
wd.find_element_by_name("pass").click()
wd.find_element_by_name("pass").clear()
wd.find_element_by_name("pass").send_keys("secret")
wd.find_element_by_css_selector("input[type=\"submit\"]").click()
wd.find_element_by_name("new").click()
wd.find_element_by_name("group_name").click()
wd.find_element_by_name("group_name").clear()
wd.find_element_by_name("group_name").send_keys("test")
wd.find_element_by_name("group_header").click()
wd.find_element_by_name("group_header").clear()
wd.find_element_by_name("group_header").send_keys("test")
wd.find_element_by_name("group_footer").click()
wd.find_element_by_name("group_footer").clear()
wd.find_element_by_name("group_footer").send_keys("test")
wd.find_element_by_name("submit").click()
wd.find_element_by_css_selector("div.msgbox").click()
wd.find_element_by_link_text("group page").click()
self.assertTrue(success)
def tearDown(self):
success = True
# We should delete all created test form
self.wd.find_element_by_link_text("groups").click()
self.wd.find_element_by_css_selector("span.group").click()
if not self.wd.find_element_by_name("selected[]").is_selected():
self.wd.find_element_by_name("selected[]").click()
self.wd.find_element_by_xpath("//div[@id='content']/form/input[5]").click()
self.wd.find_element_by_link_text("Logout").click()
self.assertTrue(success)
self.wd.quit()
class RegisterTest(LiveServerTestCase):
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(5)
create_user('john', '*****@*****.**', 'johnpassword')
steps_to_login(self.browser, self.live_server_url, 'john',
'johnpassword')
def tearDown(self):
self.browser.quit()
def test_title(self):
open_page(self.browser, '/register/', self.live_server_url)
self.assertIn('Register Supernova', self.browser.title)
def steps_to_create_user(self, username, email, password):
open_page(self.browser, '/register/', self.live_server_url)
username_input = self.browser.find_element_by_name('username')
username_input.send_keys(username)
email_input = self.browser.find_element_by_name('email')
email_input.send_keys(email)
password_input = self.browser.find_element_by_name('password')
password_input.send_keys(password)
button_register = self.browser.find_element_by_name('submit')
button_register.click()
def test_register_correct(self):
self.steps_to_create_user('teste_django',
'*****@*****.**',
'teste_django')
register_correct_message = self.browser.find_element_by_tag_name(
'strong')
self.assertIn('thank you for registering!',
register_correct_message.text)
def test_register_repeated_user(self):
self.steps_to_create_user('testedjangorepeated',
'*****@*****.**',
'testedjangorepeated')
self.steps_to_create_user('testedjangorepeated',
'*****@*****.**',
'testedjangorepeated')
register_repeated_message = self.browser.find_element_by_tag_name('li')
self.assertIn('User with this Username already exists.',
register_repeated_message.text)
def test_overwrite(self):
driver2 = WebDriver()
self.selenium.get('%s%s' % (self.live_server_url, '/apka/1/'))
self.selenium.implicitly_wait(100)
edit_button1 = self.selenium.find_element_by_id('editButton1')
save_button1 = self.selenium.find_element_by_id('submitButton1')
edit_button1.click()
driver2.get('%s%s' % (self.live_server_url, '/apka/1/'))
driver2.implicitly_wait(100)
edit_button2 = driver2.find_element_by_id('editButton1')
save_button2 = driver2.find_element_by_id('submitButton1')
edit_button2.click()
driver2.implicitly_wait(100)
inputok = driver2.find_element_by_name('ok')
inputok.clear()
inputok.send_keys('0')
inputupr = driver2.find_element_by_name('upr')
inputupr.clear()
inputupr.send_keys('1')
save_button2.click()
alert = driver2.switch_to.alert
self.assertEqual(alert.text, "Zapisano dane")
alert.accept()
obwod = Obwod.objects.get(id=1)
self.assertEqual(obwod.otrzymanych_kart, 0)
self.assertEqual(obwod.uprawnionych, 1)
driver2.quit()
self.selenium.implicitly_wait(100)
inputok = self.selenium.find_element_by_name('ok')
inputok.clear()
inputok.send_keys('42')
inputupr = self.selenium.find_element_by_name('upr')
inputupr.clear()
inputupr.send_keys('1337')
save_button1.click()
alert = self.selenium.switch_to.alert
self.assertEqual(alert.text, u"Dane zmieniły się od ostatniego zapisu. Zapisujesz 1337, a ktoś inny zapisał 1")
alert.accept()
obwod = Obwod.objects.get(id=1)
self.assertEqual(obwod.otrzymanych_kart, 0)
self.assertEqual(obwod.uprawnionych, 1)
def get_config(browser: webdriver.WebDriver):
go_to_page(browser, wbm_cfg.recoverysite_url,
wbm_cfg.iframe_recovery_xpath)
bt_dwnl_conf = browser.find_element_by_name(wbm_cfg.btn_name_downl_conf)
bt_dwnl_conf.click()
time.sleep(2)
pyautogui.typewrite("\n")
logging.info("Config file download is started")
browser.switch_to.default_content()
class Selenium_old_lwt(StaticLiveServerTestCase):
''' it tests with the fixture from "old_lwt' (the non opensource version)'''
fixtures = ['lwt/fixtures/old_lwt.json']
def setUp(self):
self.pwd = '12345'
self.user_1 = User.objects.get(username='******')
self.language_1 = Languages.objects.get(name='Italian')
Settings_currentlang_idFactory(owner=self.user_1,
stvalue=self.language_1.id)
super(Selenium_old_lwt, self).setUpClass()
self.selenium = WebDriver()
self.selenium.get('{}/accounts/login/'.format(self.live_server_url))
self.selenium.implicitly_wait(10)
login = self.selenium.find_element_by_name('login')
login.send_keys(self.user_1.username)
pw = self.selenium.find_element_by_name('password')
pw.send_keys(self.pwd)
self.selenium.find_element_by_class_name('primaryAction').click()
def test_loggout(self):
self.selenium.get(self.live_server_url) # return 'localhost:8000
self.selenium.find_element_by_name('logout').click()
self.selenium.get('{}/accounts/logout/'.format(self.live_server_url))
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
def tearDown(self):
# self.selenium.quit()
super(Selenium_old_lwt, self).tearDown()
def test_go_to_homepage(self):
self.selenium.get(self.live_server_url) # return 'localhost:8000
def test_go_to_text_list(self):
self.selenium.get('{}/text_list/'.format(self.live_server_url))
def test_go_to_text_read(self):
self.selenium.get('{}/text_read/{}'.format(self.live_server_url,
self.text1.id))
class AnonymousUseCaseTests(LiveServerTestCase):
fixtures = ['user']
@classmethod
def setUpClass(self):
self.selenium = WebDriver()
super(AnonymousUseCaseTests, self).setUpClass()
self.timeout = 10
@classmethod
def tearDownClass(self):
super(AnonymousUseCaseTests, self).tearDownClass()
self.selenium.quit()
def test_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
self.assertEquals(self.selenium.title, "Squire Learning Application")
username_input = self.selenium.find_element_by_name("username")
username_input.send_keys('super')
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys('super')
self.selenium.find_element_by_xpath('//input[@value="Login"]').click()
WebDriverWait(self.selenium, self.timeout).until(
lambda driver: driver.find_element_by_tag_name('body'))
self.assertEquals(self.selenium.current_url,
'%s%s' % (self.live_server_url, '/hr/profile/'))
def test_unsuccessful_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
self.assertEquals(self.selenium.title, "Squire Learning Application")
username_input = self.selenium.find_element_by_name("username")
username_input.send_keys('super')
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys('duper')
self.selenium.find_element_by_xpath('//input[@value="Login"]').click()
WebDriverWait(self.selenium, self.timeout).until(
lambda driver: driver.find_element_by_tag_name('body'))
self.assertEquals(self.selenium.current_url,
'%s%s' % (self.live_server_url, '/login/'))
self.assertTrue(
self.selenium.page_source.find("Please try again.") > 0)
def get_backend_log(browser: webdriver.WebDriver):
go_to_page(browser, wbm_cfg.logsite_url, wbm_cfg.iframe_logs_xpath)
dd_view_log = Select(
browser.find_element_by_tag_name(wbm_cfg.btn_dropdown_logview_name))
dd_view_log.select_by_value(wbm_cfg.filename_backend_log)
bt_dwnl_log = browser.find_element_by_name(
wbm_cfg.btn_download_logfile_name)
bt_dwnl_log.click()
time.sleep(2)
pyautogui.typewrite("\n")
browser.switch_to.default_content()
class RegisterTest(LiveServerTestCase):
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(5)
create_user('john','*****@*****.**','johnpassword')
steps_to_login(self.browser,self.live_server_url,'john','johnpassword')
def tearDown(self):
self.browser.quit()
def test_title(self):
open_page(self.browser, '/register/', self.live_server_url)
self.assertIn('Register Supernova', self.browser.title)
def steps_to_create_user(self,username,email,password):
open_page(self.browser, '/register/', self.live_server_url)
username_input = self.browser.find_element_by_name('username')
username_input.send_keys(username)
email_input = self.browser.find_element_by_name('email')
email_input.send_keys(email)
password_input = self.browser.find_element_by_name('password')
password_input.send_keys(password)
button_register = self.browser.find_element_by_name('submit')
button_register.click()
def test_register_correct(self):
self.steps_to_create_user('teste_django','*****@*****.**','teste_django')
register_correct_message = self.browser.find_element_by_tag_name('strong')
self.assertIn('thank you for registering!', register_correct_message.text)
def test_register_repeated_user(self):
self.steps_to_create_user('testedjangorepeated','*****@*****.**','testedjangorepeated')
self.steps_to_create_user('testedjangorepeated','*****@*****.**','testedjangorepeated')
register_repeated_message = self.browser.find_element_by_tag_name('li')
self.assertIn('User with this Username already exists.', register_repeated_message.text)
def get_middleware_log(browser: webdriver.WebDriver):
go_to_page(browser, wbm_cfg.logsite_url, wbm_cfg.iframe_logs_xpath)
dd_view_log = Select(
browser.find_element_by_tag_name(wbm_cfg.btn_dropdown_logview_name))
try:
dd_view_log.select_by_value(wbm_cfg.filename_middleware_log)
logging.info("Selected middleware log file")
except NoSuchElementException:
logging.error(str(dd_view_log) + " - No such dropdown element found")
bt_dwnl_log = browser.find_element_by_name(
wbm_cfg.btn_download_logfile_name)
bt_dwnl_log.click()
time.sleep(2)
pyautogui.press("down")
pyautogui.typewrite("\n")
browser.switch_to.default_content()
class UITestCase(LiveServerTestCase):
def use_xvfb(self):
from pyvirtualdisplay import Display
self.display = Display('xvfb',
visible=1,
size=(1280, 1024))
self.display.start()
self.driver = WebDriver()
def setUp(self):
try:
self.driver = WebDriver()
ui_is_not_available = False
except WebDriverException:
ui_is_not_available = True
if ui_is_not_available:
self.use_xvfb()
self.driver.implicitly_wait(10)
super(UITestCase, self).setUp()
def tearDown(self):
self.driver.quit()
if hasattr(self, 'display'):
self.display.stop()
super(UITestCase, self).tearDown()
def _process_login_form(self, username, password):
username_elmt = self.driver.find_element_by_name('username')
password_elmt = self.driver.find_element_by_name('password')
username_elmt.send_keys(username)
password_elmt.send_keys(password)
submit = self.driver.find_element_by_css_selector('form * button')
submit.click()
def _browse_to_url(self, url):
self.driver.get(self.live_server_url + url)
def find_anchor_by_url(self, url):
return self.driver.find_element_by_css_selector("[href='%s']" % url)
def get_balance(browser: WebDriver, url: str, card_number: str) -> str:
input_field_id = 'ean'
balance_field_class = 'history_header_amount'
browser.get(url)
time.sleep(0.5)
# num_form = WebDriverWait(browser, 5).until(
# expected_conditions.presence_of_element_located(
# (By.ID, input_field_id)
# )
# )
num_form = browser.find_element_by_name(input_field_id)
num_form.send_keys(card_number)
num_form.submit()
try:
balance_field = WebDriverWait(browser, 5).until(
expected_conditions.presence_of_element_located(
(By.CLASS_NAME, balance_field_class)))
balance = balance_field.text
except TimeoutException:
error = browser.find_element_by_class_name(
'form-messages_message__error')
errors = [
'Проверьте корректность введенных данных',
'Введите корректный номер штрих-кода карты',
]
if error.text in errors:
balance = 'Карта не найдена'
else:
balance = error.text
finally:
browser.close()
return balance
class MySeleniumTests(LiveServerTestCase):
def setUp(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(10)
self.user = User.objects.create_user('wafistos4', '*****@*****.**', 'djamel2013')
self.profile = Profile.objects.get_or_create(user=self.user)
def tearDown(self):
self.selenium.quit()
def test_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/register/login/'))
self.selenium.find_element_by_id("id_username").send_keys('wafistos4')
self.selenium.find_element_by_id("id_password").send_keys('djamel2013')
self.selenium.find_element_by_id('submitBtn').click()
self.assertEquals(self.selenium.title, 'Pure Beurre')
def test_search(self):
self.selenium.get('%s%s' % (self.live_server_url, '/store'))
query = self.selenium.find_element_by_name("q")
query.send_keys('Pepsi')
add_url = self.live_server_url + reverse('login')
self.selenium.find_element_by_id('submitId').click()
self.selenium.find_element_by_id("id_username").send_keys('wafistos4')
self.selenium.find_element_by_id("id_password").send_keys('djamel2013')
self.selenium.find_element_by_id('submitBtn').click()
time.sleep(100)
self.assertEquals(self.live_server_url, add_url)
class SeleniumTestCase(StaticLiveServerTestCase):
def create_flights(self):
c1 = Crew.objects.create(captain_name="Anna",
captain_surname="Kramarska")
c2 = Crew.objects.create(captain_name="Bartosz",
captain_surname="Wojno")
c3 = Crew.objects.create(captain_name="Ola", captain_surname="Grzyb")
a1 = Airport.objects.create(name="Warsaw")
a2 = Airport.objects.create(name="Modlin")
air1 = Airplane.objects.create(licenseChars="ak385833", capacity=100)
air2 = Airplane.objects.create(licenseChars="bw386385", capacity=50)
Flight.objects.create(startingAirport=a1,
landingAirport=a2,
startingTime=datetime.now(),
landingTime=datetime.now() + timedelta(hours=12),
airplane=air1,
crew=c1)
Flight.objects.create(startingAirport=a2,
landingAirport=a1,
startingTime=datetime.now(),
landingTime=datetime.now() + timedelta(hours=6),
airplane=air2,
crew=c2)
def create_users(self):
get_user_model().objects.create_user('temp', '*****@*****.**',
'temporary')
get_user_model().objects.create_user('temp2', '*****@*****.**',
'temporary')
def setUp(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(10)
self.create_users()
self.create_flights()
def tearDown(self):
self.selenium.quit()
def test_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/auth/login/'))
username_input = self.selenium.find_element_by_name("username")
username_input.send_keys('temp')
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys('temporary')
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
self.selenium.find_element_by_class_name("data")
def test_add_passenger(self):
self.test_login()
self.selenium.get('%s%s' % (self.live_server_url, '/flight/1/'))
name_input = self.selenium.find_element_by_id('id_name')
name_input.send_keys("Anna")
surname_input = self.selenium.find_element_by_id('id_surname')
surname_input.send_keys("Kramarska")
tickets_input = self.selenium.find_element_by_name('nrOfTickets')
tickets_input.send_keys(10)
self.selenium.find_element_by_id('buy').click()
def test_assign_crew(self):
self.selenium.get('%s%s' % (self.live_server_url, '/'))
self.selenium.find_element_by_id('crews-link').click()
# login
user_input = self.selenium.find_element_by_id('user')
user_input.send_keys('temp')
pass_input = self.selenium.find_element_by_id('password')
pass_input.send_keys('temporary')
self.selenium.find_element_by_id('log').click()
self.selenium.find_element_by_xpath('//button[text()="Logout"]')
# assigning crew
flight = self.selenium.find_element_by_id('flight')
flight.send_keys(1)
crew = self.selenium.find_element_by_id('crew')
crew.send_keys('1')
self.selenium.find_element_by_id('assign').click()
class BaseStoreTest(StaticLiveServerTestCase):
def by_id(self, id):
return self.selenium.find_element_by_id(id)
def by_css(self, selector: str, multiple: bool = False):
if multiple:
return self.selenium.find_elements_by_css_selector(selector)
else:
return self.selenium.find_element_by_css_selector(selector)
def setUp(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(SELENIUM_WAIT_SEC)
user = create_user(TEST_USER, TEST_PASSWORD, TEST_EMAIL)
user.firstname = 'live'
user.lastname = 'test'
user.save()
def tearDown(self):
try:
delete_user(TEST_USER)
except Exception:
pass
super().tearDown()
self.selenium.quit()
def go_to(self, url_name: str, kwargs: Dict[str, str] = None) -> None:
app_url = reverse(url_name, kwargs=kwargs)
self.selenium.get('%s%s' % (self.live_server_url, app_url))
def go_to_app(self, app_id):
self.go_to('app-detail', {'id': app_id})
def go_to_app_register(self):
self.go_to('app-register')
def go_to_app_upload(self):
self.go_to('app-upload')
def go_to_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
def login(self, user: str = TEST_USER, password: str = TEST_PASSWORD):
self.go_to_login()
user_input = self.selenium.find_element_by_name("login")
user_input.send_keys(user)
pass_input = self.selenium.find_element_by_name("password")
pass_input.send_keys(password)
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
def assert_can_not_login(self):
self.go_to('home')
self.go_to_login()
self.by_id('id_login').clear()
self.by_id('id_login').send_keys('livetest')
self.by_id('id_password').clear()
self.by_id('id_password').send_keys('livetest')
self.by_css('.auth-form button[type="submit"]').click()
error = self.by_css('.auth-form .text-danger')
self.assertTrue(error.is_displayed())
self.assertOnPage('account_login')
def logout(self):
self.findNavigationLink('account_logout').click()
def wait_for(self, selector: str,
then: Callable[[WebElement], None]) -> Any:
element = WebDriverWait(self.selenium, SELENIUM_WAIT_SEC).until(
EC.visibility_of_element_located((By.CSS_SELECTOR, selector)))
return then(element)
def wait_for_url(self, url: str) -> Any:
WebDriverWait(self.selenium, SELENIUM_WAIT_SEC).until(
EC.url_contains(url)
)
def assertOnPage(self, url_name: str,
kwargs: Dict[str, str] = None) -> None:
parsed = urlparse(self.selenium.current_url)
url = reverse(url_name, kwargs=kwargs)
self.assertEqual(url, parsed.path)
def findNavigationLink(self, url_name: str,
kwargs: Dict[str, str] = None):
route = reverse(url_name, kwargs=kwargs)
return self.by_css('#navbar a[href="%s"]' % route)
class VisitorTest(LiveServerTestCase):
"""
Test as a visitor (unregistered user)
"""
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(3)
self.n1 = Node.objects.create(
title='TestNodeOne',
description='The first test node'
)
self.u1 = User.objects.create_user(
username='******', email='*****@*****.**', password='******'
)
self.u2 = User.objects.create_user(
username='******', email='*****@*****.**', password='******'
)
# Create 99 topics
for i in range(1, 100):
setattr(
self,
't%s' % i,
Topic.objects.create(
title='Test Topic %s' % i,
user=self.u1,
content_raw='This is test topic __%s__' % i,
node=self.n1
)
)
def tearDown(self):
self.browser.quit()
def test_index(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
self.assertIn('niji', self.browser.page_source.lower())
def test_topic_page_content(self):
self.browser.get(self.live_server_url+reverse('niji:topic', kwargs={'pk': self.t88.pk}))
self.assertIn('This is test topic <strong>88</strong>', self.browser.page_source)
def test_node_page(self):
self.browser.get(self.live_server_url+reverse('niji:node', kwargs={'pk': self.n1.pk}))
topics = self.browser.find_elements_by_css_selector('ul.topic-list > li')
self.assertEqual(len(topics), 30)
def test_user_login(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
self.assertNotIn("Log out", self.browser.page_source)
login(self.browser, "test1", "111")
self.assertEqual(self.browser.current_url, self.live_server_url+reverse("niji:index"))
self.assertIn("Log out", self.browser.page_source)
def test_usr_reg(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
self.browser.find_element_by_link_text("Reg").click()
self.assertEqual(self.browser.current_url, self.live_server_url+reverse("niji:reg"))
username = self.browser.find_element_by_name('username')
email = self.browser.find_element_by_name('email')
password1 = self.browser.find_element_by_name('password1')
password2 = self.browser.find_element_by_name('password2')
username.send_keys("test3")
password1.send_keys("333")
password2.send_keys("333")
email.send_keys("*****@*****.**")
password1.send_keys(Keys.RETURN)
self.assertEqual(self.browser.current_url, self.live_server_url+reverse("niji:index"))
self.assertIn("Log out", self.browser.page_source)
self.assertIn("test3", self.browser.page_source)
def test_user_topic(self):
self.browser.get(self.live_server_url+reverse("niji:user_topics", kwargs={"pk": self.u1.id}))
self.assertIn("UID:", self.browser.page_source)
def test_user_info(self):
self.browser.get(self.live_server_url+reverse("niji:user_info", kwargs={"pk": self.u1.id}))
self.assertIn("Topics created by %s" % self.u1.username, self.browser.page_source)
def test_search(self):
self.browser.get(self.live_server_url+reverse("niji:search", kwargs={"keyword": "test"}))
self.assertIn("Search: test", self.browser.page_source)
def test_pagination(self):
self.browser.get(self.live_server_url+reverse("niji:index", kwargs={"page": 2}))
self.assertIn("«", self.browser.page_source)
prev = self.browser.find_element_by_link_text("«")
prev.click()
self.assertNotIn("«", self.browser.page_source)
self.assertIn("»", self.browser.page_source)
nxt = self.browser.find_element_by_link_text("»")
nxt.click()
self.assertEqual(self.browser.current_url, self.live_server_url+reverse("niji:index", kwargs={"page": 2}))
class MySeleniumTests(StaticLiveServerTestCase):
def setUp(self):
super(MySeleniumTests, self).setUp()
options = Options()
options.headless = True # option for server without display
self.selenium = WebDriver(options=options)
self.user = User.objects.create_user(username='******',
password='******',
email='*****@*****.**',
is_active=True)
self.category = Category.objects.create(name='boissons')
self.category.save()
self.product = Product.objects.create(id=1,
name='coca',
nutriscore='c',
url='www.coca.com',
image_url='www.linktojpg',
category=self.category)
self.product_alt = Product.objects.create(id=2,
name='eau',
nutriscore='a',
url='www.eau.com',
image_url='www.linktojpg',
category=self.category)
self.user.save(), self.product.save(), self.product_alt.save()
def tearDown(self):
self.selenium.quit()
super(MySeleniumTests, self).tearDown()
def test_login(self, username="******", password="******"):
self.selenium.get('%s%s' % (self.live_server_url, "/accounts/login/"))
self.selenium.find_element_by_id('logo').is_displayed()
self.selenium.find_element_by_name("username").send_keys(username)
self.selenium.find_element_by_name("password").send_keys(password)
self.selenium.find_element_by_id("button_login").click()
self.selenium.implicitly_wait(1)
self.selenium.find_element_by_id("colette").is_displayed()
self.selenium.implicitly_wait(1) # seconds
self.selenium.find_element_by_id(
"logout").is_displayed() # check if logout img is displayed
def test_search(self):
self.selenium.get('%s%s' % (self.live_server_url, "/"))
self.selenium.find_element_by_id('logo').is_displayed()
my_search = self.selenium.find_element_by_name("query")
my_search.send_keys("eau")
my_search.send_keys(Keys.RETURN)
self.selenium.implicitly_wait(1) # seconds
self.selenium.find_element_by_id('product_pick').is_displayed()
def test_redirection_login_to_saved_product(self):
self.selenium.get('%s%s' % (self.live_server_url, "/"))
self.selenium.find_element_by_id('logo').is_displayed()
my_search = self.selenium.find_element_by_name("query")
my_search.send_keys("coca")
my_search.send_keys(Keys.RETURN)
self.selenium.implicitly_wait(1) # seconds
self.selenium.find_element_by_name("button_id_2").click()
def test_search_with_empty_query(self):
self.selenium.get('%s%s' % (self.live_server_url, "/"))
self.selenium.find_element_by_id('logo').is_displayed()
my_search = self.selenium.find_element_by_name("query")
my_search.send_keys("")
my_search.send_keys(Keys.RETURN)
self.selenium.implicitly_wait(1) # seconds
element_to_check = self.selenium.find_element_by_id(
"message_to_display")
message = element_to_check.text
assert "Votre saisie est vide !" in message
def test_search_with_nonsense_query(self):
self.selenium.get('%s%s' % (self.live_server_url, "/"))
self.selenium.find_element_by_id('logo').is_displayed()
my_search = self.selenium.find_element_by_name("query")
my_search.send_keys("blablabla")
my_search.send_keys(Keys.RETURN)
self.selenium.implicitly_wait(1) # seconds
element_to_check = self.selenium.find_element_by_id(
"message_to_display")
message = element_to_check.text
assert "Votre produit n'existe pas dans notre base de donnée !" in message
class ScriptTestCase(LiveServerTestCase):
def setUp(self):
self.browser = WebDriver()
self.do_admin_login('test', 'test')
def tearDown(self):
self.browser.quit()
def do_admin_login(self, username, password):
self.browser.get('%s%s' % (self.live_server_url, '/admin/'))
username_input = self.browser.find_element_by_name("username")
username_input.send_keys(username)
password_input = self.browser.find_element_by_name("password")
password_input.send_keys(password)
self.browser.find_element_by_xpath('//input[@value="Log in"]').click()
def new_window(self, name='other'):
self.browser.execute_script('window.open("/admin/", "'+ name +'")')
self.browser.switch_to_window(self.browser.window_handles[1])
while self.warning_element() is False:
time.sleep(0.1)
self.browser.switch_to_window(self.browser.window_handles[0])
def press_space(self):
a = ActionChains(self.browser)
a.key_down(Keys.SPACE)
a.perform()
def warning_element(self):
try:
return self.browser.find_elements_by_css_selector(
'#session_security_warning')[0]
except IndexError:
return False
def wait_for_pages_loaded(self):
for win in self.browser.window_handles:
while self.warning_element() is False:
time.sleep(0.1)
def deadline_passed(self, now, deadline):
return (datetime.now() - now).seconds > deadline
def assertWarningShows(self, max_seconds):
now = datetime.now()
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
while self.warning_element() is False:
time.sleep(0.1)
if self.deadline_passed(now, max_seconds):
self.fail('Warning did not make it into DOM')
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
while self.warning_element().is_displayed() is False:
time.sleep(0.1)
if self.deadline_passed(now, max_seconds):
self.fail('Warning did not make it into DOM')
def assertWarningHides(self, max_seconds):
now = datetime.now()
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
while self.warning_element().is_displayed() is not False:
time.sleep(0.1)
if self.deadline_passed(now, max_seconds):
self.fail('Warning did not hide')
def assertExpires(self, max_seconds):
now = datetime.now()
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
while self.warning_element() is not False:
time.sleep(0.1)
if self.deadline_passed(now, max_seconds):
self.fail('Warning did not make it out of DOM')
def assertWarningShown(self):
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
self.assertTrue(self.warning_element().is_displayed())
def assertWarningHidden(self):
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
self.assertFalse(self.warning_element().is_displayed())
def assertWarningNotInPage(self):
for win in self.browser.window_handles:
self.browser.switch_to_window(win)
self.assertTrue(self.warning_element() is False)
def test_single_window_inactivity(self):
self.wait_for_pages_loaded()
self.assertWarningHidden()
self.assertWarningShows(9)
self.assertExpires(9)
def test_single_dont_show_warning(self):
self.wait_for_pages_loaded()
self.assertWarningHidden()
time.sleep(3.5)
self.press_space()
self.assertWarningHidden()
time.sleep(4)
self.assertWarningHidden()
def test_single_hide_warning(self):
self.assertWarningShows(9)
self.press_space()
self.assertWarningHides(2)
def test_double_window_inactivity(self):
self.new_window()
self.wait_for_pages_loaded()
self.assertWarningHidden()
self.assertWarningShows(9)
self.assertExpires(9)
def test_double_dont_show_warning(self):
self.new_window()
self.wait_for_pages_loaded()
self.assertWarningHidden()
time.sleep(3.5)
self.press_space()
self.assertWarningHidden()
time.sleep(4)
self.assertWarningHidden()
def test_double_hide_warning(self):
self.new_window()
self.assertWarningShows(9)
self.press_space()
self.assertWarningHides(6)
class WStoreSeleniumTestCase(TestCase, LiveServerTestCase):
fixtures = ['selenium_basic.json']
@classmethod
def setUpClass(cls):
super(WStoreSeleniumTestCase, cls).setUpClass()
def setUp(self):
# Open the page
self.driver = WebDriver()
self.driver.implicitly_wait(5)
self.driver.set_window_size(1024, 768)
self.driver.get(self.live_server_url)
TestCase.setUp(self)
def _check_container(self, container, offering_names):
# Check offerings container
container = self.driver.find_element_by_class_name(container)
offering_elems = container.find_elements_by_class_name('menu-offering')
self.assertEquals(len(offering_elems), len(offering_names))
for off_elem in offering_elems:
title = off_elem.find_element_by_css_selector('h2')
self.assertTrue(title.text in offering_names)
def login(self, username='******'):
# Set username
username_elem = self.driver.find_element_by_name('username')
username_elem.send_keys(username)
# Set password
password_elem = self.driver.find_element_by_name('password')
password_elem.send_keys('admin')
# Click login
self.driver.find_element_by_css_selector('#login-form button').click()
def oauth2_login(self, username='******'):
from wstore.selenium_tests.tests import TESTING_PORT
self.driver.get(self.live_server_url + '/oauth2/auth?response_type=code&client_id=test_app&redirect_uri=http://localhost:' + unicode(TESTING_PORT))
self.login(username)
self.driver.find_element_by_class_name('btn-blue').click()
time.sleep(1)
# Get authorization code
while self._server.call_received() < 1:
pass
code = self._server.get_path().split('=')[1]
# Get access token
opener = urllib2.build_opener()
url = self.live_server_url + '/oauth2/token'
data = 'client_id=test_app'
data += '&client_secret=secret'
data += '&grant_type=authorization_code'
data += '&code=' + code
data += '&redirect_uri=' + 'http://localhost:' + unicode(TESTING_PORT)
headers = {
'content-type': 'application/form-url-encoded',
}
request = MethodRequest('POST', url, data, headers)
response = opener.open(request)
token = json.loads(response.read())['access_token']
return token
def logout(self):
self.driver.find_element_by_class_name('arrow-down-settings').click()
options = self.driver.find_elements_by_css_selector('#settings-menu > li')
options[-1].click()
def tearDown(self):
self.driver.quit()
TestCase.tearDown(self)
def back(self):
self.driver.find_element_by_id('back').click()
def view_all(self):
self.driver.find_element_by_css_selector('#all').click()
def search_keyword(self, keyword, id_='#text-search', btn='#search'):
# Set search field
search_elem = self.driver.find_element_by_css_selector(id_)
search_elem.send_keys(keyword)
# Click search button
self.driver.find_element_by_css_selector(btn).click()
def open_offering_details(self, offering_name):
elements = self.driver.find_elements_by_class_name('menu-offering')
for element in elements:
if element.find_element_by_css_selector('h2').text == offering_name:
element.click()
break
def _get_navs(self):
submenu = self.driver.find_element_by_class_name('store-sub-menu')
# Get first element
return submenu.find_elements_by_css_selector('li')
def click_first_cat(self):
self.driver.find_element_by_id('menu-first-text').click()
def click_second_cat(self):
self.driver.find_element_by_id('menu-second-text').click()
def click_third_cat(self):
self.driver.find_element_by_id('menu-third-text').click()
def click_first_nav(self):
self._get_navs()[0].click()
def click_second_nav(self):
self._get_navs()[1].click()
def _open_provider_option(self, option):
self.driver.find_element_by_css_selector('#provider-options a.btn').click()
self.driver.find_element_by_id(option).click()
def create_offering_menu(self):
self._open_provider_option('create-app')
def fill_basic_offering_info(self, offering_info):
# Name and version
self.driver.find_element_by_css_selector('[name="app-name"]').send_keys(offering_info['name'])
self.driver.find_element_by_css_selector('[name="app-version"]').send_keys(offering_info['version'])
# Select the notification URL option
if not offering_info['notification']:
self.driver.find_element_by_css_selector('input[type="radio"][value="none"]').click()
elif offering_info['notification'] == 'default':
self.driver.find_element_by_css_selector('input[type="radio"][value="default"]').click()
else:
self.driver.find_element_by_css_selector('input[type="radio"][value="new"]').click()
self.driver.find_element_by_id('notify').send_keys(offering_info['notification'])
# Add the logo
logo_path = os.path.join(settings.BASEDIR, 'wstore/ui/fiware/defaulttheme/static/assets/img/noimage.png')
self.driver.find_element_by_id('img-logo').send_keys(logo_path)
# Mark as open if needed
if offering_info['open']:
self.driver.find_element_by_id('open-offering').click()
def _fill_usdl_form(self, usdl_info):
# Fill description field
self.driver.find_element_by_id('description').send_keys(usdl_info['description'])
# Fill pricing info if needed
if 'price' in usdl_info:
self.driver.find_element_by_css_selector('#pricing-select option[value="single_payment"]').click()
self.driver.find_element_by_id('price-input').send_keys(usdl_info['price'])
if 'legal' in usdl_info:
self.driver.find_element_by_id('legal-title').send_keys(usdl_info['legal']['title'])
self.driver.find_element_by_id('legal-text').send_keys(usdl_info['legal']['text'])
def _fill_usdl_upload(self, usdl_info):
pass
def _fill_usdl_url(self, usdl_info):
pass
def fill_usdl_info(self, usdl_info):
# Select the correct method
methods = {
'form': self._fill_usdl_form,
'upload': self._fill_usdl_upload,
'url': self._fill_usdl_url
}
methods[usdl_info['type']](usdl_info)
def register_resource(self, resource_info):
pass
def click_tag(self, tag):
tag_elems = self.driver.find_elements_by_class_name('tag')
for te in tag_elems:
if te.text == tag:
te.click()
break
def fill_tax_address(self, tax):
self.driver.find_element_by_id('street').send_keys(tax['street'])
self.driver.find_element_by_id('postal').send_keys(tax['postal'])
self.driver.find_element_by_id('city').send_keys(tax['city'])
self.driver.find_element_by_id('country').send_keys(tax['country'])
class ProfessorTest(LiveServerTestCase):
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(1)
create_user_and_login(self.browser, self.live_server_url,'john','johnpassword','*****@*****.**')
self.name_professor = 'teste'
def tearDown(self):
[professor.delete() for professor in Professor.find()]
self.browser.quit()
def create_professor(self,professor_name):
open_page(self.browser, '/interface/professor', self.live_server_url)
button_create_professor = self.browser.find_element_by_name('criar')
button_create_professor.click()
self.assertIn('Interface - Professor Create', self.browser.title)
form_name = self.browser.find_element_by_id('id_name')
form_name.send_keys(professor_name)
form_memberId = self.browser.find_element_by_id('id_memberId')
form_memberId.send_keys('00000')
form_office = self.browser.find_element_by_id('id_office')
form_office.send_keys('0')
form_email = self.browser.find_element_by_id('id_email')
form_email.send_keys('0')
form_phoneNumber = self.browser.find_element_by_id('id_phoneNumber')
form_phoneNumber.send_keys('0')
form_cellphoneNumber = self.browser.find_element_by_id('id_cellphoneNumber')
form_cellphoneNumber.send_keys('0')
form_idDepartment = self.browser.find_element_by_id('id_idDepartment')
form_idDepartment.send_keys('')
button_submit = self.browser.find_element_by_name('Cadastrar')
button_submit.click()
def test_login_to_interface_page(self):
self.assertIn('Index', self.browser.title)
link_interface = self.browser.find_element_by_link_text('Interface')
link_interface.click()
self.assertIn('Interface', self.browser.title)
def test_login_to_professor_page(self):
open_page(self.browser, '/interface/', self.live_server_url)
professor_interface = self.browser.find_element_by_link_text('Professor')
professor_interface.click()
self.assertIn('Interface - Professor', self.browser.title)
def test_create_professor(self):
self.create_professor(self.name_professor)
open_page(self.browser, '/interface/professor', self.live_server_url)
professor_name_link = self.browser.find_element_by_link_text(self.name_professor)
self.assertIsNotNone(professor_name_link)
def test_edit_professor(self):
professor = Professor(self.name_professor)
professor.store()
open_page(self.browser, '/interface/professor', self.live_server_url)
professor_name_link = self.browser.find_element_by_link_text(self.name_professor)
professor_name_link.click()
self.assertIn('Interface - Professor Detail', self.browser.title)
button_edit = self.browser.find_element_by_name('editar')
button_edit.click()
self.assertIn('Interface - Professor Edit', self.browser.title)
form_name = self.browser.find_element_by_id('id_name')
form_name.send_keys('Edit')
form_memberId = self.browser.find_element_by_id('id_memberId')
form_memberId.send_keys('')
form_office = self.browser.find_element_by_id('id_office')
form_office.send_keys('')
form_email = self.browser.find_element_by_id('id_email')
form_email.send_keys('')
form_phoneNumber = self.browser.find_element_by_id('id_phoneNumber')
form_phoneNumber.send_keys('0')
form_cellphoneNumber = self.browser.find_element_by_id('id_cellphoneNumber')
form_cellphoneNumber.send_keys('0')
form_idDepartment = self.browser.find_element_by_id('id_idDepartment')
form_idDepartment.send_keys('')
button_apply = self.browser.find_element_by_name('Aplicar')
button_apply.click()
open_page(self.browser, '/interface/professor', self.live_server_url)
professor_name_link_after_edit = self.browser.find_element_by_link_text(self.name_professor + 'Edit')
professor_name_link_after_edit.click()
list_professor_info = self.browser.find_elements_by_tag_name('p')
self.assertEqual(list_professor_info[1].text, 'Member ID: 0')
self.assertEqual(list_professor_info[2].text, 'Office: None')
self.assertEqual(list_professor_info[3].text, 'Email: None')
self.assertEqual(list_professor_info[4].text, 'Phone Number: 0')
self.assertEqual(list_professor_info[5].text, 'CellPhone Number: 0')
self.assertEqual(list_professor_info[6].text, 'Id Department: None')
def test_delete_professor(self):
professor = Professor(self.name_professor)
professor.store()
open_page(self.browser, '/interface/professor', self.live_server_url)
professor_name_link = self.browser.find_element_by_link_text(self.name_professor)
professor_name_link.click()
self.assertIn('Interface - Professor Detail', self.browser.title)
button_delete = self.browser.find_element_by_name('deletar')
button_delete.click()
alert = self.browser.switch_to.alert
alert.accept()
self.assertIn('Interface - Professor', self.browser.title)
professor_name_after_delete = self.browser.find_elements_by_tag_name('a')
names = [link.text for link in professor_name_after_delete]
self.assertNotIn(self.name_professor, names)
class RegisteredUserTest(LiveServerTestCase):
"""
Test as a registered user
"""
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(3)
self.n1 = Node.objects.create(title='TestNodeOne',
description='The first test node')
self.u1 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.u2 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
# Create 198 topics
for i in range(1, 100):
setattr(
self, 't%s' % i,
Topic.objects.create(title='Test Topic %s' % i,
user=self.u1,
content_raw='This is test topic __%s__' %
i,
node=self.n1))
for i in range(100, 199):
setattr(
self, 't%s' % i,
Topic.objects.create(title='Test Topic %s' % i,
user=self.u2,
content_raw='This is test topic __%s__' %
i,
node=self.n1))
def tearDown(self):
self.browser.quit()
def test_edit_own_topic(self):
self.browser.get(self.live_server_url + reverse('index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
own_topic = getattr(self, "t%s" % (random.choice(range(1, 100))))
self.browser.get(self.live_server_url +
reverse("topic", kwargs={"pk": own_topic.id}))
self.browser.find_element_by_link_text("Edit").click()
content_raw = self.browser.find_element_by_name("content_raw")
content_raw.clear()
content_raw.send_keys("This topic is edited")
self.browser.find_element_by_name("submit").click()
self.assertIn("This topic is edited", self.browser.page_source)
def test_edit_others_topic(self):
self.browser.get(self.live_server_url + reverse('index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
others_topic = getattr(self, "t%s" % (random.choice(range(100, 199))))
self.browser.get(self.live_server_url +
reverse("topic", kwargs={"pk": others_topic.id}))
self.assertNotIn("<span class=\"label label-success\">Edit</span>",
self.browser.page_source)
self.browser.get(self.live_server_url +
reverse("edit_topic", kwargs={"pk": others_topic.id}))
self.assertIn("You are not allowed to edit other's topic",
self.browser.page_source)
def test_reply_topic(self):
self.browser.get(self.live_server_url + reverse('index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
topic = getattr(self, "t%s" % (random.choice(range(1, 199))))
self.browser.get(self.live_server_url +
reverse("topic", kwargs={"pk": topic.id}))
content_raw = self.browser.find_element_by_name("content_raw")
content_raw.clear()
content_raw.send_keys("This is a reply")
self.browser.find_element_by_name("submit").click()
self.assertIn("This is a reply", self.browser.page_source)
def test_closed_topic(self):
self.browser.get(self.live_server_url + reverse('index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
topic = getattr(self, "t%s" % (random.choice(range(1, 199))))
topic.closed = True
topic.save()
self.browser.get(self.live_server_url +
reverse("topic", kwargs={"pk": topic.id}))
self.assertIn(_("This topic is closed"), self.browser.page_source)
def test_create_topic(self):
self.browser.get(self.live_server_url + reverse('index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
self.browser.get(self.live_server_url + reverse("create_topic"))
node = self.browser.find_element_by_name("node")
node = Select(node)
title = self.browser.find_element_by_name("title")
content_raw = self.browser.find_element_by_name("content_raw")
node.select_by_visible_text(self.n1.title)
title.send_keys("test title")
content_raw.send_keys("this is content")
self.browser.find_element_by_name("submit").click()
self.assertIn("this is content", self.browser.page_source)
def test_create_appendix(self):
self.browser.get(self.live_server_url + reverse('index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
own_topic = getattr(self, "t%s" % (random.choice(range(1, 100))))
self.browser.get(self.live_server_url +
reverse("topic", kwargs={"pk": own_topic.id}))
self.browser.find_element_by_link_text("Append").click()
content_raw = self.browser.find_element_by_name("content_raw")
content_raw.clear()
content_raw.send_keys("This is an appendix")
self.browser.find_element_by_name("submit").click()
self.assertIn("This is an appendix", self.browser.page_source)
class PollsTest(LiveServerTestCase):
def setUp(self):
user = User()
user.username = "******"
user.email = "*****@*****.**"
user.set_password("adm1n")
user.is_active = True
user.is_superuser = True
user.is_staff = True
user.save()
self.browser = WebDriver()
self.browser.implicitly_wait(3)
def tearDown(self):
self.browser.quit()
def test_can_create_new_poll_via_admin_site(self):
# Gertrude opens her web browser, and goes to the admin page
self.browser.get(self.live_server_url + '/admin/')
# She sees the familiar 'Django administration' heading
body = self.browser.find_element_by_tag_name('body')
self.assertIn('Django administration', \
body.find_element_by_id("header").text)
# She types in her username and passwords and hits return
username_field = self.browser.find_element_by_name('username')
username_field.send_keys('admin')
password_field = self.browser.find_element_by_name('password')
password_field.send_keys('adm1n')
password_field.send_keys(Keys.RETURN)
# her username and password are accepted, and she is taken to
# the Site Administration page
body = self.browser.find_element_by_tag_name('body')
self.assertIn('Site administration', body.text)
# She now sees a couple of hyperlink that says "Polls"
polls_links = self.browser.find_elements_by_link_text('Polls')
self.assertEquals(len(polls_links), 2)
# The second one looks more exciting, so she clicks it
polls_links[1].click()
# She is taken to the polls listing page, which shows she has
# no polls yet
body = self.browser.find_element_by_tag_name('body')
self.assertIn('0 polls', body.text)
# She sees a link to 'add' a new poll, so she clicks it
new_poll_link = self.browser.find_element_by_link_text('Add poll')
new_poll_link.click()
# She sees some input fields for "Question" and "Date published"
body = self.browser.find_element_by_tag_name('body')
self.assertIn('Question:', body.text)
self.assertIn('Date published:', body.text)
# She types in an interesting question for the Poll
question_field = self.browser.find_element_by_name('question')
question_field.send_keys("How awesome is Test-Driven Development?")
# She sets the date and time of publication - it'll be a new year's
# poll!
date_field = self.browser.find_element_by_name('pub_date_0')
date_field.send_keys('01/01/12')
time_field = self.browser.find_element_by_name('pub_date_1')
time_field.send_keys('00:00')
# Gertrude clicks the save button
save_button = self.browser.find_element_by_css_selector("input[value='Save']")
save_button.click()
# She is returned to the "Polls" listing, where she can see her
# new poll, listed as a clickable link
new_poll_links = self.browser.find_elements_by_link_text(
"How awesome is Test-Driven Development?"
)
self.assertEquals(len(new_poll_links), 1)
success = True
wd = WebDriver()
wd.implicitly_wait(60)
def is_alert_present(wd):
try:
wd.switch_to_alert().text
return True
except:
return False
try:
wd.get("http://localhost/addressbook/group.php")
wd.find_element_by_name("pass").click()
wd.find_element_by_name("pass").send_keys("\\undefined")
wd.find_element_by_xpath("//form[@id='LoginForm']/input[3]").click()
wd.find_element_by_name("new").click()
wd.find_element_by_name("group_name").click()
wd.find_element_by_name("group_name").clear()
wd.find_element_by_name("group_name").send_keys("rytyrtytry")
wd.find_element_by_name("group_header").click()
wd.find_element_by_name("group_header").send_keys("\\89")
wd.find_element_by_name("group_header").click()
wd.find_element_by_name("group_header").clear()
wd.find_element_by_name("group_header").send_keys("trytryrty")
wd.find_element_by_name("group_footer").click()
wd.find_element_by_name("group_footer").clear()
wd.find_element_by_name("group_footer").send_keys()
wd.find_element_by_name("group_footer").click()
class UITestCase(LiveServerTestCase):
def use_xvfb(self):
from pyvirtualdisplay import Display
self.display = Display('xvfb',
visible=1,
size=(1280, 1024))
self.display.start()
self.driver = WebDriver()
def setUp(self):
try:
self.driver = WebDriver()
ui_is_not_available = False
except WebDriverException:
ui_is_not_available = True
if ui_is_not_available:
self.use_xvfb()
self.driver.implicitly_wait(10)
super(UITestCase, self).setUp()
def tearDown(self):
self.driver.quit()
if hasattr(self, 'display'):
self.display.stop()
# I believe this line is no longer necessary, but I'm leaving it here
# until the UI tests have run many times without deadlocking.
# -RM 20140522
#self.kill_pending_transactions()
super(UITestCase, self).tearDown()
def kill_pending_transactions(self):
# The super.tearDown sometimes hangs when truncating tables
# because of lingering pending transactions with locks on those tables.
# Kill them to avoid deadlock!
try:
dbname = settings.DATABASES['default']['NAME']
sql = "select pg_terminate_backend(procpid)" + \
" from pg_stat_activity where datname='%s'" % dbname + \
" and current_query='<IDLE> in transaction';"
connection.cursor().execute(sql)
except InterfaceError:
# Sometimes we get "connection already closed"
pass
def click(self, selector):
self.find(selector).click()
def click_when_visible(self, selector):
element = self.find(selector)
self.wait_until_visible(element)
element.click()
def find(self, selector):
return self.driver.find_element_by_css_selector(selector)
def find_name(self, name):
return self.driver.find_element_by_name(name)
def find_id(self, id):
return self.driver.find_element_by_id(id)
def process_login_form(self, username, password):
username_elmt = self.wait_until_present('[name="username"]')
password_elmt = self.find_name('password')
username_elmt.send_keys(username)
password_elmt.send_keys(password)
self.click('form * button')
def browse_to_url(self, url):
self.driver.get(self.live_server_url + url)
def find_anchor_by_url(self, url):
return self.find("[href='%s']" % url)
def wait_until_present(self, selector, timeout=10):
"""
Wait until an element with CSS 'selector' exists on the page.
Useful for detecting that an operation loads the page you're expecting.
"""
element = [None] # use list so it can be set by inner scope
def is_present(driver):
element[0] = self.find(selector)
return element[0] is not None
WebDriverWait(self.driver, timeout).until(is_present)
return element[0]
def wait_until_text_present(self, text, timeout=10):
"""
Wait until 'text' exists on the page.
Useful for detecting that an operation loads the page you're expecting.
"""
WebDriverWait(self.driver, timeout).until(
lambda driver: text in driver.page_source)
def wait_until_enabled(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' is enabled.
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver, timeout).until(
lambda driver: element.get_attribute("disabled") is None)
return element
def wait_until_visible(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' (known to already exist on the page)
is displayed.
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver, timeout).until(
lambda driver: element.is_displayed())
return element
def wait_until_invisible(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' (known to already exist on the page)
is not displayed.
"""
element = self._get_element(element_or_selector)
def is_invisible(driver):
try:
return not element.is_displayed()
except StaleElementReferenceException:
return True
WebDriverWait(self.driver, timeout).until(is_invisible)
return element
def _get_element(self, element_or_selector):
if isinstance(element_or_selector, basestring):
return self.find(element_or_selector)
else:
return element_or_selector
class UITestCase(LiveServerTestCase):
def use_xvfb(self):
from pyvirtualdisplay import Display
self.display = Display('xvfb',
visible=1,
size=(1280, 1024))
self.display.start()
self.driver = WebDriver()
def setUp(self):
try:
self.driver = WebDriver()
ui_is_not_available = False
except WebDriverException:
ui_is_not_available = True
if ui_is_not_available:
self.use_xvfb()
self.driver.implicitly_wait(10)
super(UITestCase, self).setUp()
def tearDown(self):
self.driver.quit()
if hasattr(self, 'display'):
self.display.stop()
# The super.tearDown sometimes hangs when truncating tables
# because of lingering pending transactions with locks on those tables.
# Kill them to avoid deadlock!
try:
dbname = settings.DATABASES['default']['NAME']
sql = "select pg_terminate_backend(procpid)" + \
" from pg_stat_activity where datname='%s'" % dbname + \
" and current_query='<IDLE> in transaction';"
connection.cursor().execute(sql)
except InterfaceError:
# Sometimes we get "connection already closed"
pass
super(UITestCase, self).tearDown()
def click(self, selector):
self.find(selector).click()
def click_when_visible(self, selector):
element = self.find(selector)
self.wait_until_visible(element)
element.click()
def find(self, selector):
return self.driver.find_element_by_css_selector(selector)
def find_name(self, name):
return self.driver.find_element_by_name(name)
def find_id(self, id):
return self.driver.find_element_by_id(id)
def process_login_form(self, username, password):
username_elmt = self.find_name('username')
password_elmt = self.find_name('password')
username_elmt.send_keys(username)
password_elmt.send_keys(password)
self.click('form * button')
def browse_to_url(self, url):
self.driver.get(self.live_server_url + url)
def find_anchor_by_url(self, url):
return self.find("[href='%s']" % url)
def wait_until_enabled(self, element, timeout=10):
def isPresentAndEnabled(driver):
return element.get_attribute("disabled") is None
WebDriverWait(self.driver, timeout).until(isPresentAndEnabled)
def wait_until_visible(self, element, timeout=10):
def isVisible(driver):
return element.is_displayed()
WebDriverWait(self.driver, timeout).until(isVisible)
class UITestCase(StaticLiveServerTestCase):
def use_xvfb(self):
from pyvirtualdisplay import Display
self.display = Display('xvfb',
visible=1,
size=(DISPLAY_WIDTH, DISPLAY_HEIGHT))
self.display.start()
self.driver = WebDriver()
def setUp(self):
try:
self.driver = WebDriver()
ui_is_not_available = False
except WebDriverException:
ui_is_not_available = True
if ui_is_not_available:
self.use_xvfb()
self.driver.set_window_size(DISPLAY_WIDTH, DISPLAY_HEIGHT)
self.driver.implicitly_wait(10)
clear_caches()
setup_for_ui_test()
super(UITestCase, self).setUp()
def tearDown(self):
self.driver.quit()
if hasattr(self, 'display'):
self.display.stop()
ContentType.objects.clear_cache()
super(UITestCase, self).tearDown()
def click(self, selector):
self.find(selector).click()
def click_when_visible(self, selector):
element = self.find(selector)
self.wait_until_visible(element)
element.click()
def find(self, selector):
return self.driver.find_element_by_css_selector(selector)
def find_name(self, name):
return self.driver.find_element_by_name(name)
def find_id(self, id):
return self.driver.find_element_by_id(id)
def is_visible(self, selector):
element = self.find(selector)
return element is not None and element.is_displayed()
def process_login_form(self, username, password):
username_elmt = self.wait_until_present('[name="username"]')
password_elmt = self.find_name('password')
username_elmt.send_keys(username)
password_elmt.send_keys(password)
self.click('form * button')
def browse_to_url(self, url):
self.driver.get(self.live_server_url + url)
def browse_to_instance_url(self, url, instance=None):
instance = instance if instance is not None else self.instance
self.driver.get('%s/%s/%s' % (self.live_server_url,
instance.url_name,
url))
def find_anchor_by_url(self, url):
return self.find("[href='%s']" % url)
def wait_until_present(self, selector, timeout=10):
"""
Wait until an element with CSS 'selector' exists on the page.
Useful for detecting that an operation loads the page you're expecting.
"""
element = [None] # use list so it can be set by inner scope
def is_present(driver):
element[0] = self.find(selector)
return element[0] is not None and element[0].is_displayed()
WebDriverWait(self.driver, timeout).until(is_present)
return element[0]
def wait_until_text_present(self, text, timeout=10):
"""
Wait until 'text' exists on the page.
Useful for detecting that an operation loads the page you're expecting.
"""
WebDriverWait(self.driver, timeout).until(
lambda driver: text in driver.page_source)
def wait_until_enabled(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' is enabled.
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver, timeout).until(
lambda driver: element.get_attribute("disabled") is None)
return element
def wait_until_visible(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' (known to already exist on the page)
is displayed.
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver, timeout).until(
lambda driver: element.is_displayed())
return element
def wait_until_invisible(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' (known to already exist on the page)
is not displayed.
"""
element = self._get_element(element_or_selector)
def is_invisible(driver):
try:
return not element.is_displayed()
except StaleElementReferenceException:
return True
WebDriverWait(self.driver, timeout).until(is_invisible)
return element
def wait_for_input_value(self, element_or_selector, value, timeout=10):
"""
Wait until 'element_or_selector' input has the specified value
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver, timeout).until(
# It seems wrong, but selenium fetches the value of an input
# element using get_attribute('value')
lambda driver: element.get_attribute('value') == value)
return element
def _get_element(self, element_or_selector):
if isinstance(element_or_selector, basestring):
return self.find(element_or_selector)
else:
return element_or_selector
class FamilyBrowseTests(unittest.TestCase):
"""
Test all the different views you can go to on the family test page
"""
def setUp(self):
self.selenium = WebDriver()
self.live_server_url = LIVE_SERVER_URL
# login boilerplate blah
self.selenium.get(self.live_server_url + '/login')
username_input = self.selenium.find_element_by_name("username_or_email")
username_input.send_keys(ADMIN_USERNAME)
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys(ADMIN_PASSWORD)
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
# visit the family browse page
self.selenium.get(self.live_server_url + '/project/1kg/family/1/mendelian-variant-search')
def test_recessive_basic(self):
self.selenium.find_element_by_xpath('//input[@name="standard_inheritance"][@value="recessive"]').click()
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("7 variants" in stats_content)
def test_homozygous_recessive_basic(self):
self.selenium.find_element_by_xpath('//input[@name="standard_inheritance"][@value="homozygous_recessive"]').click()
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("1 variants" in stats_content)
def test_x_linked_recessive_basic(self):
self.selenium.find_element_by_xpath('//input[@name="standard_inheritance"][@value="x_linked_recessive"]').click()
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("No variants" in stats_content)
def test_compound_het_basic(self):
self.selenium.find_element_by_xpath('//input[@name="standard_inheritance"][@value="compound_het"]').click()
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("6 variants" in stats_content)
def test_dominant_basic(self):
self.selenium.find_element_by_xpath('//input[@name="standard_inheritance"][@value="dominant"]').click()
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("21 variants" in stats_content)
def test_de_novo_basic(self):
self.selenium.find_element_by_xpath('//input[@name="standard_inheritance"][@value="de_novo"]').click()
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("6 variants" in stats_content)
def test_custom_inheritance(self):
self.selenium.find_element_by_xpath('//li[@class="inheritance-pill-li"][@data-search_mode="custom_inheritance"]/a').click()
time.sleep(.5)
choose_select(self.selenium, '//select[@class="col-md-2 select-genotype form-control"][@data-indiv_id="NA19675"]', 'alt_alt')
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("21 variants" in stats_content)
def tearDown(self):
self.selenium.quit()
class UITestCase(LiveServerTestCase):
def use_xvfb(self):
from pyvirtualdisplay import Display
self.display = Display('xvfb',
visible=1,
size=(1280, 1024))
self.display.start()
self.driver = WebDriver()
def setUp(self):
try:
self.driver = WebDriver()
ui_is_not_available = False
except WebDriverException:
ui_is_not_available = True
if ui_is_not_available:
self.use_xvfb()
self.driver.implicitly_wait(10)
super(UITestCase, self).setUp()
def tearDown(self):
self.driver.quit()
if hasattr(self, 'display'):
self.display.stop()
super(UITestCase, self).tearDown()
def click(self, selector):
self.find(selector).click()
def find(self, selector):
return self.driver.find_element_by_css_selector(selector)
def find_name(self, name):
return self.driver.find_element_by_name(name)
def find_id(self, id):
return self.driver.find_element_by_id(id)
def process_login_form(self, username, password):
username_elmt = self.find_name('username')
password_elmt = self.find_name('password')
username_elmt.send_keys(username)
password_elmt.send_keys(password)
self.click('form * button')
def browse_to_url(self, url):
self.driver.get(self.live_server_url + url)
def find_anchor_by_url(self, url):
return self.find("[href='%s']" % url)
def wait_until_enabled(self, element, timeout=10):
def isPresentAndEnabled(driver):
return element.get_attribute("disabled") is None
WebDriverWait(self.driver, timeout).until(isPresentAndEnabled)
def wait_until_visible(self, element, timeout=10):
def isPresentAndEnabled(driver):
return element.is_displayed()
WebDriverWait(self.driver, timeout).until(isPresentAndEnabled)
if not courses:
break
for course in courses:
try:
wait = randint(30, 300)
wd.implicitly_wait(wait)
wd.get(
"https://acorn.utoronto.ca/sws/welcome.do?welcome.dispatch#/")
if wd.find_elements_by_id("inputID"):
wd.find_element_by_id("inputID").click()
wd.find_element_by_id("inputID").clear()
wd.find_element_by_id("inputID").send_keys(utorid)
wd.find_element_by_id("inputPassword").click()
wd.find_element_by_id("inputPassword").clear()
wd.find_element_by_id("inputPassword").send_keys(password)
wd.find_element_by_name("login").click()
wd.find_element_by_link_text("Manage Courses").click()
wd.find_element_by_link_text(program_year).click()
wd.find_element_by_id("searchBox").click()
wd.find_element_by_id("searchBox").clear()
wd.find_element_by_id("searchBox").send_keys(course)
wd.find_element_by_id("searchBox").click()
WebDriverWait(wd, 10).until(
EC.presence_of_element_located(
(By.ID, "course_search_results_list")))
wd.find_elements_by_xpath(
"//ul[@id='course_search_results_list']//li//a")[term].click()
if wd.find_elements_by_link_text("Enrol"):
wd.find_element_by_link_text("Enrol").click()
courses.remove(course)
print("%s was successfully enrolled. Congrats!\n" % course)
class ActivitySeleleniumTests(StaticLiveServerTestCase):
"""Selenium tests for the activity page"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if not settings.DEBUG:
settings.DEBUG = True
if not settings.TESTING:
settings.TESTING = True
def setUp(self):
"""Handles login and things"""
call_command('flush', interactive=False, verbosity=0) # Clears db
call_command('loaddata', 'groups', commit=False, verbosity=0)
call_command('loaddata', 'school', commit=False, verbosity=0)
call_command('loaddata', 'permissions', commit=False, verbosity=0)
call_command('loaddata', 'auth_users', commit=False, verbosity=0)
call_command('loaddata', 'student', commit=False, verbosity=0)
call_command('loaddata', 'advisor', commit=False, verbosity=0)
call_command('loaddata', 'coordinator', commit=False, verbosity=0)
call_command('loaddata', 'activityoptions', commit=False, verbosity=0)
call_command('loaddata', 'learningobjectiveoptions', commit=False, verbosity=0)
call_command('loaddata', 'sample_entries', commit=False, verbosity=0)
self.selenium = WebDriver()
self.selenium.set_window_size(1024, 800)
self.selenium.get('{0}/{1}'.format(self.live_server_url, ''))
self.selenium.find_element_by_xpath('//*[@id="djHideToolBarButton"]').click()
self.selenium.implicitly_wait(10)
self.selenium.find_element_by_link_text('Login').click()
# Click on the student button in the gateway
self.selenium.find_element_by_xpath('/html/body/center/md-content/div/div/div[1]/a').click()
self.selenium\
.find_element_by_xpath("//img[@src='/static/journal/activities/img"
"/journal_sign.png']")
super()
def tearDown(self):
self.selenium.quit()
super()
def test_activity_form_back(self):
"""make sure the back button works"""
self.selenium.find_element_by_xpath("/html/body/div[1]/div[2]/div/div[1]/div/div[2]/div/a").click()
self.selenium.find_element_by_name('activity_name').send_keys('Walking the cat')
self.selenium.find_element_by_name('activity_description').send_keys('Walking the cat around the neighborhood')
self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div[1]/form/div[2]/div[2]/input').send_keys('02/07/1990')
self.selenium.find_element_by_xpath('//*[@id="id_activity_type"]/li[2]/label').click()
self.selenium.find_element_by_xpath('//*[@id="id_activity_type"]/li[3]/label').click()
self.selenium.find_element_by_xpath('//*[@id="id_learned_objective"]/li[6]/label').click()
self.selenium.find_element_by_name('activity_adviser').send_keys('Cat')
self.selenium.find_element_by_name('advisor_phone').send_keys('1234567890')
self.selenium.find_element_by_name('advisor_email').send_keys('*****@*****.**')
self.selenium.find_element_by_link_text('Back').click()
self.selenium\
.find_element_by_xpath("//img[@src='/static/journal/activities/img"
"/journal_sign.png']")
def test_activity_form_error(self):
"""Tests to check errors on the activity form"""
self.selenium.find_element_by_xpath("/html/body/div[1]/div[2]/div/div[1]/div/div[2]/div/a").click()
# self.selenium.find_element_by_name('activity_name').send_keys('')
self.selenium.find_element_by_name('activity_description').send_keys('Walking with huahua around the neighborhood')
self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div[1]/form/div[2]/div[2]/input').send_keys('02/07/1990')
self.selenium.find_element_by_xpath('//*[@id="id_activity_type"]/li[2]/label').click()
self.selenium.find_element_by_xpath('//*[@id="id_activity_type"]/li[3]/label').click()
self.selenium.find_element_by_xpath('//*[@id="id_learned_objective"]/li[6]/label').click()
self.selenium.find_element_by_name('activity_adviser').send_keys('Cat')
self.selenium.find_element_by_name('advisor_phone').send_keys('1234567890')
self.selenium.find_element_by_name('advisor_email').send_keys('*****@*****.**')
self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div[1]/form/div[6]/div/input').click()
self.selenium.find_element_by_name('activity_description').text
def test_activity_form(self):
"""Tests to ensure that activities page has all necessary elements."""
self.selenium.find_element_by_xpath("/html/body/div[1]/div[2]/div/div[1]/div/div[2]/div/a").click()
self.selenium.find_element_by_name('activity_name').send_keys('Walking the cat')
self.selenium.find_element_by_name('activity_description').send_keys('Walking the cat around the neighborhood')
self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div[1]/form/div[2]/div[2]/input').send_keys('02/07/1990')
self.selenium.find_element_by_xpath('//*[@id="id_activity_type"]/li[2]/label').click()
self.selenium.find_element_by_xpath('//*[@id="id_activity_type"]/li[3]/label').click()
self.selenium.find_element_by_xpath('//*[@id="id_learned_objective"]/li[6]/label').click()
self.selenium.find_element_by_name('activity_adviser').send_keys('Cat')
self.selenium.find_element_by_name('advisor_phone').send_keys('1234567890')
self.selenium.find_element_by_name('advisor_email').send_keys('*****@*****.**')
self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div[1]/form/div[6]/div/input').click()
self.selenium\
.find_element_by_xpath("//img[@src='/static/journal/activities/img"
"/journal_sign.png']")
body_text = self.selenium.find_element_by_tag_name('body').text
self.assertTrue('Walking the cat' in body_text)
self.assertTrue('Walking the cat around the neighborhood' in body_text)
import time
success = True
wd = WebDriver()
wd.implicitly_wait(60)
def is_alert_present(wd):
try:
wd.switch_to_alert().text
return True
except:
return False
try:
wd.get("http://localhost/addressbook/")
wd.find_element_by_name("pass").click()
wd.find_element_by_name("pass").clear()
wd.find_element_by_name("pass").send_keys("secret")
wd.find_element_by_name("user").click()
wd.find_element_by_name("user").clear()
wd.find_element_by_name("user").send_keys("admin")
wd.find_element_by_css_selector("input[type=\"submit\"]").click()
wd.find_element_by_link_text("groups").click()
wd.find_element_by_name("new").click()
wd.find_element_by_name("group_name").click()
wd.find_element_by_name("group_name").clear()
wd.find_element_by_name("group_name").send_keys("new froup")
wd.find_element_by_name("group_header").click()
wd.find_element_by_name("group_header").clear()
wd.find_element_by_name("group_header").send_keys("new grope")
wd.find_element_by_name("group_footer").click()
class UITestCase(LiveServerTestCase):
def use_xvfb(self):
from pyvirtualdisplay import Display
self.display = Display('xvfb', visible=1, size=(1280, 1024))
self.display.start()
self.driver = WebDriver()
def setUp(self):
try:
self.driver = WebDriver()
ui_is_not_available = False
except WebDriverException:
ui_is_not_available = True
if ui_is_not_available:
self.use_xvfb()
self.driver.implicitly_wait(10)
clear_caches()
setup_for_ui_test()
super(UITestCase, self).setUp()
def tearDown(self):
self.driver.quit()
if hasattr(self, 'display'):
self.display.stop()
ContentType.objects.clear_cache()
super(UITestCase, self).tearDown()
def click(self, selector):
self.find(selector).click()
def click_when_visible(self, selector):
element = self.find(selector)
self.wait_until_visible(element)
element.click()
def find(self, selector):
return self.driver.find_element_by_css_selector(selector)
def find_name(self, name):
return self.driver.find_element_by_name(name)
def find_id(self, id):
return self.driver.find_element_by_id(id)
def process_login_form(self, username, password):
username_elmt = self.wait_until_present('[name="username"]')
password_elmt = self.find_name('password')
username_elmt.send_keys(username)
password_elmt.send_keys(password)
self.click('form * button')
def browse_to_url(self, url):
self.driver.get(self.live_server_url + url)
def browse_to_instance_url(self, url, instance=None):
instance = instance if instance is not None else self.instance
self.driver.get('%s/%s/%s' %
(self.live_server_url, self.instance.url_name, url))
def find_anchor_by_url(self, url):
return self.find("[href='%s']" % url)
def wait_until_present(self, selector, timeout=10):
"""
Wait until an element with CSS 'selector' exists on the page.
Useful for detecting that an operation loads the page you're expecting.
"""
element = [None] # use list so it can be set by inner scope
def is_present(driver):
element[0] = self.find(selector)
return element[0] is not None
WebDriverWait(self.driver, timeout).until(is_present)
return element[0]
def wait_until_text_present(self, text, timeout=10):
"""
Wait until 'text' exists on the page.
Useful for detecting that an operation loads the page you're expecting.
"""
WebDriverWait(self.driver,
timeout).until(lambda driver: text in driver.page_source)
def wait_until_enabled(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' is enabled.
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver, timeout).until(
lambda driver: element.get_attribute("disabled") is None)
return element
def wait_until_visible(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' (known to already exist on the page)
is displayed.
"""
element = self._get_element(element_or_selector)
WebDriverWait(self.driver,
timeout).until(lambda driver: element.is_displayed())
return element
def wait_until_invisible(self, element_or_selector, timeout=10):
"""
Wait until 'element_or_selector' (known to already exist on the page)
is not displayed.
"""
element = self._get_element(element_or_selector)
def is_invisible(driver):
try:
return not element.is_displayed()
except StaleElementReferenceException:
return True
WebDriverWait(self.driver, timeout).until(is_invisible)
return element
def _get_element(self, element_or_selector):
if isinstance(element_or_selector, basestring):
return self.find(element_or_selector)
else:
return element_or_selector
success = True
wd = WebDriver()
wd.implicitly_wait(60)
def is_alert_present(wd):
try:
wd.switch_to_alert().text
return True
except:
return False
try:
wd.get("http://localhost/addressbook/group.php")
wd.find_element_by_name("pass").click()
wd.find_element_by_name("pass").send_keys("\\undefined")
wd.find_element_by_xpath("//form[@id='LoginForm']/input[3]").click()
wd.find_element_by_link_text("home").click()
if not wd.find_element_by_xpath(
"//form[@id='right']/select//option[4]").is_selected():
wd.find_element_by_xpath(
"//form[@id='right']/select//option[4]").click()
if not wd.find_element_by_xpath("//input[@id='488']").is_selected():
wd.find_element_by_xpath("//input[@id='488']").click()
wd.find_element_by_xpath(
"//div[@id='content']/form[2]/div[3]/input").click()
wd.find_element_by_xpath(
"//div[@class='msgbox']//a[.='group page \"nameRRK\"']").click()
finally:
wd.quit()
def syn_test_script():
try:
success = True
driver = WebDriver()
driver.implicitly_wait(30)
# Disabled page sizing and instead used action chains to move mouse around
# driver.set_window_size(1920, 1080)
# Use Action chains to navigate page when there is an issue with the selection menus
# If the menu item does not appear to select, it means there was a page movement that happened
# out of sync with the action.
log_output(
"Starting @ http://www.kay.com/en/kaystore/searchterm/732541000/true/732541000"
)
driver.get(
"http://www.kay.com/en/kaystore/searchterm/732541000/true/732541000"
)
log_output("Verify Search Results on page")
html_text = driver.find_element_by_tag_name("html").text
if not ("Home Search Results" in html_text):
success = False
print("verifyTextPresent failed")
log_output("Click on first item - using div tag")
driver.find_element_by_xpath(
"//div[@id='product-grid']/div[1]/div/a/h3").click()
log_output("Start customizing ring")
driver.find_element_by_xpath(
"//div[@class='m-vcb-content-html-modifier']//button[.='Start Customizing']"
).click()
log_output("Choose number of stones and birth Stone")
if not driver.find_element_by_xpath(
"//select[@id='birthStoneSelect']//option[2]").is_selected():
driver.find_element_by_xpath(
"//select[@id='birthStoneSelect']//option[2]").click()
driver.find_element_by_id("btnStartCustomizing").click()
log_output("Step - Select Stone Type")
ActionChains(driver).move_to_element(
driver.find_element_by_css_selector("span.month_text")).perform()
driver.find_element_by_css_selector("span.month_text").click()
driver.find_element_by_xpath(
"//div[@id='tab-stones-1']/div/ul/li[1]/label").click()
if not driver.find_element_by_name("stoneId1").is_selected():
driver.find_element_by_name("stoneId1").click()
driver.find_element_by_link_text("SELECT").click()
driver.find_element_by_xpath("//div[@id='cs']//a[.='Next']").click()
log_output("Step - Select Metal Type")
if not driver.find_element_by_xpath(
"//select[@id='metalTypeSelect']//option[2]").is_selected():
driver.find_element_by_xpath(
"//select[@id='metalTypeSelect']//option[2]").click()
log_output("clicking next")
driver.find_element_by_xpath("//div[@id='m']//a[.='Next']").click()
log_output("Step - Select ring size")
if not driver.find_element_by_xpath(
"//select[@id='sizeSelect']//option[2]").is_selected():
driver.find_element_by_xpath(
"//select[@id='sizeSelect']//option[2]").click()
ActionChains(driver).move_to_element(
driver.find_element_by_xpath(
"//div[@id='rs']//a[.='Next']")).perform()
next_click = driver.find_element_by_xpath(
"//div[@id='rs']//a[.='Next']")
next_click.click()
ActionChains(driver).move_to_element(
driver.find_element_by_xpath(
"//div[@id='engr']//a[.='Next']")).perform()
driver.find_element_by_xpath("//div[@id='engr']//a[.='Next']").click()
log_output("Step - Add item to bag")
driver.find_element_by_id("addToCart").click()
# driver.find_element_by_link_text("ADD TO BAG").click()
log_output("Step - Goto Checkout")
driver.find_element_by_link_text("CHECKOUT").click()
log_output("Verify text on page - Shopping Bag")
html_text = driver.find_element_by_tag_name("html").text
if not ("Shopping Bag" in html_text):
success = False
print("verifyTextPresent failed")
finally:
driver.quit()
if not success:
raise Exception("Test failed.")
class RegisteredUserTest(LiveServerTestCase):
"""
Test as a registered user
"""
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(3)
self.n1 = Node.objects.create(
title='TestNodeOne',
description='The first test node'
)
self.u1 = User.objects.create_user(
username='******', email='*****@*****.**', password='******'
)
self.u2 = User.objects.create_user(
username='******', email='*****@*****.**', password='******'
)
# Create 198 topics
for i in range(1, 100):
setattr(
self,
't%s' % i,
Topic.objects.create(
title='Test Topic %s' % i,
user=self.u1,
content_raw='This is test topic __%s__' % i,
node=self.n1
)
)
for i in range(100, 199):
setattr(
self,
't%s' % i,
Topic.objects.create(
title='Test Topic %s' % i,
user=self.u2,
content_raw='This is test topic __%s__' % i,
node=self.n1
)
)
def tearDown(self):
self.browser.quit()
def test_edit_own_topic(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
own_topic = getattr(self, "t%s" % (random.choice(range(1, 100))))
self.browser.get(self.live_server_url+reverse("niji:topic", kwargs={"pk": own_topic.id}))
self.browser.find_element_by_link_text("Edit").click()
content_raw = self.browser.find_element_by_name("content_raw")
content_raw.clear()
content_raw.send_keys("This topic is edited")
self.browser.find_element_by_name("submit").click()
self.assertIn("This topic is edited", self.browser.page_source)
def test_edit_others_topic(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
others_topic = getattr(self, "t%s" % (random.choice(range(100, 199))))
self.browser.get(self.live_server_url+reverse("niji:topic", kwargs={"pk": others_topic.id}))
self.assertNotIn(
"<span class=\"label label-success\">Edit</span>",
self.browser.page_source
)
self.browser.get(
self.live_server_url+reverse("niji:edit_topic", kwargs={"pk": others_topic.id})
)
self.assertIn("You are not allowed to edit other's topic", self.browser.page_source)
def test_reply_topic(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
topic = getattr(self, "t%s" % (random.choice(range(1, 199))))
self.browser.get(self.live_server_url+reverse("niji:topic", kwargs={"pk": topic.id}))
content_raw = self.browser.find_element_by_name("content_raw")
content_raw.clear()
content_raw.send_keys("This is a reply")
self.browser.find_element_by_name("submit").click()
self.assertIn("This is a reply", self.browser.page_source)
def test_create_topic(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
self.browser.get(self.live_server_url+reverse("niji:create_topic"))
node = self.browser.find_element_by_name("node")
node = Select(node)
title = self.browser.find_element_by_name("title")
content_raw = self.browser.find_element_by_name("content_raw")
node.select_by_visible_text(self.n1.title)
title.send_keys("test title")
content_raw.send_keys("this is content")
self.browser.find_element_by_name("submit").click()
self.assertIn("this is content", self.browser.page_source)
def test_create_appendix(self):
self.browser.get(self.live_server_url+reverse('niji:index'))
login(self.browser, "test1", "111")
self.assertIn("Log out", self.browser.page_source)
own_topic = getattr(self, "t%s" % (random.choice(range(1, 100))))
self.browser.get(self.live_server_url+reverse("niji:topic", kwargs={"pk": own_topic.id}))
self.browser.find_element_by_link_text("Append").click()
content_raw = self.browser.find_element_by_name("content_raw")
content_raw.clear()
content_raw.send_keys("This is an appendix")
self.browser.find_element_by_name("submit").click()
self.assertIn("This is an appendix", self.browser.page_source)
# -*- coding: utf-8 -*-
from selenium.webdriver.firefox.webdriver import WebDriver
from selenium.webdriver.common.action_chains import ActionChains
import time
success = True
wd = WebDriver()
wd.implicitly_wait(60)
def is_alert_present(wd):
try:
wd.switch_to_alert().text
return True
except:
return False
try:
wd.get("http://localhost/php4dvd/")
wd.find_element_by_id("username").click()
wd.find_element_by_id("username").clear()
wd.find_element_by_id("username").send_keys("admin")
wd.find_element_by_name("password").click()
wd.find_element_by_name("password").clear()
wd.find_element_by_name("password").send_keys("admin")
wd.find_element_by_name("submit").click()
finally:
wd.quit()
if not success:
raise Exception("Test failed.")
from selenium.webdriver.firefox.webdriver import WebDriver
success = True
wd = WebDriver()
wd.implicitly_wait(60)
def is_alert_present(wd):
try:
wd.switch_to_alert().text
return True
except:
return False
try:
wd.get("http://localhost/addressbook/index.php")
wd.find_element_by_name("user").click()
wd.find_element_by_name("user").clear()
wd.find_element_by_name("user").send_keys("admin")
wd.find_element_by_name("pass").click()
wd.find_element_by_name("pass").clear()
wd.find_element_by_name("pass").send_keys("secret")
wd.find_element_by_xpath("//form[@id='LoginForm']/input[3]").click()
wd.find_element_by_link_text("groups").click()
wd.find_element_by_name("new").click()
wd.find_element_by_name("group_name").click()
wd.find_element_by_name("group_name").clear()
wd.find_element_by_name("group_name").send_keys("adfadf")
wd.find_element_by_name("group_header").click()
wd.find_element_by_name("group_header").clear()
wd.find_element_by_name("group_header").send_keys("adfadfadf")
wd.find_element_by_name("group_footer").click()
class BaseStoreTest(StaticLiveServerTestCase):
def by_id(self, id):
return self.selenium.find_element_by_id(id)
def by_css(self, selector: str, multiple: bool = False):
if multiple:
return self.selenium.find_elements_by_css_selector(selector)
else:
return self.selenium.find_element_by_css_selector(selector)
def setUp(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(SELENIUM_WAIT_SEC)
user = create_user(TEST_USER, TEST_PASSWORD, TEST_EMAIL)
user.firstname = 'live'
user.lastname = 'test'
user.save()
def tearDown(self):
try:
delete_user(TEST_USER)
except Exception:
pass
super().tearDown()
self.selenium.quit()
def go_to(self, url_name: str, kwargs: Dict[str, str] = None) -> None:
app_url = reverse(url_name, kwargs=kwargs)
self.selenium.get('%s%s' % (self.live_server_url, app_url))
def go_to_app(self, app_id):
self.go_to('app-detail', {'id': app_id})
def go_to_app_register(self):
self.go_to('app-register')
def go_to_app_upload(self):
self.go_to('app-upload')
def go_to_login(self):
self.selenium.get('%s%s' % (self.live_server_url, '/login/'))
def login(self, user: str = TEST_USER, password: str = TEST_PASSWORD):
self.go_to_login()
user_input = self.selenium.find_element_by_name("login")
user_input.send_keys(user)
pass_input = self.selenium.find_element_by_name("password")
pass_input.send_keys(password)
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
def assert_can_not_login(self):
self.go_to('home')
self.go_to_login()
self.by_id('id_login').clear()
self.by_id('id_login').send_keys('livetest')
self.by_id('id_password').clear()
self.by_id('id_password').send_keys('livetest')
self.by_css('.auth-form button[type="submit"]').click()
error = self.by_css('.auth-form .text-danger')
self.assertTrue(error.is_displayed())
self.assertOnPage('account_login')
def logout(self):
self.findNavigationLink('account_logout').click()
def wait_for(self, selector: str, then: Callable[[WebElement],
None]) -> Any:
element = WebDriverWait(self.selenium, SELENIUM_WAIT_SEC).until(
EC.visibility_of_element_located((By.CSS_SELECTOR, selector)))
return then(element)
def wait_for_url(self, url: str) -> Any:
WebDriverWait(self.selenium,
SELENIUM_WAIT_SEC).until(EC.url_contains(url))
def assertOnPage(self,
url_name: str,
kwargs: Dict[str, str] = None) -> None:
parsed = urlparse(self.selenium.current_url)
url = reverse(url_name, kwargs=kwargs)
self.assertEqual(url, parsed.path)
def findNavigationLink(self, url_name: str, kwargs: Dict[str, str] = None):
route = reverse(url_name, kwargs=kwargs)
return self.by_css('#navbar a[href="%s"]' % route)
class BaseSeleniumPoolStatsTestCase(BasePoolStatsTestCase):
def setUp(self):
self.vdisplay = Xvfb(width=1280, height=1024)
self.vdisplay.start()
self.selenium = WebDriver()
super(BaseSeleniumPoolStatsTestCase, self).setUp()
def tearDown(self):
self.selenium.quit()
self.vdisplay.stop()
super(BaseSeleniumPoolStatsTestCase, self).tearDown()
def score_sheet_create(self,
match_id=BasePoolStatsTestCase.DEFAULT_TEST_MATCH_ID,
week_id=BasePoolStatsTestCase.DEFAULT_TEST_WEEK_ID):
self.selenium.get('{}week/{}'.format(self.base_url, week_id))
self.selenium.find_element_by_id('score_sheet_create_button_match_{}'.format(match_id)).click()
def populate_lineup(self, away_players=4, home_players=4):
# get the lineup form, set the first player to 1, second to 2, etc
for location_name in location_names:
# first, make sure the form you are about to interact with is visible, to avoid a
# selenium.common.exceptions.ElementNotInteractableException being thrown.
self.selenium.find_element_by_id('toggle-{}_lineup'.format(location_name)).click()
lineup_form = self.selenium.find_element_by_id('{}_lineup'.format(location_name))
# referring to away_players and home_players only via eval() makes them look unused ...
for inc in range(0, eval('{}_players'.format(location_name))):
select = Select(lineup_form.find_element_by_id('id_form-{}-player'.format(inc)))
select.select_by_index(inc + 1) # 'inc + 1' as the first option in the select is '------' or similar
# submit the form
self.selenium.find_element_by_id('{}_lineup_save'.format(location_name)).click()
def set_substitution(self, away_home, game_index, player_index=1, substitution_index=0):
self.selenium.find_element_by_id('toggle-{}_substitutions'.format(away_home)).click()
substitution_form = self.selenium.find_element_by_id('{}_substitutions'.format(away_home))
game_select = Select(substitution_form.find_element_by_id('id_form-{}-game_order'.format(substitution_index)))
if game_index is not None:
game_select.select_by_index(game_index)
player_select = Select(substitution_form.find_element_by_id('id_form-{}-player'.format(substitution_index)))
# select the 1th player; zero is '------' or similar
player_select.select_by_index(player_index)
selected_player = player_select.first_selected_option
self.selenium.find_element_by_id('{}_substitutions_save'.format(away_home)).click()
return selected_player
def set_winners(self, forfeits=0, table_runs=0, random_wins=True):
games_form = self.selenium.find_element_by_name('score_sheet_games_form')
# hard-coding game count here, is there a way to not do that?
# id_form-1-winner_0
win_counts = {
'home': 0,
'away': 0,
}
forfeit_games = []
tr_games = []
for inc in range(0, 16):
# choose whether home (0) or away (1) wins "randomly"
if random_wins:
winner = randrange(0, 2)
else:
winner = inc % 2
win_counts[location_names[winner]] += 1
button = games_form.find_element_by_id('id_form-{}-winner_{}'.format(inc, winner))
button.click()
# set some forfeits!
while len(forfeit_games) < forfeits:
candidate = randrange(0, 16)
while candidate in forfeit_games:
candidate = randrange(0, 16)
forfeit_games.append(candidate)
while len(tr_games) < table_runs:
candidate = randrange(0, 16)
while candidate in forfeit_games or candidate in tr_games:
candidate = randrange(0, 16)
tr_games.append(candidate)
for forfeit_game in forfeit_games:
games_form.find_element_by_id('id_form-{}-forfeit'.format(forfeit_game)).click()
for tr_game in tr_games:
games_form.find_element_by_id('id_form-{}-table_run'.format(tr_game)).click()
games_form.find_element_by_id('games-save-button').click()
return win_counts
@staticmethod
def count_player_stats_in_table(table):
player_rows = table.find_elements_by_xpath('tbody/tr')
wins = 0
losses = 0
trs = 0
for player_row in player_rows:
player_cells = player_row.find_elements_by_tag_name('td')
wins += int(player_cells[3].text)
losses += int(player_cells[4].text)
trs += int(player_cells[7].text)
return {
'wins': wins,
'losses': losses,
'trs': trs,
}
@property
def base_url(self):
return '{}/stats/'.format(self.live_server_url)
class SeleniumTests(LiveServerTestCase):
"""Base class for all Selenium test classes to inherit from"""
@classmethod
def setUpClass(self):
self.selenium = WebDriver()
self.selenium.implicitly_wait(3)
super(SeleniumTests, self).setUpClass()
@classmethod
def tearDownClass(self):
self.selenium.quit()
super(SeleniumTests, self).tearDownClass()
def setUp(self):
# Create a test user and admin account
self.user_name = 'SeleniumTestUser'
self.user_pass = '******'
if User.objects.filter(username=self.user_name).count() == 0:
User.objects.create_user(self.user_name, '', self.user_pass).save()
self.admin_name = 'SeleniumAdministrativeUser'
self.admin_pass = '******'
if User.objects.filter(username=self.admin_name).count() == 0:
User.objects.create_superuser(self.admin_name, '', self.admin_pass).save()
def tearDown(self):
self.selenium.delete_all_cookies()
def link_text_exists(self, link_text):
try:
self.selenium.find_element_by_link_text(link_text)
except NoSuchElementException:
return False
return True
def xpath_exists(self, xpath):
try:
self.selenium.find_element_by_xpath(xpath)
except NoSuchElementException:
return False
return True
def element_with_selector_exists(self, selector):
try:
self.selenium.find_element_by_css_selector(selector)
except NoSuchElementException:
return False
return True
def text_exists(self, text, xpath="//body"):
try:
element = self.selenium.find_element_by_xpath(xpath)
except NoSuchElementException:
return False
if text in element.text:
return True
else:
return False
def login(self, username, password):
# Go to the login page and try logging in with the provided credentials
self.selenium.get('%s' % self.live_server_url)
self.selenium.find_element_by_link_text('Log in').click()
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)
self.selenium.find_element_by_class_name('submit').click()
def create_items_and_requests(self, x):
# Creates x number of items and requests
for i in xrange(x):
self.item = G(Item)
self.request = G(Request, item=self.item)
def create_generic_item(self):
# Quick helper in the absence of fixtures
item = G(Item, local_num=9999, part_class='parts class',
location='cart 8', description='test item', cfi='never',
company='A Business', part_num='X9X9', serial_num='8A',
asset_num='sample_num', notes='Testing')
return item
class Tests():
loged = False
username = None
selenium = None
def __init__(self):
# crea driver
self.selenium = WebDriver()
self.selenium.implicitly_wait(3)
def backend_login(self, usuari, contrasenya):
# accedeix a URL
self.selenium.get('%s%s' % ("http://*****:*****@value="Iniciar sessió"]').click()
try:
boto_logout = self.selenium.find_element_by_xpath(
'//a[text()="Finalitzar sessió"]')
except NoSuchElementException as e:
raise Exception("ERROR en login de l'usuari: " + usuari)
self.logat = True
self.username = usuari
def backend_logout(self):
self.selenium.find_element_by_xpath(
'//a[text()="Finalitzar sessió"]').click()
def ves_al_menu_principal(self):
# anar a menu principal
self.selenium.find_element_by_xpath('//a[@href="/admin/"]').click()
# aqui va la "chicha"
def crea_empresa(self, nom):
self.ves_al_menu_principal()
# afegim empresa
self.selenium.find_element_by_xpath(
'//a[@href="/admin/borsApp/empresa/add/"]').click()
self.selenium.find_element_by_name('nom').send_keys(nom)
# accedir dins iframe direcció
self.selenium.switch_to_frame("id_direccio_ifr")
self.selenium.find_element_by_xpath('//body').send_keys("c. Tal, 1")
# tornar al main frame
self.selenium.switch_to_default_content()
self.selenium.find_element_by_name('poblacio').send_keys("Cornellà")
self.selenium.find_element_by_name('cp').send_keys("08940")
self.selenium.find_element_by_name('telefon').send_keys("931112233")
nom2 = nom.replace(' ', '_')
self.selenium.find_element_by_name('email').send_keys("info@" + nom2 +
".com")
self.selenium.find_element_by_xpath('//input[@value="Desar"]').click()
# check
self.selenium.find_element_by_xpath('//li[@class="success"]')
def ajusta_usuari_empresa(self, usuari, contrasenya):
# se suposa que estem logats com a admin_centre
self.ves_al_menu_principal()
# menu usuaris
self.selenium.find_element_by_xpath('//a[text()="Usuaris"]').click()
# accedim a l'usuari de l'empresa acabada de crear
# el nom de l'usuari és igual al de l'empresa, al menys pels tests
self.selenium.find_element_by_xpath('//a[text()="' + usuari +
'"]').click()
# anem a canvi de contasenya
self.selenium.find_element_by_xpath(
'//a[@href="../password/"]').click()
self.selenium.find_element_by_name('password1').send_keys(contrasenya)
self.selenium.find_element_by_name('password2').send_keys(contrasenya)
self.selenium.find_element_by_xpath(
'//input[@value="Canviar contrasenya"]').click()
# comprovem usuari creat OK
# TODO: millorar test (comprovar no errors/warnings)
#self.selenium.find_element_by_xpath('//li[@class="success" and contains(text(),"fou afegit amb èxit")]')
self.selenium.find_element_by_xpath('//li[@class="success"]')
def crea_oferta_caducada(self):
self.ves_al_menu_principal()
# menu ofertes
self.selenium.find_element_by_xpath(
'//a[@href="/admin/borsApp/oferta/add/"]').click()
# omplim form
self.selenium.find_element_by_name('inici_0').clear()
self.selenium.find_element_by_name('inici_1').clear()
self.selenium.find_element_by_name('final_0').clear()
self.selenium.find_element_by_name('final_1').clear()
self.selenium.find_element_by_name('inici_0').send_keys("01/01/2019")
self.selenium.find_element_by_name('inici_1').send_keys("10:30:00")
self.selenium.find_element_by_name('final_0').send_keys("10/02/2019")
self.selenium.find_element_by_name('final_1').send_keys("10:30:00")
self.selenium.find_element_by_name('titol').send_keys(
"oferta test caducada 1")
# select2 empresa (FK)
self.selenium.find_element_by_xpath(
'//span[@id="select2-id_empresa-container"]').click()
self.selenium.find_element_by_xpath('//li[text()="' + self.username +
'"]').click()
# select2 cicles (m2m)
self.selenium.find_element_by_xpath(
'//div[@class="form-row field-cicles"]').click()
self.selenium.find_element_by_xpath(
'//input[@class="select2-search__field"]').send_keys("web\n")
# direccio té el RichTextField amb un iframe pel mig
# accedir dins iframe direcció
self.selenium.switch_to_frame("id_descripcio_ifr")
self.selenium.find_element_by_xpath('//body').send_keys(
"oferta test caducada.\nbla bla...")
# tornar al main frame
self.selenium.switch_to_default_content()
# submit
self.selenium.find_element_by_xpath('//input[@value="Desar"]').click()
# comprovem oferta creada OK
self.selenium.find_element_by_xpath('//li[@class="success"]')
def veu_oferta_caducada1(self):
self.ves_al_menu_principal()
self.selenium.find_element_by_xpath('//a[text()="Ofertes"]').click()
self.selenium.find_element_by_xpath(
'//a[text()="oferta test caducada 1"]').click()
def no_veu_oferta_caducada1(self):
self.ves_al_menu_principal()
try:
self.selenium.find_element_by_xpath(
'//a[text()="Ofertes"]').click()
self.selenium.find_element_by_xpath(
'//a[text()="oferta test caducada 1"]').click()
raise Exception(
"ERROR: l'usuari no autoritzat '%s' pot veure les ofertes de l'empresa 1"
% (self.username, ))
except NoSuchElementException as e:
# si no el troba, esta OK
pass
except Exception as e:
raise e
class UIRespondentTests(StaticLiveServerTestCase):
""" Tests for the UI presented to the survey respondents. These include
page rendering, response submission, and the CSRF protection of the page"""
def setUp(self):
""" Set up for the UI/respondent test case """
super(UIRespondentTests, self).setUp()
self.web_driver = WebDriver()
# Create a new survey, add some questions, and publish
user = User.objects.create(username='******')
survey = user.surveys.create(name='foobar')
questions = ['what?', 'where?', 'why?', 'when?', 'anything else?']
for question in questions:
survey.questions.create(question_text=question)
survey.publish()
self.survey = survey
# Load up the response page
url = '%s%s%s/' % (self.live_server_url, '/respond/', survey.id)
self.web_driver.get(url)
# No way of checking directly for 404 in selenium; just make sure the
# survey name is in the source
self.assertIn('foobar', self.web_driver.page_source)
def tearDown(self):
""" Clean up for the UI/respondent test case """
self.web_driver.quit()
super(UIRespondentTests, self).tearDown()
User.objects.all().delete()
def test_response_page_rendering(self):
""" The response page for a a survey contains the correct questions,
in order
"""
try:
form = self.web_driver.find_element_by_name('survey-respond-%s' %
self.survey.id)
except NoSuchElementException:
self.fail('The form did not render with the expected element name')
# For every question in the DB, make sure the page contains an element
# for each, with the name as the question's ordinance and the id as
# the question's pk.
for question_ix, question in enumerate(self.survey.questions.all()):
try:
e1 = self.web_driver.find_element_by_name(str(question_ix))
except NoSuchElementException:
self.fail('Question index %s was not rendered in response page'
% question_ix)
try:
e2 = self.web_driver.find_element_by_id(str(question.pk))
except NoSuchElementException:
self.fail('Question pk %s was not rendered in response page'
% question.pk)
if e1 != e2:
self.fail('Expected HTML element for question pk %s and id %s '
'to match' % (question.pk, question_ix))
def test_response_submission(self):
""" A submission of a valid form creates the expected `Response` and
`Answer` entries in the database
"""
questions = self.survey.questions.all()
for question_ix, question in enumerate(questions):
ans_input = self.web_driver.find_element_by_name(str(question_ix))
ans_input.send_keys('Answer to "%s"' % question.question_text)
submit_button = self.web_driver.find_element_by_name('submit-response')
submit_button.click()
answers = self.survey.responses.get().answers.all()
self.assertEqual(len(answers), len(questions))
for question, answer in zip(questions, answers):
self.assertEqual(answer.answer_text,
'Answer to "%s"' % question.question_text)
def test_csrf_protection(self):
""" The form has a CSRF token and POST requests made outside of the
form are rejected
"""
# Make sure the CSRF token exists
try:
self.web_driver.find_element_by_name('csrfmiddlewaretoken')
except NoSuchElementException:
self.fail('No CSRF token in response form')
# Check that a 403 is returned when trying to submit a response not via
# the form
response = requests.post('%s%s%s/' % (self.live_server_url,
'/respond/',
self.survey.id))
self.assertEqual(response.status_code, 403)
class VisitorTest(LiveServerTestCase):
"""
Test as a visitor (unregistered user)
"""
def setUp(self):
self.browser = WebDriver()
self.browser.implicitly_wait(3)
self.n1 = Node.objects.create(title='TestNodeOne',
description='The first test node')
self.u1 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.u2 = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
# Create 99 topics
for i in range(1, 100):
setattr(
self, 't%s' % i,
Topic.objects.create(title='Test Topic %s' % i,
user=self.u1,
content_raw='This is test topic __%s__' %
i,
node=self.n1))
def tearDown(self):
self.browser.quit()
def test_index(self):
self.browser.get(self.live_server_url + reverse('index'))
self.assertIn('niji', self.browser.page_source.lower())
def test_topic_page_content(self):
self.browser.get(self.live_server_url +
reverse('topic', kwargs={'pk': self.t88.pk}))
self.assertIn('This is test topic <strong>88</strong>',
self.browser.page_source)
def test_hidden_post(self):
hidden_post = Post.objects.create(topic=self.t1,
content_raw="i'm a reply 12138",
user=self.u1)
self.browser.get(self.live_server_url +
reverse('topic', kwargs={'pk': self.t1.pk}))
self.assertIn("i'm a reply 12138", self.browser.page_source)
hidden_post.hidden = True
hidden_post.save()
self.browser.get(self.browser.current_url)
self.assertNotIn("i'm a reply 12138", self.browser.page_source)
def test_node_page(self):
self.browser.get(self.live_server_url +
reverse('node', kwargs={'pk': self.n1.pk}))
topics = self.browser.find_elements_by_css_selector(
'ul.topic-list > li')
self.assertEqual(len(topics), 30)
def test_user_login(self):
self.browser.get(self.live_server_url + reverse('index'))
self.assertNotIn("Log out", self.browser.page_source)
login(self.browser, "test1", "111")
self.assertEqual(self.browser.current_url,
self.live_server_url + reverse("index"))
self.assertIn("Log out", self.browser.page_source)
def test_usr_reg(self):
self.browser.get(self.live_server_url + reverse('index'))
self.browser.find_element_by_link_text("Reg").click()
self.assertEqual(self.browser.current_url,
self.live_server_url + reverse("reg"))
username = self.browser.find_element_by_name('username')
email = self.browser.find_element_by_name('email')
password1 = self.browser.find_element_by_name('password1')
password2 = self.browser.find_element_by_name('password2')
username.send_keys("test3")
password1.send_keys("333")
password2.send_keys("333")
email.send_keys("*****@*****.**")
password1.send_keys(Keys.RETURN)
self.assertEqual(self.browser.current_url,
self.live_server_url + reverse("index"))
self.assertIn("Log out", self.browser.page_source)
self.assertIn("test3", self.browser.page_source)
def test_user_topic(self):
self.browser.get(self.live_server_url +
reverse("user_topics", kwargs={"pk": self.u1.id}))
self.assertIn("UID:", self.browser.page_source)
def test_user_info(self):
self.browser.get(self.live_server_url +
reverse("user_info", kwargs={"pk": self.u1.id}))
self.assertIn("Topics created by %s" % self.u1.username,
self.browser.page_source)
def test_search(self):
self.browser.get(self.live_server_url +
reverse("search", kwargs={"keyword": "test"}))
self.assertIn("Search: test", self.browser.page_source)
def test_pagination(self):
self.browser.get(self.live_server_url +
reverse("index", kwargs={"page": 2}))
self.assertIn("«", self.browser.page_source)
prev = self.browser.find_element_by_link_text("«")
prev.click()
self.assertNotIn("«", self.browser.page_source)
self.assertIn("»", self.browser.page_source)
nxt = self.browser.find_element_by_link_text("»")
nxt.click()
self.assertEqual(
self.browser.current_url,
self.live_server_url + reverse("index", kwargs={"page": 2}))
class FamilyBrowseVariantFilterTests(unittest.TestCase):
"""
Test the same recessive search with the more granular variant filters
"""
def setUp(self):
self.selenium = WebDriver()
self.live_server_url = LIVE_SERVER_URL
# login boilerplate blah
self.selenium.get(self.live_server_url + '/login')
username_input = self.selenium.find_element_by_name("username_or_email")
username_input.send_keys(ADMIN_USERNAME)
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys(ADMIN_PASSWORD)
self.selenium.find_element_by_xpath('//button[@type="submit"]').click()
# visit the family browse page
self.selenium.get(self.live_server_url + '/project/1kg/family/1/mendelian-variant-search')
# set inheritance
self.selenium.find_element_by_xpath('//li[@class="inheritance-pill-li"][@data-search_mode="all_variants"]/a').click()
def test_genes_filter(self):
self.selenium.find_element_by_xpath('//a[@href="#collapse-region"]').click()
time.sleep(.4)
genes_input = self.selenium.find_element_by_id("region-genes")
genes_input.send_keys('cdcp2\nmpv17')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("9 variants" in stats_content)
def test_region_filter(self):
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
self.selenium.find_element_by_xpath('//a[@href="#collapse-region"]').click()
time.sleep(.4)
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
genes_input = self.selenium.find_element_by_id("region-coords")
genes_input.send_keys('chr6:31000000-33000000')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("8 variants" in stats_content)
def test_region_filter_full_chr(self):
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
self.selenium.find_element_by_xpath('//a[@href="#collapse-region"]').click()
time.sleep(.4)
choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
genes_input = self.selenium.find_element_by_id("region-coords")
genes_input.send_keys('chr6')
self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
stats_content = self.selenium.find_element_by_id('variant-stats-container').text
self.assertTrue("92 variants" in stats_content)
def tearDown(self):
self.selenium.quit()
# class CohortGeneSearchTests(unittest.TestCase):
# """
# Test all the different views you can go to on the cohort browse page
# """
# def setUp(self):
#
# #self.selenium = webdriver.Chrome()
# self.selenium = WebDriver()
# self.live_server_url = 'http://*****:*****@type="submit"]').click()
#
# # visit the cohort browse page
# self.selenium.get(self.live_server_url + '/project/g1k/cohort/random_cohort/cohort-gene-search')
#
# def test_recessive_basic(self):
# self.selenium.find_element_by_xpath('//input[@name="cohort_inheritance"][@value="recessive"]').click()
# choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
# choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
#
# self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
# wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
#
# results_content = self.selenium.find_element_by_id('resultsContainer').text
# self.assertTrue("Returned 60 genes" in results_content)
#
# def test_homozygous_recessive_basic(self):
#
# self.selenium.find_element_by_xpath('//input[@name="cohort_inheritance"][@value="homozygous_recessive"]').click()
# choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
# choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
#
# self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
# wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
#
# results_content = self.selenium.find_element_by_id('resultsContainer').text
# self.assertTrue("Returned 53 genes" in results_content)
#
# def test_x_linked_recessive_basic(self):
#
# self.selenium.find_element_by_xpath('//input[@name="cohort_inheritance"][@value="x_linked_recessive"]').click()
# choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
# choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
#
# self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
# wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
#
# results_content = self.selenium.find_element_by_id('resultsContainer').text
# self.assertTrue("Returned 2 genes" in results_content)
#
# def test_compound_het_basic(self):
#
# self.selenium.find_element_by_xpath('//input[@name="cohort_inheritance"][@value="compound_het"]').click()
# choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'moderate_impact')
# choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
#
# self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
# wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
#
# results_content = self.selenium.find_element_by_id('resultsContainer').text
# self.assertTrue("Returned 6 genes" in results_content)
#
# def test_dominant_basic(self):
#
# self.selenium.find_element_by_xpath('//input[@name="cohort_inheritance"][@value="dominant"]').click()
# choose_select(self.selenium, '//select[@id="variant-presets-select"]', 'high_impact')
# choose_select(self.selenium, '//select[@id="quality-defaults-select"]', 'high_quality')
#
# self.selenium.find_element_by_xpath('//a[@id="run-search"]').click()
# wait_for_xpath(self.selenium, '//div[@id="summary-container"]')
#
# results_content = self.selenium.find_element_by_id('resultsContainer').text
# self.assertTrue("Returned 6 genes" in results_content)
def tearDown(self):
self.selenium.quit()
class TunesFunctionalTestCase(LiveServerTestCase):
@classmethod
def setUpClass(self):
self.user = User.objects.create(email="*****@*****.**")
self.user.set_password("password")
self.user.save()
self.selenium = WebDriver()
super(TunesFunctionalTestCase, self).setUpClass()
@classmethod
def tearDownClass(self):
self.selenium.quit()
super(TunesFunctionalTestCase, self).tearDownClass()
def test_login_and_add_tune_info(self):
"""
Log in to the site, find a tune by name, and add some
info about it.
"""
# Jill goes to the home page of the site and logs in
self.selenium.get(self.live_server_url)
self.selenium.find_element_by_css_selector("a#tuw-login").click()
username_input = self.selenium.find_element_by_name("username")
username_input.send_keys('*****@*****.**')
password_input = self.selenium.find_element_by_name("password")
password_input.send_keys('password')
self.selenium.find_element_by_css_selector('form#tuw-login button#tuw-submit-login').click()
# she clicks the "Tunes" nav button
self.selenium.find_element_by_css_selector('a#tuw-tunes').click()
# and then clicks "Add a New Tune"
self.selenium.find_element_by_css_selector('a#tuw-new-tune').click()
# she searches for the word "Night"
search_form = self.selenium.find_element_by_name("search")
search_form.send_keys("Night")
self.selenium.find_element_by_css_selector('form#tuw-login input#tuw-submit-search')
# and sees a few options
# "The Night Has a Thousand Eyes"
# "Night in Tunisia"
# "Night Train"
# She selects "Night Train, and since we already have some info
# about this tune in the database, she sees and partially
# filled form
# She adds what data she can about "Night Train" and
# saves the form
# She wants to add another tune to the database, so she clicks
# "Edit Another Tune"
# She searches for the word "Mood"
# and sees a few options
# "Mood Indigo"
# "In a Sentimental Mood"
# She selects "In a Sentimental Mood", and since there's no
# info in the database about this tune yet, she see's a
# completely empty form
# She enters all the information she knows about this tune in
# in the form and clicks save.
# When shes's done, she goes to the home page to the home page
# and sees the newly added tunes
self.fail("FINISH THE TEST")
class OfferTest (LiveServerTestCase):
def setUp(self):
self.name_professor = 'teste'
self.create_timePeriod_and_course()
self.create_professor_and_schedule()
self.browser = WebDriver()
create_user_and_login(self.browser, self.live_server_url,'john','johnpassword','*****@*****.**')
self.browser.implicitly_wait(40)
def tearDown(self):
cursor = MySQLConnection()
[offer.delete() for offer in Offer.find()]
[schedule.delete() for schedule in Schedule.find()]
cursor.execute('DELETE FROM minitableDayOfTheWeek')
[timePeriod.delete() for timePeriod in TimePeriod.find()]
[course.delete() for course in Course.find()]
[professor.delete() for professor in Professor.find()]
self.browser.quit()
def create_timePeriod_and_course(self):
cursor = MySQLConnection()
length = cursor.execute('SELECT idLength FROM minitableLength where length="Semestral"')
if not length:
cursor.execute('INSERT INTO minitableLength (length) values ("Semestral")')
self.course = Course('tst9999', 'teste9999', '0000-00-00')
self.course.store()
length = cursor.execute('SELECT idLength FROM minitableLength where length="Semestral"')
self.timePeriod = TimePeriod(1, 2014, 1)
self.timePeriod.store()
def create_professor_and_schedule(self):
cursor = MySQLConnection()
cursor.execute('INSERT INTO `minitableDayOfTheWeek` (dayOfTheWeek) VALUES ("Domingo"), ("Segunda"), ("Terça"), ("Quarta"), ("Quinta"), ("Sexta"), ("Sabado")')
self.schedule = Schedule('Domingo', '14:00:00', 'weekly', '12:00:00')
self.schedule.store()
self.schedule = Schedule('Segunda', '19:00:00', 'weekly', '16:00:00')
self.schedule.store()
self.schedule = Schedule('Quarta', '16:00:00', 'weekly', '14:00:00')
self.schedule.store()
self.professor = Professor('Professor Teste')
self.professor.store()
self.second_professor = Professor('Professor Teste2')
self.second_professor.store()
def login_to_offer_page(self):
open_page(self.browser, '/interface/', self.live_server_url)
dropdown_timePeriod = self.browser.find_element_by_id('id_dropDownTimePeriod')
dropdown_course = self.browser.find_element_by_id('id_dropDownCourse')
select_timePeriod = Select(dropdown_timePeriod)
select_timePeriod.select_by_value(str(self.timePeriod.idTimePeriod))
select_course = Select(dropdown_course)
select_course.select_by_value(str(self.course.idCourse))
professor_interface = self.browser.find_element_by_link_text('Offer')
professor_interface.click()
self.assertIn('Interface - Offer', self.browser.title)
def test_create_offer(self):
self.login_to_offer_page()
button_create_offer = self.browser.find_element_by_name('criar')
button_create_offer.click()
self.assertIn('Interface - Offer Create', self.browser.title)
dropdown_professor = self.browser.find_element_by_id('id_dropDownProfessor')
select_professor = Select(dropdown_professor)
select_professor.select_by_value(str(self.professor.idProfessor))
input_classNumber = self.browser.find_element_by_id('id_classNumber')
input_classNumber.send_keys('1')
dropdown_practical = self.browser.find_element_by_id('id_dropDownTeoricaPratica')
select_practical = Select(dropdown_practical)
select_practical.select_by_value('1')
input_numberOfRegistrations = self.browser.find_element_by_id('id_numberOfRegistrations')
input_numberOfRegistrations.send_keys('10')
self.browser.find_element_by_id("id_listSchedules_0").click()
self.browser.find_element_by_id("id_listSchedules_1").click()
self.browser.find_element_by_id("id_listSchedules_2").click()
button_store = self.browser.find_element_by_name('Cadastrar')
button_store.click()
self.assertIn('Interface - Offer Detail', self.browser.title)
id_courseCode = self.browser.find_element_by_id('courseCode')
self.assertEqual(id_courseCode.text, 'tst9999')
id_name = self.browser.find_element_by_id('name')
self.assertEqual(id_name.text, 'teste9999')
id_professor_name = self.browser.find_element_by_id('professor_name')
self.assertEqual(id_professor_name.text, 'Professor Teste')
id_timePeriod = self.browser.find_element_by_id('timePeriod')
self.assertEqual(id_timePeriod.text, 'Primeiro semestre de 2014')
id_classNumber = self.browser.find_element_by_id('classNumber')
self.assertEqual(id_classNumber.text, 'T01')
id_practical = self.browser.find_element_by_id('practical')
self.assertEqual(id_practical.text, "TEORICA")
id_numberOfRegistrations = self.browser.find_element_by_id('numberOfRegistrations')
self.assertEqual(id_numberOfRegistrations.text, '10')
id_schedules = self.browser.find_element_by_id('schedules')
self.assertIn("Domingo 12:00 - 14:00", id_schedules.text)
self.assertIn("Segunda 16:00 - 19:00", id_schedules.text)
self.assertIn("Quarta 14:00 - 16:00", id_schedules.text)
def test_edit_offer(self):
timePeriod = TimePeriod.find()[0]
course = Course.find()[0]
first_professor = Professor.find()[0]
schedules = Schedule.find()
offer = Offer(timePeriod, course, 10, 0, first_professor)
offer.setNumberOfRegistrations(10)
offer.setSchedules(schedules)
offer.store()
open_page(self.browser, '/interface/offer/' + str(offer.idOffer), self.live_server_url)
self.assertIn('Interface - Offer Detail', self.browser.title)
button_edit = self.browser.find_element_by_name('editar')
button_edit.click()
self.assertIn('Interface - Offer Edit', self.browser.title)
dropdown_professor = self.browser.find_element_by_id('id_dropDownProfessor')
select_professor = Select(dropdown_professor)
select_professor.select_by_value(str(self.second_professor.idProfessor))
input_classNumber = self.browser.find_element_by_id('id_classNumber')
input_classNumber.send_keys('1')
dropdown_practical = self.browser.find_element_by_id('id_dropDownTeoricaPratica')
select_practical = Select(dropdown_practical)
select_practical.select_by_value('1')
input_numberOfRegistrations = self.browser.find_element_by_id('id_numberOfRegistrations')
input_numberOfRegistrations.send_keys('1')
self.browser.find_element_by_id("id_listSchedules_1").click()
self.browser.find_element_by_id("id_listSchedules_2").click()
button_apply = self.browser.find_element_by_name('Aplicar')
button_apply.click()
self.assertIn('Interface - Offer Detail', self.browser.title)
id_courseCode = self.browser.find_element_by_id('courseCode')
self.assertEqual(id_courseCode.text, 'tst9999')
id_name = self.browser.find_element_by_id('name')
self.assertEqual(id_name.text, 'teste9999')
id_professor_name = self.browser.find_element_by_id('professor_name')
self.assertEqual(id_professor_name.text, 'Professor Teste2')
id_timePeriod = self.browser.find_element_by_id('timePeriod')
self.assertEqual(id_timePeriod.text, 'Primeiro semestre de 2014')
id_classNumber = self.browser.find_element_by_id('classNumber')
self.assertEqual(id_classNumber.text, 'T101')
id_practical = self.browser.find_element_by_id('practical')
self.assertEqual(id_practical.text, "PRATICA")
id_numberOfRegistrations = self.browser.find_element_by_id('numberOfRegistrations')
self.assertEqual(id_numberOfRegistrations.text, '101')
id_schedules = self.browser.find_element_by_id('schedules')
self.assertIn("Domingo 12:00 - 14:00", id_schedules.text)
self.assertNotIn("Segunda 16:00 - 19:00", id_schedules.text)
self.assertNotIn("Quarta 14:00 - 16:00", id_schedules.text)
def test_delete_offer(self):
timePeriod = TimePeriod.find()[0]
course = Course.find()[0]
first_professor = Professor.find()[0]
schedules = Schedule.find()
offer = Offer(timePeriod, course, 10, 0, first_professor)
offer.setNumberOfRegistrations(10)
offer.setSchedules(schedules)
offer.store()
open_page(self.browser, '/interface/offer/' + str(offer.idOffer), self.live_server_url)
self.assertIn('Interface - Offer Detail', self.browser.title)
button_delete = self.browser.find_element_by_name('deletar')
button_delete.click()
alert = self.browser.switch_to.alert
alert.accept()
self.assertIn('Interface', self.browser.title)
open_page(self.browser, '/interface/offer/' + str(offer.idOffer), self.live_server_url)
self.assertNotIn('Interface - Offer Detail', self.browser.title)
