Python Browser.fill_form方法代码示例

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
def get_claim_code_from_server():
  browser = Browser('phantomjs', service_args=['--ignore-ssl-errors=true'])
  browser.visit(ROOT_ADDRESS + "/merchant-login")
  browser.fill_form({"email": USER_NAME, "password": PASSWORD})
  browser.find_by_id("loginButton")[0].click()
  time.sleep(5)
  browser.visit(ROOT_ADDRESS + "/api-tokens")
  browser.find_by_css(".token-access-new-button").find_by_css(".btn").find_by_css(".icon-plus")[0].click()
  browser.find_by_id("token-new-form").find_by_css(".btn")[0].click()
  return browser.find_by_css(".token-claimcode")[0].html

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
def testLoginWithWrongCredentialsFails():
    browser = Browser()
    browser.visit('http://127.0.0.1:8000')
    browser.fill_form({'username': 'admin'})
    browser.fill_form({'password': 'falsepw'})
    browser.find_by_value('Anmelden').click()

    if browser.is_text_present('Your login credentials are incorrect'):
        print "Test passed"
    else:
        print "Test failed"

    browser.quit()

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
def main():
    # Open new firefox browser window, login to indeed.com
    br = Browser('firefox')
    br.visit(LOGIN_URL)
    br.fill_form({'email':INDEED_USERNAME,'password':INDEED_PASSWORD})
    br.find_by_css('.input_submit').first.click()   
    
    resume_links = []
    resume_index = 0
    
    while True:
        br.visit(RESUMES_URL + '&start=%d' % resume_index)
        links = br.find_by_css('.app_link')
        if len(links) > 0:
            for link in links:
            # Rewrite this. The Browser object cannot find the href value for some reason...
                resume_links.append('http://www.indeed.com' + re.search(r'href=[\'"]?([^\'" >]+)', link.outer_html).group(1))   
            resume_index += 50
        else:
            resume_index = 1
            break

    print '[+] Resume Links Found: %d' % len(resume_links)
    
    # Load the 1,000 most commonly used words into common_words
    sys.stdout.write('[+] Loading Common Word List [    ]')
    common_words = gen_comword_list()
    sys.stdout.flush()
    sys.stdout.write('\r[+] Loading Common Word List [DONE]\n')   
    
    for resume in resume_links:
        br.visit(resume)
        try:
            #print '[+] Scanning %s\'s Resume...' % br.find_by_id("resume-contact").text        
            resume_words = parse_resume_words(br.html, common_words) 
            #print '\tUnique Words Found: %d' % len(resume_words)
            for word in resume_words:
                if not word in KEYWORDS:
                    KEYWORDS[word] = 1
                else:
                    KEYWORDS[word] += 1      
        except:
            pass
        sys.stdout.write('[+] Sanning Resumes: {0:.0f}%\r'.format(float(resume_index)/len(resume_links) * 100))
        sys.stdout.flush()
        resume_index += 1  
            
    print '\n[+] Total Unique Keywords Found: %d' % len(KEYWORDS.keys())
    print '============\nTOP 20 WORDS\n============'
    for pair in sorted(KEYWORDS.items(), key=operator.itemgetter(1), reverse=True)[:20]:
        print '%s: %d' % (pair[0], pair[1])

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
class SplinterTestCase(LiveServerTestCase):
    username = 'peter.griffin'
    email = '[email protected]'
    password = 'lazyonthecouch'
    is_anonymous = True
    is_staff = False
    is_logged_in = True

    def setUp(self):
        settings.DEBUG = True
        super(SplinterTestCase, self).setUp()
        self.user = None
        self.base_url = URL(self.live_server_url)
        self.browser = Browser(SPLINTER_WEBDRIVER)

        if self.is_anonymous and not self.is_staff:
            return

        self.user = factories.UserFactory(
            username=self.username,
            email=self.email,
            password=self.password,
            is_staff=self.is_staff,
        )

        if self.is_logged_in:
            self.goto(reverse('admin:index'))
            self.browser.fill_form({
                'username': self.username,
                'password': self.password,
            })
            self.browser.find_by_css("input[type='submit']").first.click()
            self.assertIn('Log out', self.browser.html)

    def tearDown(self):
        super(SplinterTestCase, self).tearDown()
        self.browser.quit()

    def goto(self, path):
        url = self.base_url.path(path)
        return self.browser.visit(url.as_string())

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
class AuthenticationRegisterBrowserTestCase(TestCase):
    def setUp(self):
        self.browser = Browser('django')
        self.test_user_id = '[email protected]'
        self.test_user_password = 'test-user-password'

    def test_register_page_ok(self):
        self.browser.visit('/register')
        assert '/register' in self.browser.url

    def test_register_ok(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': self.test_user_id,
                                'password1': self.test_user_password,
                                'password2': self.test_user_password,
                                'terms_ok_0': True,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()
        assert 'registeration completed' in self.browser.title.lower()

        user = User.objects.get(email=self.test_user_id)
        assert user.is_active is False

    def test_activation_ok(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': self.test_user_id,
                                'password1': self.test_user_password,
                                'password2': self.test_user_password,
                                'terms_ok_0': True,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()

        user = User.objects.get(email=self.test_user_id)
        activation_key = UserActivation.objects.get(user=user).activation_key
        assert user.is_active is False
        assert UserActivation.objects.filter(activation_key=activation_key).exists() is True

        self.browser.visit('/activation/' + activation_key)
        assert 'activation completed' in self.browser.title.lower()

        user = User.objects.get(email=self.test_user_id)
        assert user.is_active is True
        assert UserActivation.objects.filter(activation_key=activation_key).exists() is False

    def test_too_long_email_should_fail_register(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': 'a' * 254 + '@pergenie.org',
                                'password1': self.test_user_password,
                                'password2': self.test_user_password,
                                'terms_ok_0': True,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()
        assert self.browser.is_text_present('Ensure this value has at most 254')

    def test_too_long_password_should_fail_register(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': self.test_user_id,
                                'password1': 'a' * 1025,
                                'password2': 'a' * 1025,
                                'terms_ok_0': True,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()
        assert self.browser.is_text_present('Ensure this value has at most 1024')

    def test_too_weak_password_should_fail_register(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': self.test_user_id,
                                'password1': 'weak',
                                'password2': 'weak',
                                'terms_ok_0': True,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()
        assert self.browser.is_text_present('Passwords too short')

    def test_not_match_passwords_should_fail_register(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': self.test_user_id,
                                'password1': self.test_user_password,
                                'password2': 'not-match-password',
                                'terms_ok_0': True,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()
        assert self.browser.is_text_present('Passwords do not match')

    def test_not_agree_with_terms_should_fail_register(self):
        self.browser.visit('/register')
        self.browser.fill_form({'email': self.test_user_id,
                                'password1': self.test_user_password,
                                'password2': self.test_user_password,
                                'terms_ok_0': False,
                                'terms_ok_1': True})
        self.browser.find_by_name('submit').click()
        assert self.browser.is_text_present('Not read and accept about service')

    def test_already_registerd_user_should_fail_register(self):
        self.user = User.objects.create_user(self.test_user_id,
                                             self.test_user_password)
        self.user.save()

        self.browser.visit('/register')
#.........这里部分代码省略.........

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
class Session:
    def __init__(self, browser, user):
        self.browser = Browser(browser)
        self.browser.visit('http://jizdenky.studentagency.cz/')
        self.browser.fill_form({'passwordAccountCode': user['login'],
                                'password': user['password']})
        self.browser.execute_script('window.scrollTo(0, 100)')
        button = self.browser.find_by_value('Přihlásit').first
        button.click()
        self.user = user
        self.log = logging.getLogger(__name__)

    def go_search(self):
        self.browser.visit('http://jizdenky.studentagency.cz/')

    def search(self, task, date_return=None, is_open=False):
        self.browser.find_by_id('hp_form_itinerar').first \
            .find_by_xpath('div/input[@type="radio"]'
                           )[1 if date_return or is_open else 0].check()
        for city, i in [(task.from_city, 1), (task.to_city, 2)]:
            self.browser.find_by_css('input[tabindex="{}"]'.format(i)) \
                        .first.fill(city)
            for item in self.browser.find_by_css('.ui-menu-item'):
                link = item.find_by_tag('a')
                if link.value.lower() == city.lower():
                    link.click()
                    break
        self.browser.fill('departure:dateField', task.date)
        if date_return:
            self.browser.fill('returnDeparture:dateField', date_return)
        if is_open:
            self.browser.check('returnTicketOpen')
        self.browser.find_option_by_text('ISIC').first.check()
        self.browser.find_by_value('Vyhledat').first.click()
        while self.browser.is_element_not_present_by_css('.left_column',
                                                         wait_time=1):
            pass
        items = self.browser.find_by_css('.left_column') \
                            .find_by_xpath('div/div/*')
        connections = []
        for item in items:
            if item.tag_name == 'h2':
                date_local = item.text.split(' ')[1]
            elif item.tag_name == 'div' and item.has_class('routeSummary'):
                assert date_local
                if date_local != task.date:
                    break
                connections.append(Connection(item))
        return connections

    def order_time(self, connection):
        while True:
            if connection.click():
                self.browser

            dialog = self.browser.find_by_css('[id^=_wicket_window]')
            if dialog:
                dialog.first.find_by_tag('button').click()
            if self.browser.is_element_present_by_id('sumary_lines',
                                                     wait_time=1):
                break
        self.browser.find_by_id('sumary_lines') \
                    .first.find_by_tag('button') \
                    .first.click()
        seats = {}
        bus = self.browser.find_by_css('.seatsContainer')
        if bus:
            for seat in bus.first.find_by_css(
                    '.seatContainer:not([style*=blocked])'):
                seats[int(seat.find_by_tag('div').first.html[:-1])] = seat
        else:
            bus = self.browser.find_by_css('.vehicle')
            for seat in bus.first.find_by_css('.free, .selected'):
                seats[int(seat.text[:-1])] = seat
        return seats

    def order_seat(self, seat):
        if not seat.has_class('selected'):
            seat.click()
        for fs in self.browser.find_by_css('fieldset.topRoute'):
            legend = fs.find_by_css('legend')
            if legend and 'Pojištění' in legend[0].text:
                for package in fs.find_by_css('.insurancePackageType'):
                    if 'nechci' in package.find_by_tag('label').text:
                        package.find_by_tag('input').click()
                        time.sleep(1)
        submit = self.browser.find_by_css('[name^=buttonContainer]').first
        interaction_type = submit.text
        reserved = 'Rezervovat' in interaction_type
        if not reserved:
            submit.click()
            time.sleep(1)
            data = (self.user['first'],
                    self.user['last'],
                    self.user['email'],
                    self.user['phone'])
            for item, value in zip(self.browser.find_by_id('passengerInfo')
                                               .first.find_by_tag('input'),
                                   data):
                item.fill(value)
#.........这里部分代码省略.........

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
from splinter import Browser

browser = Browser('chrome')
def myClick_txt(url):
    print 'myclick',url
    while(browser.is_element_not_present_by_text(url)):
        pass
    browser.click_link_by_text(url)
# Visit URL
url = "http://weibo.com/login.php"
browser.visit(url)
# 登录
myClick_txt(u'帐号登录')
# data里填真实的username和password
data ={'username':'******','password':'******'}
browser.fill_form(data)
browser.find_by_css('.W_btn_a').first.click()
import time
browser.visit('http://weibo.com/message/history?uid=5175429989#_0')
question = browser.find_by_css('.bubble_r .page').last.text
lastAnswer = ''
answer = ''
j = 0
while True:
    try:
        if j % 100 == 0:
            browser.reload()
            while browser.is_element_not_present_by_css('.bubble_l .page'):
                browser.reload()
        j += 1
        i = 0

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
class SplinterTestCase(LiveServerTestCase):
    username = 'peter.griffin'
    email = '[email protected]'
    password = 'lazyonthecouch'
    is_anonymous = True
    is_staff = False
    is_logged_in = True

    def setUp(self):
        super(SplinterTestCase, self).setUp()
        self.user = None
        self.base_url = URL(self.live_server_url)
        self.browser = Browser(SPLINTER_WEBDRIVER)
        self.browser.driver.set_window_size(1280, 1024)

        if self.is_anonymous and not self.is_staff:
            return

        self.user = factories.UserFactory(
            username=self.username,
            email=self.email,
            password=self.password,
            is_staff=self.is_staff,
        )

        if self.is_logged_in:
            self.goto(reverse('admin:index'))
            self.browser.fill_form({
                'username': self.username,
                'password': self.password,
            })
            self.browser.find_by_css("input[type='submit']").first.click()
            exists = self.browser.is_text_present('Log out', wait_time=2)
            self.assertTrue(exists)

    def tearDown(self):
        super(SplinterTestCase, self).tearDown()
        if not os.getenv('SPLINTER_DEBUG'):
            self.browser.quit()

    def goto(self, path):
        url = self.base_url.path(path)
        return self.browser.visit(url.as_string())

    def wait_for_editor_reload(self, wait_for=3):
        time.sleep(wait_for)

    def ensure_element(self, element_or_list, index=0):
        """
        Selects either the element with *index* from the list of elements given
        in *element_or_list* or returns the single element if it is not a list.
        This make it possible to handle an element and a list of elements where
        only a single element is required.

        :param element: ``Element`` instance or ``ElementList``.
        :parem int index: Index of element to be returned if a list.
            (Default: 0)
        :rtype: Element
        """
        if isinstance(element_or_list, ElementList):
            return element_or_list[index]
        return element_or_list

    def find_and_click_by_css(self, browser, selector, wait_time=3):
        browser.is_element_present_by_css(selector, wait_time)
        elem = self.ensure_element(browser.find_by_css(selector))
        return elem.click()

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
class TestRoutes(unittest.TestCase):

	@classmethod
	def setUpClass(cls):
		# socketio.run(flapp, port = flapp.config['PORT'])
		pass
		
	# @init_db
	def setUp(self):
		self.browser = Browser()
		self.username = uuid4().hex
		self.userpassword = uuid4().hex

	def tearDown(self):
		self.browser.quit()
		
	def go_home(self):
		self.browser.visit( 'http://localhost:%s'%flapp.config['PORT'])

	def login(self, user):
		self.go_home()
		self.browser.fill_form({'username': self.username, 'password':self.userpassword})
		self.browser.find_by_value('Sign in').click()


	def test_login_success_with_confirmed_user(self):
		self.login(UserFactory.seed_confirmed_user(self.username, self.userpassword))
		assert self.browser.is_text_present('Signed in as %s'%self.username)


	def test_login_failure_with_nonconfirmed_user(self):
		user = UserFactory.seed_nonconfirmed_user(self.username, self.userpassword)
		self.login(user)
		assert self.browser.is_text_not_present('Signed in as %s'%self.userpassword)
		assert self.browser.is_text_present('Sign in')

	def test_login_failure_with_nonexisting_user(self):
		self.go_home()
		fake_username = uuid4().hex
		self.browser.fill_form({'username': fake_username, 'password':uuid4().hex})
		self.browser.find_by_value('Sign in').click()
		assert self.browser.is_text_not_present('Signed in as %s'%fake_username)
		assert self.browser.is_text_present('Sign in')

	def test_logout(self):
		self.login(UserFactory.seed_confirmed_user(self.username, self.userpassword))
		self.browser.click_link_by_text('Sign out')
		assert self.browser.is_text_not_present('Signed in as %s'%self.username)
		assert self.browser.is_text_present('Sign in')

	# def test_index(self):
	# 	r = flapp.get('/')
	# 	assert r.okbr

	# def test_login_with_id(self):
	# 	self.login()
	# 	print self.browser.html
	# 	# print browser.html

# class TestRoutesHeadless(unittest.TestCase):

# 	def setUp(self):
# 		self.browser 

# 需要导入模块: from splinter import Browser [as 别名]
# 或者: from splinter.Browser import fill_form [as 别名]
class Client(object):
    """Proxy class which adds more functionatily to Splinter's Browser."""

    def __init__(self, browser_name='firefox', url=None):
        """Initial parameters for a web browser client.

        :param str browser_name: Name for the web browser type to instantiate.
        :param str url: The base url for your server.

        """
        self.browser = Browser(browser_name)
        # If a `url` is provided...
        if url is not None:
            # ...  use it ...
            self.base_url = url
        else:
            # ... else, use the one from configuration file
            self.base_url = conf.properties['url']

    def login(self, username=None, password=None):
        """Performs a login using the provided credentials.

        :param str username: A user name.
        :param str password: A user password.

        """

        if username is None:
            username = conf.properties['username']
        if password is None:
            password = conf.properties['password']

        # Fill the login form.
        self.browser.fill_form(
            {FLD_USERNAME: username, FLD_PASSWORD: password})
        # Click the 'Login' button
        self.browser.find_by_name(BTN_LOGIN).click()

    def logout(self):
        """Performs a logout."""
        # Position the mouse over the account menu to expose submenus.
        self.browser.find_by_id(MENU_ACCOUNT).mouse_over()
        # Then, click the logout menu
        self.browser.find_by_id(MENU_LOGOUT).click()

    def __getattr__(self, name):
        """Proxy attr lookup to self.browser.

        Allows calling Splinter's Browser methods directly. If `name` is not
        a method found in either `Browser` or `Client`, then ``AttributeError``
        is raised.

        :param str name: Name for a supported method.
        :raises: ``AttributeError``

        """
        attr = getattr(self.browser, name, None)
        if attr is None:
            super(Client, self).__getattribute__(name)

        return attr

    def __enter__(self):
        return self

    def __exit__(self, *exc):
        self.browser.__exit__(*exc)