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)