Python WebDriver.find_element_by_css_selector方法代码示例

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
def decline_offer(offer_reference):
    driver = WebDriver()

    # Login
    selenium_login(webdriver=driver)

    # Decline offer
    driver.get('https://www.odesk.com/applications/%s' % offer_reference)
    driver.find_element_by_id("declineButton").click()
    driver.find_element_by_css_selector("option[value=\"146\"]").click()
    driver.find_element_by_id("otherReason").clear()
    driver.find_element_by_id("otherReason").send_keys("Test")
    driver.find_element_by_xpath("(//a[contains(text(),'Decline')])[2]").click()

    driver.close()

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class TestGroup(unittest.TestCase):

    def setUp(self):
        self.wd = WebDriver()
        self.wd.implicitly_wait(60)
    
    def test_create_group(self):
        """Validation of correct create test group"""
        success = True
        wd = self.wd
        wd.get("http://localhost/addressbook/group.php")
        wd.find_element_by_name("user").click()
        wd.find_element_by_name("user").clear()
        wd.find_element_by_name("user").send_keys("admin")
        wd.find_element_by_id("LoginForm").click()
        wd.find_element_by_name("pass").click()
        wd.find_element_by_name("pass").clear()
        wd.find_element_by_name("pass").send_keys("secret")
        wd.find_element_by_css_selector("input[type=\"submit\"]").click()
        wd.find_element_by_name("new").click()
        wd.find_element_by_name("group_name").click()
        wd.find_element_by_name("group_name").clear()
        wd.find_element_by_name("group_name").send_keys("test")
        wd.find_element_by_name("group_header").click()
        wd.find_element_by_name("group_header").clear()
        wd.find_element_by_name("group_header").send_keys("test")
        wd.find_element_by_name("group_footer").click()
        wd.find_element_by_name("group_footer").clear()
        wd.find_element_by_name("group_footer").send_keys("test")
        wd.find_element_by_name("submit").click()
        wd.find_element_by_css_selector("div.msgbox").click()
        wd.find_element_by_link_text("group page").click()
        self.assertTrue(success)
    
    def tearDown(self):
        success = True
        # We should delete all created test form
        self.wd.find_element_by_link_text("groups").click()
        self.wd.find_element_by_css_selector("span.group").click()
        if not self.wd.find_element_by_name("selected[]").is_selected():
            self.wd.find_element_by_name("selected[]").click()
        self.wd.find_element_by_xpath("//div[@id='content']/form/input[5]").click()
        self.wd.find_element_by_link_text("Logout").click()
        self.assertTrue(success)
        self.wd.quit()

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
def add_odesk_teams(user):
    """
        Creates oDesk teams that will be used for our jobs.
    """
    driver = WebDriver()
    driver.implicitly_wait(time_to_wait=10)

    selenium_login(webdriver=driver)
    account = user.get_profile()

    # Gain access to settings
    driver.find_element_by_css_selector("a.oNavIcon.oNavIconSettings").click()
    driver.find_element_by_id("answer").clear()
    driver.find_element_by_id("answer").send_keys(settings.ODESK_TEST_ACC_ANSWER)
    driver.find_element_by_id("submitButton").click()

    sg_name = SAMPLE_GATHERING_TEAM % TEAM_PREFIX
    v_name = VOTING_TEAM % TEAM_PREFIX
    btmg_name = BTM_GATHERING_TEAM % TEAM_PREFIX
    btmv_name = BTM_VOTING_TEAM % TEAM_PREFIX

    sg_res = add_odesk_team(webdriver=driver, name=sg_name)
    v_res = add_odesk_team(webdriver=driver, name=v_name)
    btmg_res = add_odesk_team(webdriver=driver, name=btmg_name)
    btmv_res = add_odesk_team(webdriver=driver, name=btmv_name)

    if not all([sg_res, v_res, btmg_res, btmv_res]):
        log.warning('[oDesk] Failed to create oDesk teams.')
        return False

    client = make_client_from_account(account)
    teams = client.hr.get_teams()

    for team in teams:
        if team['name'] == sg_name:
            account.odesk_teams[JOB_SAMPLE_GATHERING_KEY] = team['reference']
        elif team['name'] == v_name:
            account.odesk_teams[JOB_VOTING_KEY] = team['reference']
        elif team['name'] == btmg_name:
            account.odesk_teams[JOB_BTM_GATHERING_KEY] = team['reference']
        elif team['name'] == btmv_name:
            account.odesk_teams[JOB_BTM_VOTING_KEY] = team['reference']
    account.save()
    return True

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class UITestCase(LiveServerTestCase):
    def use_xvfb(self):
        from pyvirtualdisplay import Display
        self.display = Display('xvfb',
                               visible=1,
                               size=(1280, 1024))
        self.display.start()
        self.driver = WebDriver()

    def setUp(self):
        try:
            self.driver = WebDriver()
            ui_is_not_available = False
        except WebDriverException:
            ui_is_not_available = True

        if ui_is_not_available:
            self.use_xvfb()

        self.driver.implicitly_wait(10)
        super(UITestCase, self).setUp()

    def tearDown(self):
        self.driver.quit()
        if hasattr(self, 'display'):
            self.display.stop()

        super(UITestCase, self).tearDown()

    def _process_login_form(self, username, password):
        username_elmt = self.driver.find_element_by_name('username')
        password_elmt = self.driver.find_element_by_name('password')

        username_elmt.send_keys(username)
        password_elmt.send_keys(password)

        submit = self.driver.find_element_by_css_selector('form * button')
        submit.click()

    def _browse_to_url(self, url):
        self.driver.get(self.live_server_url + url)

    def find_anchor_by_url(self, url):
        return self.driver.find_element_by_css_selector("[href='%s']" % url)

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
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='josh', 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()

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
def send_offer(cipher, job_reference, client, buyer_reference,
        worker_reference):
    driver = WebDriver()
    driver.implicitly_wait(time_to_wait=10)

    # Login
    selenium_login(webdriver=driver)

    # Worker's page
    driver.get('https:/www.odesk.com/users/%s' % cipher)
    driver.find_element_by_link_text("Contact").click()

    # Make an offer link
    driver.find_element_by_id("jsMakeOfferLink").click()
    el = driver.find_element_by_css_selector("#jsTeamSelector > select")
    el.find_element_by_css_selector("option[value=\"%s\"]" % buyer_reference).\
        click()
    driver.find_element_by_id("jsMakeOfferProceed").click()

    # Sign in to make an offer
    driver.find_element_by_id("password").clear()
    driver.find_element_by_id("password").send_keys(settings.ODESK_TEST_ACC_PASS)
    try:
        driver.find_element_by_id("answer").clear()
        driver.find_element_by_id("answer").send_keys(settings.ODESK_TEST_ACC_ANSWER)
    except selenium.exceptions.NoSuchElementException:
        pass
    driver.find_element_by_id("submitButton").click()

    # Make an offer form
    driver.find_element_by_id("useExistingJob-yes").click()
    el = driver.find_element_by_id("jobPosting")
    el.find_element_by_css_selector("option[value=\"%s\"]" % job_reference).\
        click()
    driver.find_element_by_id("employerRate").clear()
    driver.find_element_by_id("employerRate").send_keys("0.01")
    driver.find_element_by_id("setLimit-yes").click()
    driver.find_element_by_id("limit").clear()
    driver.find_element_by_id("limit").send_keys("0")
    driver.find_element_by_id("submitButton").click()

    # Agreement
    driver.find_element_by_id("agreement").click()
    driver.find_element_by_id("submitButton").click()

    driver.close()

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class JavaScriptTestCase(unittest.TestCase):

    def setUp(self):
        self.selenium = WebDriver()
        self.selenium.implicitly_wait(1) # wait one second before failing to find

    def tearDown(self):
        self.selenium.quit()

    def test_catalogue_extender_required(self):
        self.selenium.get(self._load('test_catalogue_extender_required'))
        self.assert_zero_failures()

    def _load(self, page):
        return 'file://' + opath.join(opath.dirname(__file__), 'qunit', page+'.html')

    def assert_zero_failures(self):
        elem = self.selenium.find_element_by_css_selector('#qunit-testresult span.failed')
        self.assertTrue(int(elem.text) == 0, "Failures found: " + elem.text)

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class TunesFunctionalTestCase(LiveServerTestCase):

    @classmethod
    def setUpClass(self):
        self.user = User.objects.create(email="[email protected]")
        self.user.set_password("password")
        self.user.save()
        
        self.selenium = WebDriver()
        super(TunesFunctionalTestCase, self).setUpClass()

    @classmethod
    def tearDownClass(self):
        self.selenium.quit()
        super(TunesFunctionalTestCase, self).tearDownClass()
    
    def test_login_and_add_tune_info(self):
        """
        Log in to the site, find a tune by name, and add some
        info about it.
        """

        # Jill goes to the home page of the site and logs in
        self.selenium.get(self.live_server_url)
        self.selenium.find_element_by_css_selector("a#tuw-login").click()
        username_input = self.selenium.find_element_by_name("username")
        username_input.send_keys('[email protected]')
        password_input = self.selenium.find_element_by_name("password")
        password_input.send_keys('password')
        self.selenium.find_element_by_css_selector('form#tuw-login button#tuw-submit-login').click()

        # she clicks the "Tunes" nav button
        self.selenium.find_element_by_css_selector('a#tuw-tunes').click()

        # and then clicks "Add a New Tune"
        self.selenium.find_element_by_css_selector('a#tuw-new-tune').click()

        # she searches for the word "Night"
        search_form = self.selenium.find_element_by_name("search")
        search_form.send_keys("Night")
        self.selenium.find_element_by_css_selector('form#tuw-login input#tuw-submit-search') 

        # and sees a few options
        #   "The Night Has a Thousand Eyes"
        #   "Night in Tunisia"
        #   "Night Train"
        
        # She selects "Night Train, and since we already have some info
        # about this tune in the database, she sees and partially
        # filled form

        # She adds what data she can about "Night Train" and 
        # saves the form

        # She wants to add another tune to the database, so she clicks
        # "Edit Another Tune"

        # She searches for the word "Mood"

        # and sees a few options
        #   "Mood Indigo"
        #   "In a Sentimental Mood"

        # She selects "In a Sentimental Mood", and since there's no 
        # info in the database about this tune yet, she see's a 
        # completely empty form

        # She enters all the information she knows about this tune in
        # in the form and clicks save.

        # When shes's done, she goes to the home page to the home page
        # and sees the newly added tunes

        self.fail("FINISH THE TEST")

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class UITestCase(StaticLiveServerTestCase):
    def use_xvfb(self):
        from pyvirtualdisplay import Display
        self.display = Display('xvfb',
                               visible=1,
                               size=(DISPLAY_WIDTH, DISPLAY_HEIGHT))
        self.display.start()
        self.driver = WebDriver()

    def setUp(self):
        try:
            self.driver = WebDriver()
            ui_is_not_available = False
        except WebDriverException:
            ui_is_not_available = True

        if ui_is_not_available:
            self.use_xvfb()

        self.driver.set_window_size(DISPLAY_WIDTH, DISPLAY_HEIGHT)

        self.driver.implicitly_wait(10)

        clear_caches()
        setup_for_ui_test()

        super(UITestCase, self).setUp()

    def tearDown(self):
        self.driver.quit()
        if hasattr(self, 'display'):
            self.display.stop()

        ContentType.objects.clear_cache()

        super(UITestCase, self).tearDown()

    def click(self, selector):
        self.find(selector).click()

    def click_when_visible(self, selector):
        element = self.find(selector)
        self.wait_until_visible(element)
        element.click()

    def find(self, selector):
        return self.driver.find_element_by_css_selector(selector)

    def find_name(self, name):
        return self.driver.find_element_by_name(name)

    def find_id(self, id):
        return self.driver.find_element_by_id(id)

    def is_visible(self, selector):
        element = self.find(selector)
        return element is not None and element.is_displayed()

    def process_login_form(self, username, password):
        username_elmt = self.wait_until_present('[name="username"]')
        password_elmt = self.find_name('password')

        username_elmt.send_keys(username)
        password_elmt.send_keys(password)

        self.click('form * button')

    def browse_to_url(self, url):
        self.driver.get(self.live_server_url + url)

    def browse_to_instance_url(self, url, instance=None):
        instance = instance if instance is not None else self.instance
        self.driver.get('%s/%s/%s' % (self.live_server_url,
                                      instance.url_name,
                                      url))

    def find_anchor_by_url(self, url):
        return self.find("[href='%s']" % url)

    def wait_until_present(self, selector, timeout=10):
        """
        Wait until an element with CSS 'selector' exists on the page.
        Useful for detecting that an operation loads the page you're expecting.
        """
        element = [None]  # use list so it can be set by inner scope

        def is_present(driver):
            element[0] = self.find(selector)
            return element[0] is not None and element[0].is_displayed()

        WebDriverWait(self.driver, timeout).until(is_present)
        return element[0]

    def wait_until_text_present(self, text, timeout=10):
        """
        Wait until 'text' exists on the page.
        Useful for detecting that an operation loads the page you're expecting.
        """
        WebDriverWait(self.driver, timeout).until(
            lambda driver: text in driver.page_source)
#.........这里部分代码省略.........

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
def is_alert_present(wd):
    try:
        wd.switch_to_alert().text
        return True
    except:
        return False

try:
    wd.get("http://b11test4a.mentoringmindsonline.com/mysdb_m3_test4/_design/mys/mmloginw.html")
    wd.find_element_by_id("loginUserID").click()
    wd.find_element_by_id("loginUserID").clear()
    wd.find_element_by_id("loginUserID").send_keys("113177")
    wd.find_element_by_id("userPasswd").click()
    wd.find_element_by_id("userPasswd").clear()
    wd.find_element_by_id("userPasswd").send_keys("Ctfl*5258")
    wd.find_element_by_id("sign-in").click()
    wd.find_element_by_id("reportsBigBtnBtn").click()
    wd.find_element_by_id("selectReportTypeW").click()
    wd.find_element_by_id("dijit_MenuItem_30_text").click()
    wd.find_element_by_id("dijit_MenuItem_39_text").click()
    wd.find_element_by_id("dijit_MenuItem_92_text").click()
    wd.find_element_by_id("generateReportBtn").click()
    wd.find_element_by_css_selector("#dojox_mobile_ToolBarButton_34 > span.mblToolBarButtonBody.mblColorDefault > table.mblToolBarButtonText > tbody > tr > td.mblToolBarButtonLabel").click()
    wd.find_element_by_css_selector("#dojox_mobile_ToolBarButton_4 > span.mblToolBarButtonBody.mblColorDefault > table.mblToolBarButtonText > tbody > tr > td.mblToolBarButtonLabel").click()
    wd.find_element_by_css_selector("td.mblToolBarButtonLabel").click()
finally:
    wd.quit()
    if not success:
        raise Exception("Test failed.")

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
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
#.........这里部分代码省略.........

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
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='admin'):
        # 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='admin'):
        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()

#.........这里部分代码省略.........

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class SeleniumTests(LiveServerTestCase):
    """Base class for all Selenium test classes to inherit from"""

    @classmethod
    def setUpClass(self):
        self.selenium = WebDriver()
        self.selenium.implicitly_wait(3)
        super(SeleniumTests, self).setUpClass()

    @classmethod
    def tearDownClass(self):
        self.selenium.quit()
        super(SeleniumTests, self).tearDownClass()

    def setUp(self):
        # Create a test user and admin account
        self.user_name = 'SeleniumTestUser'
        self.user_pass = 'test'
        if User.objects.filter(username=self.user_name).count() == 0:
            User.objects.create_user(self.user_name, '', self.user_pass).save()

        self.admin_name = 'SeleniumAdministrativeUser'
        self.admin_pass = 'test'
        if User.objects.filter(username=self.admin_name).count() == 0:
            User.objects.create_superuser(self.admin_name, '', self.admin_pass).save()

    def tearDown(self):
        self.selenium.delete_all_cookies()

    def link_text_exists(self, link_text):
        try:
            self.selenium.find_element_by_link_text(link_text)
        except NoSuchElementException:
            return False
        return True

    def xpath_exists(self, xpath):
        try:
            self.selenium.find_element_by_xpath(xpath)
        except NoSuchElementException:
            return False
        return True

    def element_with_selector_exists(self, selector):
        try:
            self.selenium.find_element_by_css_selector(selector)
        except NoSuchElementException:
            return False
        return True

    def text_exists(self, text, xpath="//body"):
        try:
            element = self.selenium.find_element_by_xpath(xpath)
        except NoSuchElementException:
            return False

        if text in element.text:
            return True
        else:
            return False

    def login(self, username, password):
        # Go to the login page and try logging in with the provided credentials
        self.selenium.get('%s' % self.live_server_url)
        self.selenium.find_element_by_link_text('Log in').click()
        username_input = self.selenium.find_element_by_name('username')
        username_input.send_keys(username)
        password_input = self.selenium.find_element_by_name('password')
        password_input.send_keys(password)
        self.selenium.find_element_by_class_name('submit').click()

    def create_items_and_requests(self, x):
        # Creates x number of items and requests
        for i in xrange(x):
            self.item = G(Item)
            self.request = G(Request, item=self.item)

    def create_generic_item(self):
        # Quick helper in the absence of fixtures
        item = G(Item, local_num=9999, part_class='parts class',
                 location='cart 8', description='test item', cfi='never',
                 company='A Business', part_num='X9X9', serial_num='8A',
                 asset_num='sample_num', notes='Testing')
        return item

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
class UITestCase(LiveServerTestCase):
    def use_xvfb(self):
        from pyvirtualdisplay import Display
        self.display = Display('xvfb',
                               visible=1,
                               size=(1280, 1024))
        self.display.start()
        self.driver = WebDriver()

    def setUp(self):
        try:
            self.driver = WebDriver()
            ui_is_not_available = False
        except WebDriverException:
            ui_is_not_available = True

        if ui_is_not_available:
            self.use_xvfb()

        self.driver.implicitly_wait(10)
        super(UITestCase, self).setUp()

    def tearDown(self):
        self.driver.quit()
        if hasattr(self, 'display'):
            self.display.stop()

        super(UITestCase, self).tearDown()

    def click(self, selector):
        self.find(selector).click()

    def find(self, selector):
        return self.driver.find_element_by_css_selector(selector)

    def find_name(self, name):
        return self.driver.find_element_by_name(name)

    def find_id(self, id):
        return self.driver.find_element_by_id(id)

    def process_login_form(self, username, password):
        username_elmt = self.find_name('username')
        password_elmt = self.find_name('password')

        username_elmt.send_keys(username)
        password_elmt.send_keys(password)

        self.click('form * button')

    def browse_to_url(self, url):
        self.driver.get(self.live_server_url + url)

    def find_anchor_by_url(self, url):
        return self.find("[href='%s']" % url)

    def wait_until_enabled(self, element, timeout=10):
        def isPresentAndEnabled(driver):
            return element.get_attribute("disabled") is None
        WebDriverWait(self.driver, timeout).until(isPresentAndEnabled)

    def wait_until_visible(self, element, timeout=10):
        def isPresentAndEnabled(driver):
            return element.is_displayed()
        WebDriverWait(self.driver, timeout).until(isPresentAndEnabled)

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_css_selector [as 别名]
def is_alert_present(wd):
    try:
        wd.switch_to_alert().text
        return True
    except:
        return False

try:
    wd.get("http://localhost/addressbook/")
    wd.find_element_by_name("pass").click()
    wd.find_element_by_name("pass").clear()
    wd.find_element_by_name("pass").send_keys("secret")
    wd.find_element_by_name("user").click()
    wd.find_element_by_name("user").clear()
    wd.find_element_by_name("user").send_keys("admin")
    wd.find_element_by_css_selector("input[type=\"submit\"]").click()
    wd.find_element_by_link_text("groups").click()
    wd.find_element_by_name("new").click()
    wd.find_element_by_name("group_name").click()
    wd.find_element_by_name("group_name").clear()
    wd.find_element_by_name("group_name").send_keys("new froup")
    wd.find_element_by_name("group_header").click()
    wd.find_element_by_name("group_header").clear()
    wd.find_element_by_name("group_header").send_keys("new grope")
    wd.find_element_by_name("group_footer").click()
    wd.find_element_by_name("group_footer").clear()
    wd.find_element_by_name("group_footer").send_keys("new grpi")
    wd.find_element_by_name("submit").click()
    wd.find_element_by_link_text("group page").click()
    wd.find_element_by_link_text("Logout").click()
    wd.find_element_by_name("user").click()