def handle(self, *args, **options):
xvfb = Xvfb(width=1600, height=720)
xvfb.start()
browser = WebDriver()
browser.get(settings.DOMAIN)
sleep(1)
browser.find_element_by_css_selector("#disclaimer button").click()
sleep(0.7)
browser.find_elements_by_css_selector(".officer .checkmark")[4].click()
sleep(2)
browser.find_element_by_css_selector(
".complaint-row .col-md-3").click()
sleep(1)
content = browser.get_screenshot_as_png()
now = datetime.datetime.now().strftime("%Y-%m-%d %H-%M-%S")
file_name = "{now}.png".format(now=now)
file_path = os.path.join(settings.BASE_DIR, 'static', file_name)
with open(file_path, "wb") as f:
f.write(content)
browser.quit()
email = EmailMessage(subject='CPDB Homepage screenshot %s' % now,
body='FYI',
to=['*****@*****.**'])
email.attach_file(file_path)
email.send()
xvfb.stop()
def get_fail_tests(url):
"""
"""
browser = Firefox()
browser.get(url)
# get new failures
tests = [e.text.strip() for e in
browser.find_elements_by_css_selector(
"#new-failed-tests .test-name")]
# get existing tests
tests = tests + [e.text.strip() for e in
browser.find_elements_by_css_selector(
"#existing-failed-tests .test-name")]
browser.quit()
return tests
def get_fail_tests(url):
"""
"""
browser = Firefox()
browser.get(url)
# get new failures
tests = [
e.text.strip() for e in browser.find_elements_by_css_selector(
"#new-failed-tests .test-name")
]
# get existing tests
tests = tests + [
e.text.strip() for e in browser.find_elements_by_css_selector(
"#existing-failed-tests .test-name")
]
browser.quit()
return tests
class Fox(object):
'''
Fox is an abstraction around Selenium web testing
'''
def __init__(self):
try:
self.fox = WebDriver()
except:
print "No web server detected; skipping web tests"
self.fox = None
def login(self, page='/login', name='josh', password='******', t=5):
self.get(page)
WebDriverWait(self.fox, t).until(EC.element_to_be_clickable((By.CSS_SELECTOR, '[name=username]'))).send_keys(name)
WebDriverWait(self.fox, t).until(EC.element_to_be_clickable((By.CSS_SELECTOR, '[name=password]'))).send_keys(password)
WebDriverWait(self.fox, t).until(EC.element_to_be_clickable((By.CSS_SELECTOR, 'input'))).click()
def get(self, i):
return self.fox.get(i)
def click(self, css, t=5):
return WebDriverWait(self.fox, t).until(EC.element_to_be_clickable((By.CSS_SELECTOR, css))).click()
def clickx(self, xpath, t=5):
return WebDriverWait(self.fox, t).until(EC.element_to_be_clickable((By.XPATH, xpath))).click()
def click_last(self, css):
e = self.fox.find_elements_by_css_selector('.modal-open .btn-primary')[-1]
return e.click()
def val(self, css, val, t=5):
return WebDriverWait(self.fox, t).until(EC.element_to_be_clickable((By.CSS_SELECTOR, css))).send_keys(val)
def fill(self, form, field, value):
css = '#{} [name={}]'.format(form, field)
return self.val(css, value)
def form(self, form, values):
for k, v in values:
self.fill(form, k, v)
def wait_for_destroy(self, css, t=5):
element = self.fox.find_element_by_css_selector(css)
return WebDriverWait(self.fox, t).until(EC.staleness_of(element))
def close(self):
if not self.fox:
return
self.fox.quit()
driver.find_element_by_xpath(".//*[@id='btnSubmit']").click()
a=driver.find_element_by_xpath(".//*[@id='contentTable']/tbody/tr[2]/td[8]")
print(a.text)
driver.find_element_by_xpath(".//*[@id='main-sidebar']/section/ul/li[4]/a/span").click()
driver.switch_to_frame('mainFrame')
'''
driver.find_element_by_xpath(
".//*[@id='main-sidebar']/section/ul/li[4]/a/span").click()
driver.switch_to_frame('mainFrame')
WebDriverWait(driver, 10, 1).until(
lambda x: x.find_element_by_xpath("html/body/div[1]/ul/li[3]/a")).click()
a = WebDriverWait(driver, 10, 1).until(lambda x: x.find_element_by_xpath(
".//*[@id='inputForm']/div[2]/div/span/span[1]/span/span[2]"))
a.click()
driver.find_elements_by_css_selector('[role="treeitem"]')[9].click()
driver.find_element_by_xpath(
".//*[@id='inputForm']/div[3]/div/span/span[1]/span/span[2]").click()
driver.find_elements_by_css_selector('[role="treeitem"]')[6].click()
driver.find_element_by_id('tel').send_keys('15123532346')
driver.find_element_by_id('carNo').send_keys('川A56LB7')
driver.find_element_by_id('btnSubmit').click()
a = WebDriverWait(driver, 10, 1).until(lambda x: x.find_element_by_xpath(
".//*[@id='searchForm']/div[1]/div[2]/div/div/span/span[1]/span/span[2]"))
print('1111111111')
a.click()
driver.find_elements_by_css_selector('[role="treeitem"]')[9].click()
time.sleep(2)
driver.find_element_by_xpath(
".//*[@id='searchForm']/div[1]/div[3]/div/div/span/span[1]/span/span[2]"
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 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 LiveServerTest(object):
fixtures = ['rules.json']
DOWNLOAD_DIRECTORY = '/tmp/work/downloads'
## List all ajax enabled pages that have initialization code and must wait
AJAX_WAIT = ['mock_galaxy_factory', 'view_job']
SUMMARY_INDEX = str(len(MODULE_INDICES)+1)
OUTPUT_FORMATS = [
{'value':'csv', 'text':'CSV (Text)', 'extension':'csv'},
{'value':'hdf5', 'text':'HDF5', 'extension':'hdf5'},
{'value': 'fits', 'text': 'FITS', 'extension': 'fits'},
{'value': 'votable', 'text': 'VOTable', 'extension': 'xml'}
]
def wait(self, secs=1):
time.sleep(secs * 1.0)
def setUp(self):
from selenium.webdriver.firefox.webdriver import FirefoxProfile
fp = FirefoxProfile()
fp.set_preference("browser.download.folderList", 2)
fp.set_preference("browser.download.dir", self.DOWNLOAD_DIRECTORY)
fp.set_preference("browser.helperApps.neverAsk.saveToDisk", "text/html, application/zip, text/plain, application/force-download, application/x-tar")
self.selenium = WebDriver(firefox_profile=fp)
self.selenium.implicitly_wait(1) # wait one second before failing to find
# create the download dir
if not os.path.exists(self.DOWNLOAD_DIRECTORY):
os.makedirs(self.DOWNLOAD_DIRECTORY)
def tearDown(self):
self.selenium.quit()
# remove the download dir
for root, dirs, files in os.walk(self.DOWNLOAD_DIRECTORY, topdown=False):
for name in files:
os.remove(os.path.join(root, name))
for name in dirs:
os.rmdir(os.path.join(root, name))
def lc_id(self, bare_field):
return '#id_light_cone-%s' % bare_field
def lc_2select(self, bare_field):
return 'id_light_cone-output_properties_%s' % bare_field
def rf_id(self, bare_field):
return '#id_record_filter-%s' % bare_field
def sed(self, bare_field):
return 'id_sed-%s' % bare_field
def mi_id(self, bare_field):
return 'id_mock_image-%s' % bare_field
def sed_id(self, bare_field):
return '#%s' % self.sed(bare_field)
def sed_2select(self, bare_field):
return 'id_sed-band_pass_filters_%s' % bare_field
def job_select(self, bare_field):
return 'id-job_%s' % bare_field
def job_id(self, bare_field):
return '#%s' % self.job_select(bare_field)
def get_parent_element(self, element):
return self.selenium.execute_script('return arguments[0].parentNode;', element)
def get_element_css_classes(self, element):
list = []
found = element.get_attribute('class')
if found is not None: list = found.split()
return list
def get_closest_by_class(self, element, css_class):
while css_class not in self.get_element_css_classes(element):
element = self.get_parent_element(element)
return element
def get_summary_selector(self, form_name, field_name):
return 'div.summary_%s .%s' % (form_name, field_name)
def get_summary_field(self, form_name, field_name):
summary_selector = self.get_summary_selector(form_name, field_name)
return self.selenium.find_element_by_css_selector(summary_selector)
def get_summary_field_text(self, form_name, field_name):
return self.get_summary_field(form_name, field_name).text
def get_info_field(self, section, field):
elem = self.selenium.find_element_by_css_selector("div.%(section)s-info .%(field)s" % {'section': section, 'field': field})
return elem.text
def find_element_by_css_selector(self, selector):
retries = 3
while retries > 0:
try:
elem = self.selenium.find_element_by_css_selector(selector)
return elem
except NoSuchElementException:
retries -= 1
self.wait(1)
# If it hasn't been found by now, try one more time and let the exception through
return self.selenium.find_element_by_css_selector(selector)
def find_element_by_id(self, elem_id):
retries = 3
while retries > 0:
try:
elem = self.selenium.find_element_by_id(elem_id)
return elem
except NoSuchElementException:
retries -= 1
self.wait(1)
# If it hasn't been found by now, try one more time and let the exception through
return self.selenium.find_element_by_id(elem_id)
def assert_email_body_contains(self, email, text):
pattern = re.escape(text)
matches = re.search(pattern, email.body)
self.assertTrue(matches, "Email does not contain " + text)
def get_page_source(self):
try:
return self.selenium.page_source
except:
while True:
self.wait(0.2)
try:
self.selenium.switch_to_alert().accept()
except:
return self.selenium.page_source
def assertTrue(self, value, msg):
if not value:
raise AssertionError(msg)
return
def assertEqual(self, vala, valb):
if vala != valb:
msg = 'FAIL: "{0}" != "{1}"'.format(vala, valb)
raise AssertionError(msg)
return
def assert_page_has_content(self, string):
page_source = self.get_page_source()
pattern = re.escape(string)
self.assertTrue((string in page_source) or re.search(pattern, page_source), "page source did not contain %s" % pattern)
def assert_page_does_not_contain(self, string):
page_source = self.get_page_source()
pattern = re.escape(string)
self.assertFalse(re.search(pattern, page_source), "page source contained %s" % pattern)
def assert_element_text_equals(self, selector, expected_value):
text = self.find_visible_element(selector).text.strip()
self.assertEqual(expected_value.strip(), text.strip())
def assert_element_value_equals(self, selector, expected_value):
text = self.find_visible_element(selector).get_attribute('value')
self.assertEqual(expected_value.strip(), text.strip())
def assert_selector_texts_equals_expected_values(self, selector_value):
# selector_value is a dict of selectors to expected text values
for selector, expected_value in selector_value.items():
self.assert_element_text_equals(selector, unicode(expected_value))
def assert_attribute_equals(self, attribute, selector_values):
# selector_values is a dict of selectors to attribute values
for selector, expected_value in selector_values.items():
element = self.find_visible_element(selector)
actual_value = element.get_attribute(attribute)
self.assertEqual(expected_value, actual_value)
def assert_is_checked(self, selector):
field = self.selenium.find_element_by_css_selector(selector)
self.assertEqual('true', field.get_attribute('checked'))
def assert_is_unchecked(self, selector):
field = self.selenium.find_element_by_css_selector(selector)
self.assertIsNone(field.get_attribute('checked'))
def assert_is_enabled(self, selector):
field = self.selenium.find_element_by_css_selector(selector)
self.assertIsNone(field.get_attribute('disabled'))
def assert_is_disabled(self, selector):
field = self.selenium.find_element_by_css_selector(selector)
self.assertEqual('true', field.get_attribute('disabled'))
def assert_are_displayed(self, name):
fields = self.selenium.find_elements_by_name(name)
self.assertTrue([field.is_displayed() for field in fields])
def assert_are_displayed_by_class_name(self, name):
fields = self.selenium.find_elements_by_class_name(name)
self.assertTrue([field.is_displayed() for field in fields])
def assert_are_not_displayed(self, name):
fields = self.selenium.find_elements_by_name(name)
self.assertFalse(all([field.is_displayed() for field in fields]))
def assert_is_displayed(self, selector):
field = self.selenium.find_element_by_css_selector(selector)
self.assertTrue(field.is_displayed())
def assert_not_displayed(self, selector):
field = self.selenium.find_element_by_css_selector(selector)
self.assertFalse(field.is_displayed())
def assert_not_in_page(self, selector):
"Assert that the supplied selector is not part of the page content"
elements = self.selenium.find_elements_by_css_selector(selector)
self.assertTrue(len(elements) == 0)
def assert_on_page(self, url_name, ignore_query_string=False):
retries = 30
while retries > 0:
try:
self._assert_on_page(url_name, ignore_query_string)
return
except AssertionError:
retries -= 1
print "assert_on_page: retry"
self.wait(1)
self._assert_on_page(url_name, ignore_query_string)
def _assert_on_page(self, url_name, ignore_query_string=False):
if not ignore_query_string:
self.assertEqual(self.selenium.current_url, self.get_full_url(url_name))
else:
split_url = self.selenium.current_url.split('?')
url = split_url[0]
self.assertEqual(url, self.get_full_url(url_name))
def assert_multi_selected_text_equals(self, id_of_select, expected):
actual = self.get_multi_selected_option_text(id_of_select)
remaining = []
for value in expected:
if value not in actual:
remaining.append(value)
else:
actual.remove(value)
self.assertTrue(not actual and not remaining)
def assert_summary_field_correctly_shown(self, expected_value, form_name, field_name):
value_displayed = self.get_summary_field_text(form_name, field_name)
self.assertEqual(expected_value, strip_tags(value_displayed))
def fill_in_fields(self, field_data, id_wrap=None, clear=False):
for selector, text_to_input in field_data.items():
if id_wrap:
selector = id_wrap(selector)
elem = self.selenium.find_element_by_css_selector(selector)
if elem.tag_name == 'select':
self.select(selector, str(text_to_input))
else:
if clear:
elem.clear()
elem.send_keys(str(text_to_input))
self.wait(0.5)
def clear(self, selector):
elem = self.selenium.find_element_by_css_selector(selector)
elem.clear()
def click(self, elem_id):
elem = self.find_element_by_id(elem_id)
elem.click()
self.wait(0.5)
def click_by_css(self, element_css):
elem = self.selenium.find_element_by_css_selector(element_css)
elem.click()
self.wait(0.5)
def click_by_class_name(self, class_name):
elem = self.selenium.find_element_by_class_name(class_name)
elem.click()
self.wait(0.5)
def login(self, username, password):
self.visit('accounts/login')
username_input = self.selenium.find_element_by_id('id_username')
password_input = self.selenium.find_element_by_id('id_password')
submit_button = self.selenium.find_element_by_tag_name('button') # TODO make this more specific
username_input.send_keys(username)
password_input.send_keys(password)
submit_button.submit()
def visit(self, url_name, *args, **kwargs):
""" self.visit(name_of_url_as_defined_in_your_urlconf) """
self.selenium.get(self.get_full_url(url_name, *args, **kwargs))
if url_name in LiveServerTest.AJAX_WAIT:
self.wait(2)
self.assertTrue(self.selenium.execute_script('return (window.catalogue !== undefined ? catalogue._loaded : true)'),
'catalogue.js loading error')
def get_actual_filter_options(self):
option_selector = '%s option' % self.rf_id('filter')
return [x.get_attribute('value').encode('ascii') for x in self.selenium.find_elements_by_css_selector(option_selector)]
def get_expected_filter_options(self, data_set):
def gen_bp_pairs(objs):
for obj in objs:
yield ('B-' + str(obj.id) + '_apparent')
yield ('B-' + str(obj.id) + '_absolute')
normal_parameters = datasets.filter_choices(data_set.simulation.id, data_set.galaxy_model.id)
bandpass_parameters = datasets.band_pass_filters_objects()
return ['D-' + str(x.id) for x in normal_parameters] + [pair for pair in gen_bp_pairs(bandpass_parameters)]
def get_actual_snapshot_options(self):
option_selector = '%s option' % self.lc_id('snapshot')
return [x.get_attribute("innerHTML") for x in self.selenium.find_elements_by_css_selector(option_selector)]
def get_expected_snapshot_options(self, snapshots):
return [str("%.5g" % snapshot.redshift) for snapshot in snapshots]
def get_full_url(self, url_name, *args, **kwargs):
return "%s%s" % (self.job_params.BASE_URL, url_name)
def get_selected_option_text(self, id_of_select):
select = self.selenium.find_element_by_css_selector(id_of_select)
options = select.find_elements_by_css_selector('option')
selected_option = None
for option in options:
if option.get_attribute('selected'):
selected_option = option
return selected_option.text
def get_multi_selected_option_text(self, id_of_select):
select = self.selenium.find_element_by_css_selector(id_of_select)
options = select.find_elements_by_css_selector('option')
return [option.text for option in options]
def get_selector_value(self, selector):
return self.selenium.find_element_by_css_selector(selector).get_attribute('value')
def select(self, selector, value):
from selenium.webdriver.support.ui import Select
elem = self.selenium.find_element_by_css_selector(selector)
select = Select(elem)
select.select_by_visible_text(value)
def find_visible_elements(self, css_selector):
elements = self.selenium.find_elements_by_css_selector(css_selector)
return [elem for elem in elements if elem.is_displayed()]
def find_visible_element(self, css_selector):
elements = self.find_visible_elements(css_selector)
num_elements = len(elements)
if num_elements != 1:
raise Exception("Found %s elements for selector %s" % (num_elements, css_selector))
return elements[0]
def select_dark_matter_simulation(self, simulation):
self.select(self.lc_id('dark_matter_simulation'), simulation.name)
self.wait(0.5)
def select_galaxy_model(self, galaxy_model):
self.select(self.lc_id('galaxy_model'), galaxy_model.name)
self.wait(0.5)
def select_stellar_model(self, stellar_model):
self.select(self.sed_id('single_stellar_population_model'), stellar_model.label)
self.wait(0.5)
def select_record_filter(self, filter, extension=None):
text = ''
if isinstance(filter, DataSetProperty):
units_str = ''
if filter.units is not None and len(filter.units) > 0:
units_str = ' (' + filter.units + ')'
text = filter.label + units_str
elif isinstance(filter, BandPassFilter):
text = filter.label
if extension is not None:
text += ' (' + extension.capitalize() + ')'
else:
raise TypeError("Unknown filter type")
self.select(self.rf_id('filter'), text)
#a function to make a list of list of text inside the table
def table_as_text_rows(self, selector):
table = self.selenium.find_element_by_css_selector(selector)
rows = table.find_elements_by_css_selector('tr')
cells = [[cell.text for cell in row.find_elements_by_css_selector('th, td')] for row in rows]
return cells
def submit_support_form(self):
submit_button = self.selenium.find_element_by_css_selector('button[type="submit"]')
submit_button.submit()
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 BrowserTestCase(StaticLiveServerTestCase):
""" These tests take longer to run than other tests because they pop up a browser window, a headless one in
linux/x-window supporting system, real firefox in others. Instead of launching a new firefox for each test, I have
modified this to use only one instance and just reload pages -- browser is set up in *setUpClass*, not in setUp.
When we have login cookies etc., those tests better run in 'clean' browser, but here reusing the browser
doesn't seem to cause problems.
"""
vdisplay = None
selenium = None
fixtures = [
'organizations', 'persons_browser_testing', 'projects_browser_testing',
'project_templates'
]
@classmethod
def setUpClass(cls):
StaticLiveServerTestCase.setUpClass()
if USE_XVFB:
# Start xvfb for Firefox
cls.vdisplay = Display(visible=0, size=(1024, 768))
cls.vdisplay.start()
def setUp(self):
StaticLiveServerTestCase.setUp(self)
profile = FirefoxProfile()
# Browser itself attempts to validate form fields before they are sent to django.
# Fields where input type="Number" accept "100.0" when locale is "en" and "100,0" when locale is "fi", and when
# they reject the value, django sees an empty value instead.
# To prevent this causing more problems, force browser used by tests to use same locale as django, typically
# "en".
# We may want to occassionally test with other locales, so localize_input, number_format etc. when entering
# and reading decimals/floats.
profile.set_preference("intl.accept_languages", get_language())
profile.set_preference("general.useragent.locale", get_language())
self.selenium = Firefox(
firefox_profile=profile,
executable_path='node_modules/geckodriver/geckodriver')
self.selenium.maximize_window()
@classmethod
def tearDownClass(cls):
if USE_XVFB:
cls.vdisplay.stop()
StaticLiveServerTestCase.tearDownClass()
def tearDown(self):
self.selenium.quit()
StaticLiveServerTestCase.tearDown(self)
# Helper methods for this test case:
def open(self, url):
self.selenium.get("%s%s" % (self.live_server_url, url))
def find(self, element_id):
return self.selenium.find_element_by_id(element_id)
def find_css(self, css_selector):
elems = self.selenium.find_elements_by_css_selector(css_selector)
found = len(elems)
if found == 1:
return elems[0]
elif not elems:
raise NoSuchElementException(css_selector)
return elems
def assert_wait(self, until, timeout_msg):
good = False
try:
WebDriverWait(self.selenium, WAIT).until(until)
good = True
except TimeoutException:
pass
self.assertTrue(good, timeout_msg)
def assert_that_css_appears(self, css_selector):
self.assert_wait(lambda _: self.find_css(css_selector),
"CSS selector '%s' failed to appear." % css_selector)
def assert_that_element_appears(self, element_id):
self.assert_wait(EC.visibility_of_element_located((By.ID, element_id)),
"Element with id '%s' failed to appear." % element_id)
def assert_that_element_disappears(self, element_id):
self.assert_wait(
EC.invisibility_of_element_located((By.ID, element_id)),
"Element with id '%s' is still there." % element_id)
def assert_that_text_appears(self, css_selector, text):
self.assert_wait(
EC.text_to_be_present_in_element((By.CSS_SELECTOR, css_selector),
text),
"Text '%s' failed to appear in '%s'." % (text, css_selector))
def assert_wait_that_element_clickable(self, element_id):
self.assert_wait(EC.element_to_be_clickable((By.ID, element_id)),
"{} failed to become clickable".format(element_id))
# Actual tests
def test_add_organization_add_project(self):
"""Add new organization and new project under that organization"""
# Add person that will act as project manager later
project_project_manager = Person.objects.get(pk=2)
self.open(reverse('admin_tools'))
organization_name = 'Great organization'
org_input = self.find('orgName')
org_input.send_keys(organization_name)
self.find('org-form').submit()
# Wait for modal to open
self.assert_that_css_appears('#conf-modal-body')
# Reload organizations in "Add project" modal
self.open(reverse('admin_tools'))
# Fill in "Add project" form on Admin tools page and submit it
time.sleep(1)
project_name = "Great project"
self.find('id_name').send_keys(project_name)
Select(self.find('id_organization')).select_by_value(organization_name)
self.find('pre-add-project-form').submit()
# Wait for add project page to open up
self.assert_that_element_appears('id_add_project_form-name')
# Wait for javascript to populate fields
time.sleep(1)
organization = Organization.objects.get(pk=organization_name)
# Fill in the details of new project and hit submit
budget_field, end_date_field, project_manager_field, *foo = organization.templates.all(
)[0].dimensions.all()
project_budget = 135151.0
project_end_date = datetime.datetime(2015,
8,
1,
tzinfo=get_current_timezone())
date_in = project_end_date.strftime("%d/%m/%Y")
self.find('id_{}_form-value'.format(budget_field.id)).send_keys(
localize_input(project_budget))
self.find('id_{}_form-value'.format(
end_date_field.id)).send_keys(date_in)
project_manager_input = self.find('id_{}_form-value'.format(
project_manager_field.id))
Select(project_manager_input).select_by_value(
str(project_project_manager.id))
self.find('add-project-form').submit()
# Wait until user is redirected to "Show project" page and check that page contains
# correct information
self.assert_that_element_appears('project-dimension-panels')
self.assertEquals(project_name, self.find('project-name').text)
# TODO: Add search for panel with owningorganization
# self.assertEquals(organization_name, self.find('projectparent').text)
end_date = project_end_date.strftime("%d/%m/%Y %H:%M")
self.assertEquals(end_date, self.find('EndDate').text)
self.assertEquals(str(project_project_manager),
self.find('ProjectManager').text)
budget = number_format(project_budget, decimal_pos=2)
self.assertEquals(budget, self.find('Budget').text)
def test_add_project_from_admin_tools(self):
"""Add project from admin tools"""
self.open(reverse('admin_tools'))
self._test_add_project()
def test_add_project_from_homepage(self):
"""Add project from homepage"""
self.open(reverse('homepage'))
self.find('add-project-btn').click()
# Wait until pre add project form is loaded
self.assert_that_element_appears('id_name')
self._test_add_project()
def _test_add_project(self):
project_name = "FooBar"
organization = Organization.objects.get(pk=1)
# Fill in details of new project and click "Continue"
self.find('id_name').send_keys(project_name)
Select(self.find('id_organization')).select_by_value(organization.pk)
self.find('pre-add-project-form').submit()
# Wait for "Add project" page to load
self.assert_that_element_appears('id_add_project_form-name')
# Check that project name and organization are propertly transmitted from pre add project form
self.assertEquals(
project_name,
self.find('id_add_project_form-name').get_attribute('value'))
self.assertEquals(
organization.pk,
self.find('id_add_project_form-organization').get_attribute(
'value'))
# Fill in the detail of new project and submit
phase_field, budget_field, *foo = organization.templates.all(
)[0].dimensions.all()
project_phase = "Adding-Project"
project_budget = 135151.0
self.find('id_{}_form-value'.format(
phase_field.id)).send_keys(project_phase)
self.find('id_{}_form-value'.format(budget_field.id)).send_keys(
localize_input(project_budget))
self.find('add-project-form').submit()
# Wait for "Show project" to load
self.assert_that_element_appears('project-dimension-panels')
# Check that "Show project" page contains correct information
self.assertEquals(project_name, self.find('project-name').text)
# TODO: Add search for panel with owningorganization
# self.assertEquals(organization_name, self.find('projectparent').text)
self.assertEquals(project_phase, self.find('Phase').text)
budget = number_format(project_budget, decimal_pos=2)
self.assertEquals(budget, self.find('Budget').text)
# Check that correct information is loaded to db
project = Project.objects.get(name=project_name)
self.assertIsInstance(project, Project)
self.assertEquals(organization, project.parent)
phase_dim, budget_dim, *leftovers = project.dimensions.all()
self.assertFalse(leftovers)
self.assertIsInstance(phase_dim.dimension_object, TextDimension)
self.assertIsInstance(budget_dim.dimension_object, NumberDimension)
self.assertEquals(Decimal(project_budget),
budget_dim.dimension_object.value)
self.assertEquals(project_phase, phase_dim.dimension_object.value)
def _test_modify_project_dimension(self, dimension_name, field_type,
new_value, cmp_value):
self.open(reverse('show_project', args=(1, )))
# Click the "Modify" button of the dimension
self.find('{}-modifybtn'.format(dimension_name)).click()
# Wait for modal to open up
self.assert_that_element_appears('{}-value'.format(field_type))
self.assert_that_element_appears('modify-{}-modal'.format(field_type))
# Update form value and submit
elem = self.find('{}-value'.format(field_type))
time.sleep(1)
elem.send_keys(new_value)
elem.send_keys(Keys.RETURN)
self.find_css('#modify-{}-form button[type="submit"]'.format(
field_type)).click()
# Wait for modal to close
self.assert_that_element_disappears('{}-value'.format(field_type))
self.assert_that_element_disappears(
'modify-{}-modal'.format(field_type))
# Refresh the page
self.open(reverse('show_project', args=(1, )))
# Check that dimension value was updated
self.assertEquals(cmp_value, self.find(dimension_name).text)
def test_modify_project_text_dimension(self):
"""Modifying Phase field from show_project"""
self._test_modify_project_dimension('Phase', 'text', 'Done', 'Done')
def test_modify_project_number_dimension(self):
"""Modifying Budget field from show_project"""
result = number_format(38.00, decimal_pos=2)
self._test_modify_project_dimension('Budget', 'number',
localize_input(38.00), result)
def test_modify_project_date_dimension(self):
"""Modifying End date from show_project"""
project_end_date = datetime.datetime(2015,
9,
1,
tzinfo=get_current_timezone())
date_in = project_end_date.strftime("%d/%m/%Y")
result = project_end_date.strftime("%d/%m/%Y %H:%M")
self._test_modify_project_dimension('EndDate', 'date', date_in, result)
def test_modify_project_associated_person_dimension(self):
"""Change ProjectManager"""
self.open(reverse('show_project', args=(1, )))
# Click "Modify" button of ProjectManager dimension
self.find('ProjectManager-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('associatedperson-value')
self.assert_that_element_appears('modify-associatedperson-modal')
# Select another person from dropdown and submit the form
Select(self.find('associatedperson-value')).select_by_value('2')
self.find_css(
'#modify-associatedperson-form button[type="submit"]').click()
#Wait for modal to close
self.assert_that_element_disappears('modify-associatedperson-modal')
# Refresh the page
self.open(reverse('show_project', args=(1, )))
# Check that dimension value is updated
self.assertEquals(str(Person.objects.get(id=2)),
self.find('ProjectManager').text)
def test_modify_project_associated_persons_dimension_remove(self):
"""Remove a Member"""
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Members dimension
self.find('Members-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('modify-associatedpersons-modal')
self.assert_that_element_appears('associatedpersons-value')
# Click to remove the only associated person
self.find_css(
'#multiple-associatedpersons-1 button[type="submit"]').click()
# Refresh page
self.open(reverse('show_project', args=(1, )))
p = Person.objects.get(pk=1)
persons = AssociatedPersonsDimension.objects.get(pk=1).value.all()
self.assertFalse(p in persons)
def test_modify_project_associated_persons_dimension_add(self):
"""Add a Member"""
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Members dimension
self.find('Members-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('associatedpersons-value')
self.assert_that_element_appears('modify-associatedpersons-modal')
# Select person to add and click '+'
Select(self.find('associatedpersons-value')).select_by_value('2')
self.find_css(
'#modify-associatedpersons-form button[type="submit"]').click()
# Reload page
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Members dimension
self.find('Members-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('associatedpersons-value')
self.assert_that_element_appears('modify-associatedpersons-modal')
# Modal should list new member (2 members + addform)
self.assertEquals(
3,
len(
self.selenium.find_elements_by_css_selector(
'#associatedpersons-well-ul li')))
def test_modify_project_associated_projects_dimension_remove(self):
"""Remove a ProjectDependency"""
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Dependencies dimension
self.find('Dependencies-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('modify-associatedprojects-modal')
self.assert_that_element_appears('associatedprojects-value')
# Click to remove the only associated project
self.find_css(
'#multiple-associatedprojects-1 button[type="submit"]').click()
# Refresh page
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Dependencies dimension
self.find('Dependencies-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('modify-associatedprojects-modal')
self.assert_that_element_appears('associatedprojects-value')
# Check that it was removed in the database
p = Project.objects.get(pk=1)
projects = AssociatedProjectsDimension.objects.get(pk=1).value.all()
self.assertFalse(p in projects)
# Modal should not list any members only add the addform
self.assertEquals(
1,
len(
self.selenium.find_elements_by_css_selector(
'#associatedprojects-well-ul li')))
def test_modify_project_associated_projects_dimension_add(self):
"""Add ProjectDependency"""
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Dependencies dimension
self.find('Dependencies-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('associatedprojects-value')
self.assert_that_element_appears('modify-associatedprojects-modal')
# Select project to add and click '+'
Select(self.find('associatedprojects-value')).select_by_value('2')
self.find_css(
'#modify-associatedprojects-form button[type="submit"]').click()
self.open(reverse('show_project', args=(1, )))
# Click "Modify" of Dependencies dimension
self.find('Dependencies-modifybtn').click()
# Wait for modal to open up
self.assert_that_element_appears('associatedprojects-value')
self.assert_that_element_appears('modify-associatedprojects-modal')
# Check that it was added to the database
p = Project.objects.get(pk=2)
projects = AssociatedProjectsDimension.objects.get(pk=1).value.all()
self.assertTrue(p in projects)
# Modal should've added dependency(2 projects + addform)
self.assertEquals(
3,
len(
self.selenium.find_elements_by_css_selector(
'#associatedprojects-well-ul li')))
def test_add_path_snapshot(self):
self.open(reverse('path'))
self.assert_wait_that_element_clickable('project-selector')
Select(self.find('project-selector')).select_by_value("1")
self.find('save-path-snap-btn').click()
self.assert_that_element_appears('save-path-snap-modal')
self.find('path-snap-name').send_keys("PathSnapTest")
self.find('path-snap-desc').send_keys("PathSnapTestDescription")
self.find_css('#save-path-snap-form input[type="submit"]').click()
self.assert_that_element_appears('snap-info-cont')
def test_add_fourfield_snapshot(self):
self.open(reverse('fourfield'))
self.assert_wait_that_element_clickable('x-selector')
self.find('save-fourfield-snap-btn').click()
self.assert_that_element_appears('save-fourfield-snap-modal')
self.find('fourfield-snap-name').send_keys("FourFieldSnapTest")
self.find('fourfield-snap-desc').send_keys(
"FourFieldSnapTestDescription")
self.find_css('#save-fourfield-snap-form input[type="submit"]').click()
self.assert_that_element_appears('snap-info-cont')
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(
'icon-double-angle-down').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/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_info(self, usdl_info):
# Fill description field
self.driver.find_element_by_id('description').send_keys(
usdl_info['description'])
self.driver.find_element_by_id('abstract').send_keys(
usdl_info['abstract'])
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 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 select_plan(self, plan):
element = WebDriverWait(self.driver, 5).until(
EC.presence_of_element_located((By.ID, plan)))
element.click()
def accept_conditions(self):
element = WebDriverWait(self.driver, 5).until(
EC.presence_of_element_located((By.ID, "conditions-accepted")))
element.click()
def fill_tax_address(self, tax):
# Wait until the form is loaded
element = WebDriverWait(self.driver, 5).until(
EC.presence_of_element_located((By.ID, "street")))
element.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 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)
time.sleep(1)
wd.find_element_by_id("formLoginSubmit").click()
time.sleep(1)
if not ("Site" in wd.find_element_by_tag_name("html").text):
success = False
FH.write("Failed to log in. Check your User name and/or password\n")
raise Exception()
#=======================================================================
# Taking screen shot and writing result to BD_Results directory
#=======================================================================
wd.get_screenshot_as_file(path + "/Moderate_Tile.png")
#=======================================================================
if not (len(wd.find_elements_by_css_selector("div.pushIcon")) != 0):
success = False
FH.write("MODERATE A TILE FAILED: Please reset the data\n\n")
if not (len(wd.find_elements_by_css_selector("div.pullIcon")) != 0):
success = False
FH.write("MODERATE A TILE FAILED: Please reset the data\n\n")
wd.find_element_by_xpath(
"//table[@id='viewModerateTable']//td[.='CTD / VNX']").click()
time.sleep(1)
if not wd.find_element_by_css_selector("input.tableCheck").is_selected():
wd.find_element_by_css_selector("input.tableCheck").click()
time.sleep(1)
#wd.find_element_by_id("viewModerateTable-comment").click()
#time.sleep(1)
wd.find_element_by_id("viewModerateTable-comment").click()
time.sleep(1)
