(selenium+python)_UI 自动化 01_Mac 下 selenium 环境搭建

前言

Selenium 是一个用于 Web 网页 UI 自动化测试的开源框架，可以驱动浏览器模拟用户操作。支持多种平台 (Windows、Mac OS、Linux) 和多种浏览器 (IE、Firefox、Chrome、Safari)，可以用多种语言 (Java，Ruby，Python，Perl，PHP，C#) 编写测试用例。

selenium+python 环境搭建

python 环境安装

mac 上安装 python 环境可参考：Mac 版 - python 环境配置（一）：Python 下载安装

安装 selenium

打开终端 ->pip 安装（安装命令：pip3 install selenium）

安装浏览器驱动

安装 Chrome 浏览器驱动 ChromeDriver

1. 查看 Chrome 版本

设置 -> 关于 Chrome

2. 查找 Chrome 和 ChromeDriver 的对应关系

Chrome 和 ChromeDriver 的对应关系可参考：https://www.cnblogs.com/mini-monkey/p/12088721.html

3. 下载对应 ChromeDriver

ChromeDriver 下载地址：http://chromedriver.storage.googleapis.com/index.html

小编 1 中查看到的 chrome 版本为 79，故下载 ChromeDriver 79 版本

4. ChromeDriver 环境配置

进入 /usr/local/bin 目录（由于 Mac 该目录是隐藏的，所以可通过快捷键 command+shift+g 打开）

将解压的 ChromeDriver 拖拽到 bin 文件夹中

查看 ChromeDriver 版本：chromedriver --version

备注：输出 ChromeDriver 版本即安装成功

5. 编写脚本启动 Chrome 浏览器

1 # 启动Chrome
2 from selenium import webdriver
3 
4 driver = webdriver.Chrome()
5 driver.get(''http://www.baidu.com/'')  # 打开百度

运行脚本，打开百度页

appium+python+selenium测试配置

# -*- coding: utf-8 -*-

from appium import webdriver
from time import sleep

CAPS = {
    "deviceName": " MEIZU_E3","platformName": "Android","platformVersion": "7.1.1",#‘app‘ = ‘E:/autotestingPro/app/UCliulanqi_701.apk‘  #指向.apk文件，如果设置appPackage和appActivity，那么这项会被忽略
    "appPackage": " com.meizu.flyme.flymebbs","appActivity": ".ui.LoadingActivity",#"noreset": True,
}

driver = webdriver.Remote(‘http://localhost:4723/wd/hub‘,CAPS)
sleep(3)

# coding: utf-8
import unittest
from appium import webdriver
from selenium.webdriver.support.ui import webdriverwait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

desired_caps = {‘platformName‘: ‘Android‘,‘platformVersion‘: ‘5.1.1‘,‘deviceName‘: ‘MEIZU_E3‘,"appPackage": " com.meizu.flyme.flymebbs",}
appium_server = ‘http://localhost:4723/wd/hub‘


class LearnAppiumTest(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Remote(appium_server,desired_caps)

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

    def test_01(self):
        text_view = self.driver.find_element_by_id("text_view")
        assert text_view.text == ‘Hello World! Hello World!‘  # 测试应该不通过

    def test_02(self):
        wait = webdriverwait(self.driver,6)
        wait.until(EC.element_to_be_clickable((By.ID,‘button‘)))
        button = self.driver.find_element_by_id("button")
        button.click()

        wait = webdriverwait(self.driver,6)
        wait.until(EC.presence_of_element_located((By.ID,‘text_view‘)))
        text_view = self.driver.find_element_by_id("text_view")
        assert text_view.text == ‘3‘  # 测试应该通过

if __name__ == ‘__main__‘:
    unittest.main()

java+selenium, python+selenium浏览界面,滑动页面

用到selenium的时候,有时需要滑动屏幕,模拟浏览,这时候就可以用到下边的代码了:

首先是java的selenium滑屏代码(不知道为啥后边就乱了排版,自己调整下就好~)

private static Random random = new Random();

private void pretendScrolling(JavascriptExecutor js, int sum) throws InterruptedException {
    sum--;
 int step;
 int length;
 switch (sum) {
 case 0:
 step = random.nextInt(30) + 1 + 50;
 length = random.nextInt(3000) + 1 + 3000;
 smoothlyScrolling(js, 0, step, length, true);
 smoothlyScrolling(js, 0, step, length, false);

 smoothlyScrolling(js, 0, step, length, true);
 smoothlyScrolling(js, length, step, 8000, true);

 step = random.nextInt(20) + 1 + 80;
 smoothlyScrolling(js, 0, step, 8000, false);

 length = random.nextInt(2000) + 1 + 3000;
 smoothlyScrolling(js, 0, step, length, true);
 smoothlyScrolling(js, 0, 20, length, false);
 break;
 case 1:
 step = random.nextInt(10) + 1 + 40;
 smoothlyScrolling(js, 0, step, 6000, true);
 Thread.sleep(3000);
 smoothlyScrolling(js, 0, step, 6000, false);

 length = random.nextInt(1500) + 1 + 1000;
 step = random.nextInt(10) + 1 + 40;
 Thread.sleep(3000);
 smoothlyScrolling(js, 0, step, length, true);
 Thread.sleep(5000);
 step = random.nextInt(10) + 1 + 40;
 smoothlyScrolling(js, length, step, 7000, true);
 Thread.sleep(3000);

 step = random.nextInt(20) + 1 + 80;
 smoothlyScrolling(js, 0, step, 8000, false);
 Thread.sleep(3000);
 break;
 case 2:
 step = random.nextInt(10) + 1 + 30;
 length = random.nextInt(1300) + 1 + 1000;
 smoothlyScrolling(js, 0, step, length, true); Thread.sleep(8000); step = random.nextInt(10) + 1 + 20; smoothlyScrolling(js, length, step, 6000, true); Thread.sleep(3000); length = random.nextInt(1500) + 1 + 1500; step = random.nextInt(20) + 1 + 40; smoothlyScrolling(js, length, step, 6000, false); Thread.sleep(3000); step = random.nextInt(30) + 1 + 70;
 smoothlyScrolling(js, length, step, 6000, true);
 Thread.sleep(4000);
 step = random.nextInt(20) + 1 + 30;
 smoothlyScrolling(js, 0, step, 6000, false);
 Thread.sleep(3000);
 break;
 case 3:
 step = random.nextInt(10) + 1 + 30;
 smoothlyScrolling(js, 0, step, 7000, true);
 Thread.sleep(3000);
 step = random.nextInt(30) + 1 + 20;
 smoothlyScrolling(js, 0, step, 7000, false);
 Thread.sleep(3000);
 break;
 case 4:
 step = random.nextInt(10) + 1 + 50;
 smoothlyScrolling(js, 0, step, 7000, true);
 Thread.sleep(3000);
 length = random.nextInt(1500) + 1 + 2000;
 step = random.nextInt(25) + 1 + 20;
 smoothlyScrolling(js, length, step, 7000, false);
 Thread.sleep(3000);
 step = random.nextInt(20) + 1 + 30;
 smoothlyScrolling(js, length, step, 7000, true);
 Thread.sleep(3000);
 step = random.nextInt(20) + 1 + 40;
 smoothlyScrolling(js, 0, step, 7000, false);
 Thread.sleep(2000);
 break;
 case 5:
 step = random.nextInt(20) + 1 + 30;
 smoothlyScrolling(js, 0, step, 2500, true);
 Thread.sleep(3000);
 step = random.nextInt(30) + 1 + 40; 
 smoothlyScrolling(js, 0, step, 2500, false);
 Thread.sleep(3000);
 step = random.nextInt(20) + 1 + 30;
 smoothlyScrolling(js, 0, step, 7000, true);
 Thread.sleep(6000);
 step = random.nextInt(20) + 1 + 30;
 smoothlyScrolling(js, 0, step, 7000, false);
 Thread.sleep(2000);
 break;
 default:
 case 6:
 step = random.nextInt(30) + 1 + 30;
 length = random.nextInt(1500) + 1 + 2500;
 smoothlyScrolling(js, 0, step, length, true);
 step = random.nextInt(30) + 1 + 70;
 smoothlyScrolling(js, 0, step, length, false);
 step = random.nextInt(20) + 1 + 40;
 smoothlyScrolling(js, 0, step, 7000, true);
 step = random.nextInt(25) + 1 + 20;
 smoothlyScrolling(js, 0, step, 7000, false);
 Thread.sleep(3000);
 step = random.nextInt(25) + 1 + 20;
 length = random.nextInt(1500) + 1 + 3000;
 smoothlyScrolling(js, 0, step, length, true);
 Thread.sleep(3000);
 step = random.nextInt(15) + 1 + 30;
 smoothlyScrolling(js, 0, step, length, false);
 break;
 }
}

private void smoothlyScrolling(JavascriptExecutor js, int floor, int step, int celling, boolean direction) {
 if (direction) {
 for (int i = floor; i <= celling; i += step) {
 js.executeScript("scrollTo(0," + i + ")");
 }
 } else {
 for (int i = celling; i >= floor; i -= step) {
 js.executeScript("scrollTo(0," + i + ")");
 }
 }
}

用法如下:



两个参数,其中js表示的是driver, sum是一个随机数,表示随机的从7中浏览方式之间选一种


再然后是在python selenium中的应用,我专门写了一个类出来存放浏览界面的代码,然后在需要用到它的地方导入,引用

import random
import time


class PretendScrolling:
    @staticmethod
 def pretend_scrolling(driver, sum):
 step = 1
 length = 1
 if sum == 1:
 step = random.randint(0, 30) + 1 + 50
 length = random.randint(0, 3000) + 1 + 3000
 smoothlyScrolling(driver, 0, step, length, True)
 smoothlyScrolling(driver, 0, step, length, False)

 smoothlyScrolling(driver, 0, step, length, True)
 smoothlyScrolling(driver, length, step, 8000, False)
 step = random.randint(0, 20)+ 1+80
 smoothlyScrolling(driver, 0 ,step, 8000, False)

 length = random.randint(0, 2000) + 1 + 3000
 smoothlyScrolling(driver, 0 , step, length, True)
 smoothlyScrolling(driver, 0 , 20, length, False)
 elif sum == 2:
 step = random.randint(0, 10) + 1 + 40
 smoothlyScrolling(driver, 0, step, 6000, True)
 time.sleep(3)
 smoothlyScrolling(driver, 0, step, 6000, False)

 length = random.randint(0, 1500) + 1 + 1000
 step = random.randint(0, 10) + 1 + 40
 time.sleep(3)
 smoothlyScrolling(driver, 0, step, length, True)
 time.sleep(5)
 step = random.randint(0, 10)+1+40
 smoothlyScrolling(driver, length, step, 7000, True)
 time.sleep(3)

 step = random.randint(0, 20)+1+80
 smoothlyScrolling(driver, 0, step, 8000, False)
 time.sleep(3)
 elif sum == 3:
 step = random.randint(0, 10) + 1 + 30
 length = random.randint(0, 1300) + 1 + 1000
 smoothlyScrolling(driver, 0, step, length, True)
 time.sleep(8)
 step = random.randint(0, 10) + 1 + 20
 smoothlyScrolling(driver, length, step, 6000, True)
 time.sleep(3)
 length = random.randint(0, 1500) + 1 + 1500
 step = random.randint(0, 20) + 1 + 40
 smoothlyScrolling(driver, length, step, 6000, False)
 time.sleep(3)
 step = random.randint(0, 30) + 1 + 70
 smoothlyScrolling(driver, length, step, 6000, True)
 time.sleep(4)
 step = random.randint(0, 20) + 1 + 30
 smoothlyScrolling(driver, 0, step, 6000, False)
 time.sleep(3)
 elif sum == 4:
 step = random.randint(0, 10) + 1 + 30
 smoothlyScrolling(driver, 0, step, 7000, True)
 time.sleep(3)
 step = random.randint(0, 30) + 1 + 20
 smoothlyScrolling(driver, 0, step, 7000, False)
 time.sleep(3)
 elif sum == 5:
 step = random.randint(0, 10) + 1 + 50
 smoothlyScrolling(driver, 0, step, 7000, True)
 time.sleep(3)
 length = random.randint(0, 1500) + 1 + 2000
 step = random.randint(0, 25) + 1 + 20
 smoothlyScrolling(driver, length, step, 7000, False)
 time.sleep(3)
 step = random.randint(0, 20) + 1 + 30
 smoothlyScrolling(driver, length, step, 7000, True) time.sleep(3) step = random.randint(0, 20) + 1 + 40 smoothlyScrolling(driver, 0, step, 7000, False) time.sleep(2) elif sum == 6: step = random.randint(0, 20) + 1 + 30 smoothlyScrolling(driver, 0, step, 2500, True) time.sleep(3)
 step = random.randint(0, 30) + 1 + 40
 smoothlyScrolling(driver, 0, step, 2500, False)
 time.sleep(3)
 step = random.randint(0, 20) + 1 + 30
 smoothlyScrolling(driver, 0, step, 7000, True)
 time.sleep(6)
 step = random.randint(0, 20) + 1 + 30
 smoothlyScrolling(driver, 0, step, 7000, False)
 time.sleep(2)
 elif sum == 7:
 step = random.randint(0, 30) + 1 + 30
 length = random.randint(0, 1500) + 1 + 2500
 smoothlyScrolling(driver, 0, step, length, True)
 step = random.randint(0, 30) + 1 + 70
 smoothlyScrolling(driver, 0, step, length, False)
 step = random.randint(0, 20) + 1 + 40
 smoothlyScrolling(driver, 0, step, 7000, True)
 step = random.randint(0, 25) + 1 + 20
 smoothlyScrolling(driver, 0, step, 7000, False)
 time.sleep(3)
 step = random.randint(0, 25) + 1 + 20
 length = random.randint(0, 1500) + 1 + 3000
 smoothlyScrolling(driver, 0, step, length, True)
 time.sleep(3)
 step = random.randint(0, 15) + 1 + 30
 smoothlyScrolling(driver, 0, step, length, False)
 else:
 pass



#(不知道为啥会乱排版,这是另一个方法)def smoothlyScrolling(driver, floor, step, celling, direction):
 if direction is True:
 i = floor
 while i <= celling:
 i += step
 jscript = "window.scrollTo(1, {height_i})".format(height_i=i)
 driver.execute_script(jscript)
 else:
 i = celling
 while i >= floor:
 i -= step
 jscript = "window.scrollTo(1, {height_i})".format(height_i=i)
 driver.execute_script(jscript)

在python的其它类中引用如下:
首先先在相关类中引入滚动界面的类

然后调用:

以上就是selenium里边滑动界面的一组方法了,支持java和python.

 





因为图片好像没有加载出来,所以再放一下.然后也不知道为啥排版会乱,要用的话自己调整一下即可.

Python selenium —— 一定要会用selenium的等待，三种等待方式解读

发现太多人不会用等待了，博主今天实在是忍不住要给大家讲讲等待的必要性。

很多人在群里问，这个下拉框定位不到、那个弹出框定位不到…各种定位不到，其实大多数情况下就是两种问题：1 有frame，2 没有加等待。殊不知，你的代码运行速度是什么量级的，而浏览器加载渲染速度又是什么量级的，就好比闪电侠和凹凸曼约好去打怪兽，然后闪电侠打完回来之后问凹凸曼你为啥还在穿鞋没出门？凹凸曼分分中内心一万只羊驼飞过，欺负哥速度慢，哥不跟你玩了，抛个异常撂挑子了。

那么怎么才能照顾到凹凸曼缓慢的加载速度呢？只有一个办法，那就是等喽。说到等，又有三种等法，且听博主一一道来：

1. 强制等待
第一种也是最简单粗暴的一种办法就是强制等待sleep(xx)，强制让闪电侠等xx时间，不管凹凸曼能不能跟上速度，还是已经提前到了，都必须等xx时间。

看代码：

# -*- coding: utf-8 -*-
from selenium import webdriver
from time import sleep

driver = webdriver.Firefox()
driver.get(''https://huilansame.github.io'')

sleep(3) # 强制等待3秒再执行下一步

print driver.current_url
driver.quit()
1
2
3
4
5
6
7
8
9
10
11
这种叫强制等待，不管你浏览器是否加载完了，程序都得等待3秒，3秒一到，继续执行下面的代码，作为调试很有用，有时候也可以在代码里这样等待，不过不建议总用这种等待方式，太死板，严重影响程序执行速度。

2. 隐性等待
第二种办法叫隐性等待，implicitly_wait(xx)，隐性等待的意义是：闪电侠和凹凸曼约定好，不论闪电侠去哪儿，都要等凹凸曼xx秒，如果凹凸曼在这段时间内来了，则俩人立即出发去打怪兽，如果凹凸曼在规定时间内没到，则闪电侠自己去，那自然就等着凹凸曼给你抛异常吧。

看代码：

# -*- coding: utf-8 -*-
from selenium import webdriver

driver = webdriver.Firefox()
driver.implicitly_wait(30) # 隐性等待，最长等30秒
driver.get(''https://huilansame.github.io'')

print driver.current_url
driver.quit()
1
2
3
4
5
6
7
8
9
隐形等待是设置了一个最长等待时间，如果在规定时间内网页加载完成，则执行下一步，否则一直等到时间截止，然后执行下一步。注意这里有一个弊端，那就是程序会一直等待整个页面加载完成，也就是一般情况下你看到浏览器标签栏那个小圈不再转，才会执行下一步，但有时候页面想要的元素早就在加载完成了，但是因为个别js之类的东西特别慢，我仍得等到页面全部完成才能执行下一步，我想等我要的元素出来之后就下一步怎么办？有办法，这就要看selenium提供的另一种等待方式——显性等待wait了。

需要特别说明的是：隐性等待对整个driver的周期都起作用，所以只要设置一次即可，我曾看到有人把隐性等待当成了sleep在用，走哪儿都来一下…

3. 显性等待
第三种办法就是显性等待，WebDriverWait，配合该类的until()和until_not()方法，就能够根据判断条件而进行灵活地等待了。它主要的意思就是：程序每隔xx秒看一眼，如果条件成立了，则执行下一步，否则继续等待，直到超过设置的最长时间，然后抛出TimeoutException。

先看个代码示例：

# -*- coding: utf-8 -*-
from selenium import webdriver
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

driver = webdriver.Firefox()
driver.implicitly_wait(10) # 隐性等待和显性等待可以同时用，但要注意：等待的最长时间取两者之中的大者
driver.get(''https://huilansame.github.io'')
locator = (By.LINK_TEXT, ''CSDN'')

try:
WebDriverWait(driver, 20, 0.5).until(EC.presence_of_element_located(locator))
print driver.find_element_by_link_text(''CSDN'').get_attribute(''href'')
finally:
driver.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
上例中，我们设置了隐性等待和显性等待，在其他操作中，隐性等待起决定性作用，在WebDriverWait..中显性等待起主要作用，但要注意的是：最长的等待时间取决于两者之间的大者，此例中为20，如果隐性等待时间 > 显性等待时间，则该句代码的最长等待时间等于隐性等待时间。

我们主要用到了WebDriverWait类与expected_conditions模块，下面博主带大家细看一下这两个模块：

WebDriverWait
wait模块的WebDriverWait类是显性等待类，先看下它有哪些参数与方法：

selenium.webdriver.support.wait.WebDriverWait（类）
1
__init__

driver: 传入WebDriver实例，即我们上例中的driver
timeout: 超时时间，等待的最长时间（同时要考虑隐性等待时间）
poll_frequency: 调用until或until_not中的方法的间隔时间，默认是0.5秒
ignored_exceptions: 忽略的异常，如果在调用until或until_not的过程中抛出这个元组中的异常，
则不中断代码，继续等待，如果抛出的是这个元组外的异常，则中断代码，抛出异常。默认只有NoSuchElementException。
1
2
3
4
5
until

method: 在等待期间，每隔一段时间（__init__中的poll_frequency）调用这个传入的方法，直到返回值不是False
message: 如果超时，抛出TimeoutException，将message传入异常
1
2
until_not

与until相反，until是当某元素出现或什么条件成立则继续执行，
until_not是当某元素消失或什么条件不成立则继续执行，参数也相同，不再赘述。
1
2
看了以上内容基本上很清楚了，调用方法如下：

WebDriverWait(driver, 超时时长, 调用频率, 忽略异常).until(可执行方法, 超时时返回的信息)
1
这里需要特别注意的是until或until_not中的可执行方法method参数，很多人传入了WebElement对象，如下：

WebDriverWait(driver, 10).until(driver.find_element_by_id(''kw'')) # 错误
1
这是错误的用法，这里的参数一定要是可以调用的，即这个对象一定有 __call__() 方法，否则会抛出异常：

TypeError: ''xxx'' object is not callable
1
在这里，你可以用selenium提供的 expected_conditions 模块中的各种条件，也可以用WebElement的 is_displayed() 、is_enabled()、is_selected() 方法，或者用自己封装的方法都可以，那么接下来我们看一下selenium提供的条件有哪些：

expected_conditions
expected_conditions是selenium的一个模块，其中包含一系列可用于判断的条件：

selenium.webdriver.support.expected_conditions（模块）
1
以下两个条件类验证title，验证传入的参数title是否等于或包含于driver.title
title_is
title_contains

以下两个条件验证元素是否出现，传入的参数都是元组类型的locator，如(By.ID, ‘kw’)
顾名思义，一个只要一个符合条件的元素加载出来就通过；另一个必须所有符合条件的元素都加载出来才行
presence_of_element_located
presence_of_all_elements_located

以下三个条件验证元素是否可见，前两个传入参数是元组类型的locator，第三个传入WebElement
第一个和第三个其实质是一样的
visibility_of_element_located
invisibility_of_element_located
visibility_of

以下两个条件判断某段文本是否出现在某元素中，一个判断元素的text，一个判断元素的value
text_to_be_present_in_element
text_to_be_present_in_element_value

以下条件判断frame是否可切入，可传入locator元组或者直接传入定位方式：id、name、index或WebElement
frame_to_be_available_and_switch_to_it

以下条件判断是否有alert出现
alert_is_present

以下条件判断元素是否可点击，传入locator
element_to_be_clickable

以下四个条件判断元素是否被选中，第一个条件传入WebElement对象，第二个传入locator元组
第三个传入WebElement对象以及状态，相等返回True，否则返回False
第四个传入locator以及状态，相等返回True，否则返回False
element_to_be_selected
element_located_to_be_selected
element_selection_state_to_be
element_located_selection_state_to_be

最后一个条件判断一个元素是否仍在DOM中，传入WebElement对象，可以判断页面是否刷新了
staleness_of

上面是所有17个condition，与until、until_not组合能够实现很多判断，如果能自己灵活封装，将会大大提高脚本的稳定性。

今天关于[Selenium][Python][CSV]在 selenium python 中加载测试的特定列和selenium读取csv的讲解已经结束，谢谢您的阅读，如果想了解更多关于(selenium+python)_UI 自动化 01_Mac 下 selenium 环境搭建、appium+python+selenium测试配置、java+selenium, python+selenium浏览界面,滑动页面、Python selenium —— 一定要会用selenium的等待，三种等待方式解读的相关知识，请在本站搜索。