Python WebDriver.find_element_by_class_name方法代码示例

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

    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='test1', email='[email protected]', password='111'
        )
        self.super_user = User.objects.create_user(
            username='super', email='[email protected]', password='123'
        )
        self.super_user.is_superuser = True
        self.super_user.is_staff = True
        self.super_user.save()
        # 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_stick_to_top_admin(self):
        self.browser.get(self.live_server_url + reverse("niji:index"))
        login(self.browser, 'super', '123')
        self.assertIn("Log out", self.browser.page_source)

        lucky_topic1 = getattr(self, 't%s' % random.randint(1, 50))

        self.browser.get(self.live_server_url+reverse('niji:topic', kwargs={"pk": lucky_topic1.pk}))
        self.browser.find_element_by_class_name('move-topic-up').click()
        up_level = WebDriverWait(
            self.browser, 10
        ).until(
            expected_conditions.presence_of_element_located(
                (By.NAME, 'move-topic-up-level')
            )
        )
        up_level = Select(up_level)
        up_level.select_by_visible_text('1')
        time.sleep(1)
        self.browser.execute_script("$('.modal-confirm').click()")
        self.browser.get(self.live_server_url+reverse('niji:index'))
        first_topic_title = self.browser.find_elements_by_class_name('entry-link')[0].text

        self.assertEqual(first_topic_title, lucky_topic1.title)

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_class_name [as 别名]
class EntrySeleleniumTests(StaticLiveServerTestCase):
    """Selenium tests for the entry form"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        if not settings.DEBUG:
            settings.DEBUG = True

    def setUp(self):
        """Handles login and things"""
        call_command('flush', interactive=False, verbosity=0)  # Clears db
        call_command('loaddata', 'groups', commit=False, verbosity=0)
        call_command('loaddata', 'school', commit=False, verbosity=0)
        call_command('loaddata', 'permissions', commit=False, verbosity=0)
        call_command('loaddata', 'auth_users', commit=False, verbosity=0)
        call_command('loaddata', 'student', commit=False, verbosity=0)
        call_command('loaddata', 'advisor', commit=False, verbosity=0)
        call_command('loaddata', 'coordinator', commit=False, verbosity=0)
        call_command('loaddata', 'activityoptions', commit=False, verbosity=0)
        call_command('loaddata', 'learningobjectiveoptions', commit=False, verbosity=0)
        call_command('loaddata', 'sample_entries', commit=False, verbosity=0)
        self.selenium = WebDriver()
        self.selenium.set_window_size(1024, 800)
        self.selenium.get('{0}/{1}'.format(self.live_server_url, ''))
        self.selenium.find_element_by_xpath('//*[@id="djHideToolBarButton"]').click()
        self.selenium.implicitly_wait(10)
        self.selenium.find_element_by_link_text('Login').click()
        # Click on the student button in the gateway
        self.selenium.find_element_by_xpath('/html/body/center/md-content/div/div/div[1]/a').click()
        self.selenium\
            .find_element_by_xpath("//img[@src='/static/journal/activities/img"
                                   "/journal_sign.png']")
        super()

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

    def test_text_entry(self):
        """Test to ensure that a student can add a text entry"""
        # Click on the first activity box: Walking around the block
        self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div/div[1]/div/div[3]/a/div').click()
        self.selenium.find_element_by_link_text('Add an entry').click()
        # The following has 2 matching: Just walking and Adding entry...block
        header_text = self.selenium.find_elements_by_tag_name('h3')[1].text
        self.assertTrue('Adding entry for Walking around the block!' in header_text)
        # Switching to iframe focus
        self.selenium.switch_to_frame(self.selenium.find_element_by_id('id_entry_iframe'))
        # Insert text
        entry = 'I think I will bring my cat out next time.'
        self.selenium.find_element_by_class_name('note-editable')\
            .send_keys(entry)
        # Switch back out of the iframe.
        self.selenium.switch_to_default_content()
        # Click on the submit button
        self.selenium.find_element_by_class_name('btn-success').click()
        # Ensure that we are back on the entries page.
        self.selenium.find_element_by_link_text('Add an entry')
        # Ensure that entry exists as the first box on the page.
        box_text = self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div[2]/div[1]/a/div').text
        self.assertTrue(entry in box_text)

    def test_image_entry(self):
        """Test to ensure that a student can add an image entry"""
        # Click on the first activity box: Walking around the block
        self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div/div[1]/div/div[3]/a/div').click()
        self.selenium.find_element_by_link_text('Add an entry').click()
        # The following has 2 matching: Just walking and Adding entry...block
        header_text = self.selenium.find_elements_by_tag_name('h3')[1].text
        self.assertTrue('Adding entry for Walking around the block!' in header_text)
        # Switching to iframe focus
        self.selenium.switch_to_frame(self.selenium.find_element_by_id('id_entry_iframe'))
        self.selenium.find_element_by_xpath('/html/body/div[2]/div[5]/div[3]/button[2]').click()
        entry = 'http://images.jfdaily.com/jiefang/wenyu/new/201409/W020140919421426345484.jpg'
        self.selenium.find_element_by_xpath('/html/body/div[2]/div[2]/div[1]/div/div/div[2]/div[2]/input')\
            .send_keys(entry)
        # click on the inset image button
        self.selenium.find_element_by_xpath('/html/body/div[2]/div[2]/div[1]/div/div/div[3]/button').click()
        # Switch back out of the iframe.
        self.selenium.switch_to_default_content()
        # Click on the submit button
        self.selenium.implicitly_wait(10)
        self.selenium.find_element_by_class_name('btn-success').click()
        # Ensure that we are back on the entries page.
        self.selenium.find_element_by_link_text('Add an entry')
        # Ensure that entry exists on the page.
        self.selenium.find_element_by_xpath("//img[@src='http://images.jfdaily.com/jiefang/wenyu/new/201409/W020140919421426345484.jpg']")

    def test_video_entry(self):
        """Test to ensure that a student can add a video entry"""
        # Click on the first activity box: Walking around the block
        self.selenium.find_element_by_xpath('/html/body/div[1]/div[2]/div/div[1]/div/div[3]/a/div').click()
        self.selenium.find_element_by_link_text('Add an entry').click()
        # The following has 2 matching: Just walking and Adding entry...block
        header_text = self.selenium.find_elements_by_tag_name('h3')[1].text
        self.assertTrue('Adding entry for Walking around the block!' in header_text)
        # Switching to iframe focus
        self.selenium.switch_to_frame(self.selenium.find_element_by_id('id_entry_iframe'))
        # Insert video
        self.selenium.find_element_by_xpath('/html/body/div[2]/div[5]/div[3]/button[3]').click()
#.........这里部分代码省略.........

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_class_name [as 别名]

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

    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')

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_class_name [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_class_name [as 别名]
class RegistrationSeleniumTestCase(LiveServerTestCase):
    """
    """
    fixtures = ['test_data.json', 'test_schedule.json']


    @classmethod
    def setUpClass(self):
        """ Start Selenium.
        """
        # start Firefox websdriver
        self.selenium = WebDriver()

        # call super setup method
        super(RegistrationSeleniumTestCase, self).setUpClass()


    def setUp(self):
        # change the language to english for language-based assertations
        self.branch = Branch.objects.all()[0]
        self.branch.language = 'en'
        self.branch.save()  

        # approve a scheduled class so it appears on the website
        self.schedule = Schedule.objects.filter(course__branch=self.branch)[0]
        self.schedule.course_status = 3
        self.schedule.save()
        
        self.timeout = 2


    def test_registration_toggle_button(self):
        """ Tests that clicking the title of a scheduled class
            on the website expands the div.
        """
        # construct server url
        schedule_list_url = reverse('schedule-list', kwargs={ 'branch_slug' : self.branch.slug })
        live_url = "%s%s" % (self.live_server_url, schedule_list_url)

        # load page
        self.selenium.get(live_url)

        # find a scheduled class title and click on it
        toggle_button = self.selenium.find_element_by_class_name('toggle')        
        
        self.assertTrue(toggle_button.is_displayed())
        toggle_button.click()
        
        
    def test_registration_join_button(self):
        """ Tests that clicking on the join button sends an ajax request.
        """
        # construct server url
        schedule_register_url = reverse('schedule-register', kwargs={ 'branch_slug' : self.branch.slug, 'schedule_slug' : self.schedule.slug })
        live_url = "%s%s" % (self.live_server_url, schedule_register_url)

        # load page
        self.selenium.get(live_url)

        # find a scheduled class join button
        join_button = self.selenium.find_element_by_class_name('join')        
        
        self.assertTrue(join_button.is_displayed())

        join_button.click()        


    def tearDown(self):
        """ Delete Branch files.
        """
        # delete branches' files
        for branch in Branch.objects.all():
            branch.delete_files()        

    @classmethod
    def tearDownClass(self):
        # stop selenium    
        self.selenium.quit()

        # call super teardown method
        super(RegistrationSeleniumTestCase, self).tearDownClass()

# 需要导入模块: from selenium.webdriver.firefox.webdriver import WebDriver [as 别名]
# 或者: from selenium.webdriver.firefox.webdriver.WebDriver import find_element_by_class_name [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_class_name [as 别名]
class TopicOrderingTest(LiveServerTestCase):

    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='test1', email='[email protected]', password='111'
        )
        # 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_default_ordering_without_settings(self):
        self.browser.get(self.live_server_url+reverse("niji:index"))
        first_topic_title = self.browser.find_element_by_class_name(
            "entry-link"
        ).text
        self.assertEqual(first_topic_title, self.t99.title)
        Post.objects.create(
            topic=self.t1,
            content_raw='reply to post __1__',
            user=self.u1,
        )
        self.browser.get(self.browser.current_url)
        first_topic_title = self.browser.find_element_by_class_name(
            "entry-link"
        ).text
        self.assertEqual(first_topic_title, self.t1.title)

    @override_settings(NIJI_DEFAULT_TOPIC_ORDERING="-pub_date")
    def test_default_ordering_with_settings(self):
        self.browser.get(self.live_server_url+reverse("niji:index"))
        first_topic_title = self.browser.find_element_by_class_name(
            "entry-link"
        ).text
        self.assertEqual(first_topic_title, self.t99.title)
        Post.objects.create(
            topic=self.t1,
            content_raw='reply to post __1__',
            user=self.u1,
        )
        self.browser.get(self.browser.current_url)
        first_topic_title = self.browser.find_element_by_class_name(
            "entry-link"
        ).text
        self.assertEqual(first_topic_title, self.t99.title)

    def test_user_specified_ordering_last_replied(self):
        self.browser.get(self.live_server_url+reverse("niji:index"))
        self.browser.find_element_by_link_text(
            "Last Replied"
        ).click()
        first_topic_title = self.browser.find_element_by_class_name(
            "entry-link"
        ).text
        self.assertEqual(first_topic_title, self.t99.title)

    def test_user_specified_ordering_pub_date(self):
        Post.objects.create(
            topic=self.t1,
            content_raw='reply to post __1__',
            user=self.u1,
        )
        self.browser.get(self.live_server_url+reverse("niji:index"))
        self.browser.find_element_by_link_text(
            "Topic Date"
        ).click()
        first_topic_title = self.browser.find_element_by_class_name(
            "entry-link"
        ).text
        self.assertEqual(first_topic_title, self.t99.title)

    def test_user_specified_ordering_last_replied_pagination(self):
        self.browser.get(self.live_server_url+reverse("niji:index"))
        self.browser.find_element_by_link_text(
            "Last Replied"
        ).click()
        res = self.client.get(self.browser.current_url)
        request = res.wsgi_request
        self.assertEqual(request.GET.get("order"), "-last_replied")
        self.browser.find_element_by_link_text("»").click()
        res = self.client.get(self.browser.current_url)
        request = res.wsgi_request
        self.assertEqual(request.GET.get("order"), "-last_replied")
#.........这里部分代码省略.........