精华内容
下载资源
问答
  • selenium webdriver定位到元素的五种原因及解决办法
    千次阅读
    2018-03-19 08:56:58
    1.动态id定位不到元素
    for example:
            //WebElement xiexin_element = driver.findElement(By.id("_mail_component_82_82"));
            WebElement xiexin_element = driver.findElement(By.xpath("//span[contains(.,'写 信')]"));
            xiexin_element.click();

       上面一段代码注释掉的部分为通过id定位element的,但是此id“_mail_component_82_82”后面的数字会随着你每次登陆而变化,此时就无法通过id准确定位到element。
       所以推荐使用xpath的相对路径方法查找到该元素。

    2.iframe原因定位不到元素

        由于需要定位的元素在某一个frame里边,所以有时通过单独的id/name/xpath还是定位不到此元素
    比如以下一段xml源文件:
    <iframe id="left_frame" scrolling="auto" frameborder="0" src="index.php?m=Index&a=Menu" name="left_frame" noresize="noresize" style="height: 100%;visibility: inherit; width: 100%;z-index: 1">
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <body class="menuBg">
    <div id="menu_node_type_0">
    <table width="193" cellspacing="0" cellpadding="0" border="0">
    <tbody>
    <tr>
    <tr>
    <td id="c_1">
    <table class="menuSub" cellspacing="0" cellpadding="0" border="0" align="center">
    <tbody>
    <tr class="sub_menu">
    <td>
    <a href="index.php?m=Coupon&a=SearchCouponInfo" target="right_frame">密码重置</a>
    </td>
    </tr>

    原本可以通过
    WebElement element = driver.findElement(By.linkText("
    密码重置"));
    来定位此元素,但是由于该元素在
    iframe id="left_frame"这个frame里边 所以需要先通过定位frame然后再定位frame里边的某一个元素的方法定位此元素
    WebElement element =driver.switchTo().frame("left_frame").findElement(
    By.linkText("密码重置"));

    3.不在同一个frame里边查找元素
    大家可能会遇到页面左边一栏属于
    left_frame,右侧属于right_frame的情况,此时如果当前处在
    left_frame,就无法通过id定位到right_frame的元素。此时需要通过以下语句切换到默认的content
    driver.switchTo().defaultContent();

    例如当前所在的frame为left_frame

           WebElement xiaoshoumingxi_element = driver.switchTo().frame("left_frame").findElement(By.linkText("销售明细"));
           xiaoshoumingxi_element.click();

    需要切换到right_frame      
           driver.switchTo().defaultContent();
           
           Select quanzhong_select2 = new Select(driver.switchTo().frame("right_frame").findElement(By.id("coupon_type_str")));
           quanzhong_select2.selectByVisibleText("售后0小时");

    4. xpath描述错误
    这个是因为在描述路径的时候没有按照xpath的规则来写 造成找不到元素的情况出现

    5.点击速度过快 页面没有加载出来就需要点击页面上的元素
    这个需要增加一定等待时间,显示等待时间可以通过WebDriverWait 和util来实现
    例如:
           //用WebDriverWait和until实现显示等待 等待欢迎页的图片出现再进行其他操作
           WebDriverWait wait = (new WebDriverWait(driver,10));
           wait.until(new ExpectedCondition<Boolean>(){
               public Boolean apply(WebDriver d){
                   boolean loadcomplete = d.switchTo().frame("right_frame").findElement(By.xpath("//center/div[@class='welco']/img")).isDisplayed();
                   return loadcomplete;
               }
           });
    也可以自己预估时间通过Thread.sleep(5000);//等待5秒 这个是强制线程休息

    6.firefox安全性强,不允许跨域调用出现报错
    错误描述:uncaught exception: [Exception... "Component returned failure code: 0x80004005 (NS_ERROR_FAILURE) [nsIDOMNSHTMLDocument.execCommand]" nsresult: "0x80004005 (NS_ERROR_FAILURE)" location:

    解决办法:
    这是因为firefox安全性强,不允许跨域调用。 
    Firefox 要取消XMLHttpRequest的跨域限制的话,第一
    是从 about:config 里设置 signed.applets.codebase_principal_support = true; (地址栏输入about:config 即可进行firefox设置)
    第二就是在open的代码函数前加入类似如下的代码: try { netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead"); } catch (e) { alert("Permission UniversalBrowserRead denied."); } 

    更多相关内容
  • WebDriver API 提供了一个与平台和语言无关的接口,允许程序控制行为并检查 Web 浏览器的状态。 它主要用于自动化测试,但也可用于出于其他目的控制浏览器。 WebDriver API 通过 http 请求访问,数据使用 JSON ...
  • selenium webdriver入门

    2022-01-02 14:29:05
    WebDriver可以像用户一样驱动原生浏览器,无论是在本地服务器还是在使用Selenium服务器的远程机器上,都标志着浏览器自动化的一个飞跃。 Selenium WebDriver也是控制浏览器代码运行的一种实现方式,通常被简称为...

    ​概要

    WebDriver可以像用户一样驱动原生浏览器,无论是在本地服务器还是在使用Selenium服务器的远程机器上,都标志着浏览器自动化的一个飞跃。

    Selenium WebDriver也是控制浏览器代码运行的一种实现方式,通常被简称为WebDriver。

    它有以下特点:

    • WebDriver框架设计简单、编程接口设计简明。

    • WebDriver是一个紧凑的面向对象的API。

    • 它能有效地驱动浏览器。

    原理

    组件

    使用WebDriver构建一个测试套件,需要你事先了解并能熟练地使用一些不同的组件。就像软件一样,不同的人可以使用不同的术语来表达同一个想法。下面是本说明中术语使用的分类。

    术语

    • API:应用程序编程接口,用来操作WebDriver的一组 "命令"。

    • 库:一个代码模块,它包含API和实现特定功能的代码。

    • 驱动程序:负责控制实际的浏览器。大多数驱动程序是由浏览器厂商自己创建的。驱动程序通常是可执行模块,与浏览器本身一起在系统上运行,而不是在执行测试套件的系统上。PS:有些人把驱动程序也称为代理。

    • 框架:用于支持WebDriver套件的附加库。这些框架可能是测试框架,如JUnit或NUnit。它们也可以是支持自然语言功能的框架,如Cucumber或Robotium。框架也可能被编写和使用,如操作或配置被测系统、数据创建、测试等。

    框架的作用

    WebDriver通过驱动程序与浏览器对话,属于双向通信。WebDriver通过驱动程序向浏览器传递命令,并通过同样的途径接收信息。

    驱动程序是针对浏览器的,如Chrome/Chromium的ChromeDriver,Mozilla Firefox的GeckoDriver等。该驱动程序与浏览器运行在同一系统上。

    上面这个简单的例子就是直接通信。当然,与浏览器通信也可以通过Selenium Server或RemoteWebDriver进行远程通信。RemoteWebDriver与驱动程序和浏览器运行在相同的系统上。

    远程通信也可以使用Selenium Server或Selenium Grid来进行,这两种方式都会与主机系统上的驱动程序进行对话。

    WebDriver有且仅有的职责:通过上述任何一种方式与浏览器进行通信。WebDriver对测试本身一窍不通:它不知道如何比较事物、断言通过或失败,当然也不知道测试报告或Given/When/Then语法。

    但这也是各种测试框架发挥作用的关键点,至少你需要一个与语言绑定相匹配的测试框架,比如.NET的NUnit,Java的JUnit,Ruby的RSpec等。

    测试框架负责运行和执行WebDriver以及测试中的相关步骤。因此,你可以认为它看起来类似于下面的图片。

    自然语言框架/工具(如Cucumber)可能作为上图中那个测试框架框的一部分而存在,也可能将测试框架完全包裹在自己的实现中。

    驱动依赖

    通过WebDriver,Selenium可以支持市面上所有主流的浏览器,如Chrom(ium)、Firefox、Internet Explorer、Opera和Safari。在可能的情况下,WebDriver会使用浏览器内置功能支持来驱动浏览器以实现自动化,尽管不是所有的浏览器都能支持远程控制。

    WebDriver的目标是尽可能地模拟真实用户与浏览器的交互。

    尽管所有的驱动程序都共享一个用于控制浏览器的面向用户的界面,但它们在设置浏览器会话的方式略有不同。由于许多驱动程序的实现是由第三方提供的,所以它们并不包含在标准的Selenium发行版中。

    驱动程序实例化、配置文件管理和各种浏览器特定的设置等,使用不同浏览器有不同的要求。本节了让你了解使用不同浏览器的基本要求。

    将可执行文件添加PATH路径

    大多数驱动程序需要一个额外的可执行文件,以便Selenium与浏览器通信。你可以在启动WebDriver之前手动指定可执行文件的位置,但是这可能会降低你的测试的可移植性,因为可执行文件需要在每台机器上的同一个地方,或者在你的测试代码库中包含可执行文件。

    通过在你的系统路径中添加一个包含WebDriver二进制文件的文件夹,Selenium将能够找到额外的二进制文件,而不需要你的测试代码找到驱动的确切位置。

    创建一个目录来放置可执行文件,比如/opt/WebDriver/bin,将该目录添加到您的PATH中。

    export PATH=$PATH:/opt/WebDriver/bin >> ~/.profile
    

    现在你已经准备环境了。打开的命令提示输入一个新的命令,输入上一步创建的文件夹中的一个二进制文件的名称,例如:

     
    
    chromedriver
    

    如果您的PATH配置正确,您将看到一些与启动驱动程序有关的输出:

    Chromium/Chrome

    要驱动Chrome或Chromium,你必须下载chromedriver,并将其放在系统路径上的文件夹中。

    在Linux或macOS上,这意味着要修改PATH环境变量。你可以通过执行下面的命令来查看系统路径中由冒号分隔的目录。

    echo $PATH

    要将chromedriver包含在路径上,如果还没有的话,请确保包含chromedriver二进制的父目录。下面这行将设置PATH环境变量的当前内容,加上冒号后添加的额外路径。

    $ export PATH="$PATH:/path/to/chromedriver"

    配置好chromedriver后,你可以从任何目录下执行chromedriver。

    实例化一个Chrome/Chromium会话,您可以执行以下操作:

     
    
    #Simple assignment
    from selenium.webdriver import Chrome
    
    driver = Chrome()#Or use the context managerfrom selenium.webdriver import Chrome
    with Chrome() as driver:        #your code inside this indent

    操作浏览器

    • 浏览器导航

    启动浏览器后,首先要做的就是打开网站,这可以通过一行代码来实现。

    driver.get("https://selenium.dev")
    • 获取当前 URL

    可以使用以下方法从浏览器的地址栏读取当前的URL。

    driver.current_url
    
    • 后退Back

    driver.back()
    • 前进Forward

    driver.forward()
    • 刷新Refresh

     
    
    driver.refresh()
    

    • 获取网站title

     
    
    driver.title
    
    • 窗口和标签

    WebDriver不区分窗口和标签。如果你的网站打开了一个新的标签页或窗口,Selenium会让你使用一个窗口句柄来处理它。每个窗口都有一个唯一的标识符,它在一个会话中保持不变。你可以通过使用以下方法获得当前窗口的窗口句柄。

    driver.current_window_handle
    
    • 切换窗口或标签

    点击一个在新窗口中打开的链接会将新窗口或标签页集中在屏幕上,但WebDriver不会知道操作系统认为哪个窗口是活动的。要使用新窗口,您需要切换到新窗口。如果你只打开了两个标签页或窗口,并且你知道你从哪个窗口开始,通过消除过程,你可以在WebDriver能看到的两个窗口或标签页上循环,并切换到不是原来的那个窗口。

    然而,Selenium 4提供了一个新的api NewWindow,它可以创建一个新的标签(或)新的窗口,并自动切换到它。

     
    
    from selenium import webdriver
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    # Start the driver
    with webdriver.Firefox() as driver:
        # Open URL
        driver.get("https://seleniumhq.github.io")
    
    
        # Setup wait for later
        wait = WebDriverWait(driver, 10)
    
    
        # Store the ID of the original window
        original_window = driver.current_window_handle
    
    
        # Check we don't have other windows open already
        assert len(driver.window_handles) == 1
    
        # Click the link which opens in a new window
        driver.find_element(By.LINK_TEXT, "new window").click()
    
    
        # Wait for the new window or tab
        wait.until(EC.number_of_windows_to_be(2))
    
    
        # Loop through until we find a new window handle
        for window_handle in driver.window_handles:
            if window_handle != original_window:
                driver.switch_to.window(window_handle)
                break
        # Wait for the new tab to finish loading content
        wait.until(EC.title_is("SeleniumHQ Browser Automa

    创建新的窗口/新的标签页、切换

    创建一个新的窗口(或)标签,并将新窗口或标签集中在屏幕上。您不需要切换就可以使用新窗口(或)标签页。如果你有两个以上的窗口(或)标签页被打开,而不是新窗口,你可以在WebDriver可以看到的两个窗口或标签页上循环,并切换到不是原来的那个窗口或标签页。

     
    
    # Opens a new tab and switches to new tab
    driver.switch_to.new_window('tab')
    
    # Opens a new window and switches to new windowdriver.switch_to.new_window('window'
    

    • 关闭窗口/标签页

    当你完成一个窗口或标签页的操作,并且它不是浏览器中最后一个打开的窗口或标签页时,你应该关闭它,并切换回之前使用的窗口。假设你遵循了上一节的代码示例,你将会把之前的窗口句柄存储在一个变量中。

     
    
    #Close the tab or window
    driver.close()
    
    #Switch back to the old tab or windowdriver.switch_to.window(original_window)

    在关闭窗口后忘记切换到另一个窗口句柄,将使WebDriver在已经关闭的页面上执行,并将触发No Such Window异常,必须切换回一个有效的窗口句柄才能继续执行。

    在会话结束时退出浏览器

    当你完成浏览器会话时,你应该调用退出,而不是关闭。

     
    
    driver.quit()
    

    Quit的作用:

    • 关闭所有与WebDriver会话相关联的窗口和标签。

    • 关闭浏览器进程

    • 关闭后台驱动进程

    • 通知Selenium Grid浏览器不再使用,以便它可以被另一个会话使用(如果你使用Selenium Grid)。

    如果没有调用退出,将会留下额外的后台进程和端口在你的机器上运行,这可能会导致后续问题。

    一些测试框架提供了一些方法和注释,你可以在测试结束时挂到这些方法和注释上进行拆解。

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

    如果不是在测试上下文中运行WebDriver,你可以考虑使用大多数语言提供的try / finally,这样异常仍然会清理WebDriver会话。

     
    
    try:
        #WebDriver code here...
    
    finally:        driver.quit()

    Python的WebDriver现在支持python上下文管理器,当使用with关键字时,它可以在执行结束时自动退出驱动程序。

     
    
    with webdriver.Firefox() as driver:
    # WebDriver code here...
    
    # WebDriver will automatically quit after indentation

    Frames and Iframes

    Frames是一种从同一域名上的多个文档构建网站布局的手段,现已被淘汰。除非你使用的是 HTML5 之前的 webapp,否则你不太可能使用它们。Iframes允许从一个完全不同的域中插入一个文档,并且至今仍然被普遍使用。

    如果你需要使用Frames或iframe,WebDriver允许你以同样的方式使用它们。如果我们使用浏览器开发工具检查iframe中的button元素,html包含以下内容:

     
    
    <div id="modal">
      <iframe id="buttonframe" name="myframe"  src="https://seleniumhq.github.io">
       <button>Click here</button> </iframe></div>
    
     
    

    如果不是iframe,我们可能会使用以下操作来点击按钮:

     
    
    driver.find_element(By.TAG_NAME, 'button').click()
    

    然而,如果在iframe之外没有按钮,你可能会得到一个no such element错误。这是因为Selenium只知道顶层文档中的元素。为了与按钮交互,我们需要首先切换到框架,就像我们切换窗口一样,WebDriver提供了三种切换到框架的方法。

    WebElement

    使用WebElement进行切换是最灵活的选择。你可以使用你喜欢的选择器找到框架并切换到它。

     
    
    # Store iframe web element
    iframe = driver.find_element(By.CSS_SELECTOR, "#modal > iframe")
    # switch to selected iframe
    driver.switch_to.frame(iframe)
    # Now click on button
    driver.find_element(By.TAG_NAME, 'button').click()
    • name or ID

    如果你的frames或iframe有一个id或name属性,可以用这个属性代替。如果名字或ID在页面上不是唯一的,那么第一个找到的名字将被切换到。

     
    
    # Still witch frame by id
    driver.switch_to.frame('buttonframe')
    
    # Now, Click on the buttondriver.find_element(By.TAG_NAME, 'button').click()
    
    • 使用索引

    也可以使用frames的索引,如可以使用JavaScript中的window.frames来查询。

    driver.switch_to.frame(1)
    • 窗口管理

    获取窗口size

     
    
    # Access each dimension individually
    width = driver.get_window_size().get("width")
    height = driver.get_window_size().get("height")
    # Or store the dimensions and query them later
    size = driver.get_window_size()
    width1 = size.get("width")
    height1 = size.get("height")
    • 设置窗口size

     
    
    driver.set_window_size(1024, 768)

    获取窗口位置

    # Access each dimension individually
    x = driver.get_window_position().get('x')
    y = driver.get_window_position().get('y')
    # Or store the dimensions and query them later
    position = driver.get_window_position()
    x1 = position.get('x')
    y1 = position.get('y')

     
    
    • 设置窗口位置

     
    
    driver.set_window_position(0, 0)
    

    窗口最大化

     
    
    driver.maximize_window()
    

    窗口最小化

    最小化当前浏览上下文的窗口。该命令的具体行为是针对各个窗口管理器的。

    最小化窗口通常会将窗口隐藏在系统托盘中。

    注意:该功能适用于Selenium 4及以后的版本。

     
    
    driver.minimize_window()
    

    窗口全屏

     
    
    driver.fullscreen_window()
    

    截屏

    用于捕获当前浏览环境的屏幕截图,图片为Base64格式编码的屏幕截图。

    from selenium import webdriver
    driver = webdriver.Chrome()
    # Navigate to url
    driver.get("http://www.example.com")
    # Returns and base64 encoded string into image
    driver.save_screenshot('./image.png')
    driver.quit()

    TakeElementScreenshot

    用于捕捉当前浏览环境中元素的屏幕截图。WebDriver端点screenshot返回以Base64格式编码的屏幕截图。

    from selenium import webdriver
    from selenium.webdriver.common.by import By
    driver = webdriver.Chrome()
    # Navigate to url
    driver.get("http://www.example.com")
    ele = driver.find_element(By.CSS_SELECTOR, 'h1')
    # Returns and base64 encoded string into image
    ele.screenshot('./image.png')
    driver.quit()
    • 打印页面

    在浏览器中打印当前页面。

     
    
    from selenium.webdriver.common.print_page_options import PrintOptions
    print_options = PrintOptions()
    print_options.page_ranges = ['1-2']
    driver.get("printPage.html")
    base64code = driver.print_page(print_options)

    等待

    一般来说,WebDriver可以说是一个阻塞式的API。因为它是一个进程外的库,指示浏览器做什么,而且由于Web平台具有内在的异步性,所以WebDriver并不跟踪DOM的活跃、实时状态。这就带来了一些挑战,我们将在这里讨论。

    根据经验,使用Selenium和WebDriver所产生的大多数间歇性问题都与浏览器和用户指令之间的竞赛条件有关。一个例子可能是,用户指示浏览器导航到一个页面,然后在试图找到一个元素时得到一个no such element错误。

     
    
    <!doctype html>
    <meta charset=utf-8>
    <title>Race Condition Example</title>
    <script>
      var initialised = false;
      window.addEventListener("load", function() {
        var newElement = document.createElement("p");
        newElement.textContent = "Hello from JavaScript!";
        document.body.appendChild(newElement);
        initialised = true;
      });
    </script>
    

    driver.get("file:///race_condition.html");
    WebElement element = driver.findElement(By.tagName("p"));
    assertEquals(element.getText(), "Hello from JavaScript!");
    

    这里的问题是,WebDriver中使用的默认页面加载策略在调用导航后返回之前,会监听document.readyState是否变为 "完成"。因为p元素是在文档完成加载后添加的,所以这个WebDriver脚本可能是间歇性的。之所以说 "可能 "是间歇性的,是因为在没有明确等待或阻止这些事件的情况下,无法保证异步触发的元素或事件。

    幸运的是,WebElement接口上可用的普通指令集--如WebElement.click和WebElement.sendKeys--都保证是同步的,即函数调用不会返回(或者回调式语言中的回调不会触发),直到命令在浏览器中完成。高级用户交互API,键盘和鼠标,是个例外,因为它们明确是作为 "按我说的做 "的异步命令。

    等待是让自动任务执行经过一定时间后再继续下一步。

    为了克服浏览器和你的WebDriver脚本之间的竞赛条件的问题,大多数Selenium客户端都带有一个等待包。当采用等待时,你使用的是通常所说的显式等待。

    Explicit wait

    显式等待对Selenium客户端的命令式、过程式语言是可用的。它们允许你的代码停止程序执行,或者冻结线程,直到你传递给它的条件解决。该条件以一定的频率被调用,直到等待的超时结束。这意味着,只要条件返回一个假值,它就会一直尝试和等待。

    由于显式等待允许你等待一个条件发生,所以它们很适合用于同步浏览器和它的DOM以及你的WebDriver脚本之间的状态。

    为了弥补我们之前的错误指令集,我们可以采用等待的方式,让 findElement 调用等待,直到脚本中动态添加的元素被添加到 DOM 中。

     
    
    from selenium.webdriver.support.ui import WebDriverWait
    def document_initialised(driver):
        return driver.execute_script("return initialised")
    driver.navigate("file:///race_condition.html")
    WebDriverWait(driver).until(document_initialised)
    el = driver.find_element(By.TAG_NAME, "p")
    assert el.text == "Hello from JavaScript!"
     
    

    我们以函数引用的形式传递条件,即等待将反复运行,直到其返回值为truthhy。一个 "真实 "的返回值是指在当前语言中评价为布尔值真的任何东西,比如一个字符串、数字、布尔值、一个对象(包括一个WebElement),或者一个填充的(非空)序列或列表。这意味着一个空列表评价为false。当条件是真实的,阻塞等待被中止时,条件的返回值就会变成等待的返回值。

    有了这些知识,并且因为wait实用程序默认忽略没有这样的元素错误,我们可以重构我们的代码,使其更加简洁:

    from selenium.webdriver.support.ui import WebDriverWait
    driver.navigate("file:///race_condition.html")
    el = WebDriverWait(driver).until(lambda d: d.find_element_by_tag_name("p"))
    assert el.text == "Hello from JavaScript!"

    Implicit wait

    不同于显式等待的等待类型,称为隐式等待。通过隐式等待,WebDriver在试图找到任何元素时,会在一定时间内轮询DOM。当网页上的某些元素不是立即可用,需要一些时间来加载时,这很有用。

    隐式等待元素出现的功能在默认情况下是禁用的,需要在每个会话的基础上手动启用。混合使用显式等待和隐式等待会导致意想不到的后果,即即使元素可用或条件为真,等待的时间也会达到最长。

    警告:不要混合隐式和显式等待。不要混合隐式和显式等待。这样做会导致不可预知的等待时间。例如,设置隐式等待为10秒,显式等待为15秒,可能会导致20秒后发生超时。

    隐式等待是告诉WebDriver,当试图找到一个或多个元素时,如果它们不是立即可用,则会在一定时间内轮询DOM。默认设置为0,意味着禁用。一旦设置,隐式等待将在会话的整个过程中被设置。

     
    
    driver = Firefox()
    driver.implicitly_wait(10)
    driver.get("http://somedomain/url_that_delays_loading")
    my_dynamic_element = driver.find_element(By.ID, "myDynamicElement")

    FluentWait

    FluentWait实例定义了等待条件的最长时间,以及检查条件的频率。

    用户可以配置等待以在等待时忽略特定类型的异常,例如在页面上搜索元素时忽略NoSuchElementException。

     
    
    driver = Firefox()
    driver.get("http://somedomain/url_that_delays_loading")
    wait = WebDriverWait(driver, 10, poll_frequency=1, ignored_exceptions=[ElementNotVisibleException, ElementNotSelectableException])
    element = wait.until(EC.element_to_be_clickable((By.XPATH, "//div")))

    Http proxies

    代理服务器作为客户端和服务器之间请求的中介。简单来说,流量通过代理服务器流向你所请求的地址并返回。

    使用Selenium自动化脚本的代理服务器可以:

    • 捕捉网络流量

    • 模拟网站的后台调用

    • 在复杂的网络拓扑结构或严格的企业限制/政策下访问所需网站。

    • 如果你在企业环境中,浏览器无法连接到一个URL,很可能这个环境需要代理才能访问。

    Selenium WebDriver提供了一种代理设置的方式。

     
    
    from selenium import webdriver
    PROXY = "<HOST:PORT>"
    webdriver.DesiredCapabilities.FIREFOX['proxy'] = {
        "httpProxy": PROXY,
        "ftpProxy": PROXY,
        "sslProxy": PROXY,
        "proxyType": "MANUAL",
    }
    with webdriver.Firefox() as driver:
        # Open URL
        driver.get("https://selenium.dev")
    

    网页加载策略

    定义当前会话的页面加载策略。默认情况下,当Selenium WebDriver加载页面时,它遵循正常的网页加载策略。当页面加载耗费大量时间时,总是建议停止下载额外的资源(如图片、css、js)。

    文档的document.readyState属性描述了当前文档的加载状态。默认情况下,WebDriver将暂缓响应driver.get()(或)driver.navigate().to()调用,直到文档准备状态完成。

    在SPA应用中(如Angular、React、Ember),一旦动态内容已经加载完毕(即一旦pageLoadStrategy状态为COMPLETE),点击链接或在页面中执行一些操作将不会向服务器发出新的请求,因为内容是在客户端动态加载的,不需要完全刷新页面。

    SPA应用程序可以动态加载许多视图,而不需要任何服务器请求,所以网页加载策略将始终显示COMPLETE状态,直到我们做一个新的driver.get()和driver.navigate().to()。

    WebDriver 网页加载策略支持以下方式:

    • normal

    这将使Selenium WebDriver等待整个页面被加载。当设置为正常时,Selenium WebDriver会一直等待,直到加载事件被返回,默认加载方式也是normal。

    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options
    options = Options()
    options.page_load_strategy = 'normal'
    driver = webdriver.Chrome(options=options)
    # Navigate to url
    driver.get("http://www.google.com")
    driver.quit()
     
    
    • eager

    这种加载方式具体是,Selenium WebDriver等待到初始HTML文档被完全加载和解析,并放弃样式表、图像和子框架的加载。

    当设置为eager时,Selenium WebDriver会等待DOMContentLoaded事件的返回。

     
    
    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options
    options = Options()
    options.page_load_strategy = 'eager'
    driver = webdriver.Chrome(options=options)
    # Navigate to url
    driver.get("http://www.google.com")
    driver.quit()
    • none

    当设置为none时,Selenium WebDriver只等待下载初始页面。

     
    
    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options
    options = Options()
    options.page_load_strategy = 'none'
    driver = webdriver.Chrome(options=options)
    # Navigate to url
    driver.get("http://www.google.com")
    driver.quit()

    Remote WebDriver

    用户可以像在本地使用WebDriver一样远程使用它。主要的区别是,远程WebDriver需要被配置,以便它能在单独的机器上运行测试。

    远程WebDriver由两部分组成:一个客户端和一个服务器。客户端是你的WebDriver测试,而服务器是一个简单的Java servlet,它可以托管在任何现代JEE应用程序服务器上。

    Remote WebDriver server

    服务器将始终运行在装有您要测试的浏览器的机器上。服务器可以从命令行或通过代码配置来使用。

    • 命令行启动服务器

    一旦你下载了selenium-server-standalon-{VERSION}.jar,把它放在你要测试的浏览器的电脑上。然后,在该jar的目录下,运行以下内容。

    java -jar selenium-server-standalone-{VERSION}.jar
    • 运行服务器的注意事项

    调用者需要正确地终止每个会话,调用Selenium#stop()或WebDriver#quit。

    selenium服务器为每个正在进行的会话保留内存日志,当调用Selenium#stop()或WebDriver#quit时,这些日志会被清除。如果你忘记终止这些会话,你的服务器可能会泄漏内存。如果你保持了非常长的会话,你可能需要每隔一段时间就停止/退出一次(或者用-Xmx jvm选项增加内存)。

    • Timeouts

    服务器支持两种不同的超时方式,可以设置如下。

    java -jar selenium-server-standalone-{VERSION}.jar -timeout=20 -browserTimeout=60
    1. 浏览器超时

    控制浏览器被允许挂起的时间(数值以秒为单位)。

    1. 超时

    控制客户端在恢复会话之前允许离开多长时间(值为秒)。

    PS:从2.21版本开始,不再支持系统属性selenium.server.session.timeout。

    browserTimeout是作为普通超时机制失效时的一种备份超时机制,应该主要用于网格/服务器环境中,以保证崩溃/丢失的进程不会停留太久,污染运行环境。

    Remote WebDriver client

    要运行远程WebDriver客户端,我们首先需要连接到远程WebDriver。我们通过将URL指向运行测试的服务器地址来实现。为了定制我们的配置,我们设置所需的功能。下面是一个实例化远程WebDriver对象的例子,它指向我们的远程Web服务器www.example.com,在Firefox上运行我们的测试。

     
    
    from selenium import webdriver
    firefox_options = webdriver.FirefoxOptions()
    driver = webdriver.Remote(
        command_executor='http://www.example.com',
        options=firefox_options
    )
    driver.get("http://www.google.com")
    driver.quit()
     
    

    为了进一步定制我们的测试配置,我们可以添加其他需要的功能。

    • 浏览器选项

    例如,你想在Windows XP上运行Chrome,使用Chrome 67版本。

     
    
    from selenium import webdriver
    chrome_options = webdriver.ChromeOptions()
    chrome_options.set_capability("browserVersion", "67")
    chrome_options.set_capability("platformName", "Windows XP")
    driver = webdriver.Remote(
        command_executor='http://www.example.com',
        options=chrome_options
    )
    driver.get("http://www.google.com")
    driver.quit()

    本地文件检测器

    本地文件检测器允许将文件从客户端机器传输到远程服务器。例如,如果一个测试需要将一个文件上传到Web应用程序,远程WebDriver可以在运行时自动将文件从本地机器传输到远程Web服务器,这样就可以从运行测试的远程机器上传文件。默认情况下不会被启用,需要通过以下方式启用。

     
    
    from selenium.webdriver.remote.file_detector import LocalFileDetector
    driver.file_detector = LocalFileDetector()
    
     
    

    定义好上述代码后,就可以按照以下方式测试上传文件。

     
    
    driver.get("http://sso.dev.saucelabs.com/test/guinea-file-upload")
    driver.find_element(By.ID, "myfile").send_keys("/Users/sso/the/local/path/to/darkbulb.jpg")

    声明

    未经允许,不得私自转载,否则追究法律责任

    展开全文
  • 知道怎么回事,先前能跑动的case,现在元素始终找到。  但是我xpath是能定位得到的,debug了一下,结果发现在  WebElementelement = locator.findElement();就卡住了。  弄了好久也没有成功。  网上找例子: ...
    不知道怎么回事,先前能跑动的case,现在元素始终找不到。
      但是我xpath是能定位得到的,debug了一下,结果发现在
      WebElementelement = locator.findElement();就卡住了。
      弄了好久也没有成功。
       网上找例子:
      Selenium2( WebDriver)_如何判断WebElement元素对象是否存在
      1.selenium中如果去寻找元素,而元素不存在的话,通常会抛出NoSuchElementException 导致 测试失败,但有时候,我们需要去确保页面元素不存在,才是我们正确的验收条件下面的方法可以用来判定页面元素是否存在
        1 public boolean doesWebElementExist(WebDriver driver, By selector)
        2{
        3
        4         try
        5         {
        6                driver.findElement(selector);
        7                returntrue;
        8        }
        9        catch(NoSuchElementException e)
        10         {
        11                 return false;
        12         }
        13 }
      2.一般有这样的应用场合,例如我们要验证在一个网站是否登录成功,那么可以通过判断登录之后是否显示相应元素:
      WebElementlinkUsername =driver.findElement(By.xpath("//a[contains(text(),"+username+")]"));
      return linkUsername.isDisplayed();
      这一方法的前提是:该元素之前已经存在,仅仅需要判断是否被显示。
      现在存在另一种场合,页面元素并不存在,即通过driver.findElement只能在超时之后得到NoSuchElementException的异常。
      因此只好通过如下方法解决:
    1 boolean ElementExist (ByLocator )
    2{
    3 try
    4 {
    5 driver.findElement( Locator );
    6 returntrue;
    7}
    8 catch(org.openqa.selenium.NoSuchElementException ex)
    9{
    10     returnfalse;
    11 }
    12 }
       但这一方法仍然不理想,有这样两个问题:
      1、这一方法不属于任何一个page页,因此需要额外进行框架上的变更以支持这些功能函数,否则就必须在每一个用到该函数的page类写一遍。
      2、仍然需要等到超时才能得知结果,当需要频繁使用该函数的时候会造成相当的时间浪费。
      3.
      类似于seleniumRC中的isTextPresent方法
      用xpath匹配所有元素(//*[contains(.,'keyword')]),判断是否存在包含期望关键字的元素。
      使用时可以根据需要调整参数和返回值。
    1 public boolean isContentAppeared(WebDriver driver,String content) {
    2       booleanstatus = false;
    3       try {
    4          driver.findElement(By.xpath("//*[contains(.,'" + content +"')]"));
    5           System.out.println(content + "is appeard!");
    6           status = true;
    7       } catch (NoSuchElementException e) {
    8           status = false;
    9           System.out.println("'" +content + "' doesn't exist!"));
    10      }
    11      return status;
    12 }
      4. Xpath 多重判断
      1 while(currentPageLinkNumber<MaxPage)
      2 {
      3 WebElement PageLink;
      4 PageLink = driver.findElement(By.xpath("//a[@class = 'PageLink' and@title ='"+Integer.toString(currentPageLinkNumber+1)+"']"));
      5 PageLink.click();
      6 currentPageLinkNumber++;
      7 //OtherOperation();
      8 }
      然后又看了一篇 文章
       selenium webdriver定位不到元素的五种原因及解决办法
       1.动态id定位不到元素
      for example:
      //WebElement xiexin_element = driver.findElement(By.id("_mail_component_82_82"));
      WebElement xiexin_element = driver.findElement(By.xpath("//span[contains(.,'写  信')]"));
      xiexin_element.click();
      上面一段代码注释掉的部分为通过id定位element的,但是此id“_mail_component_82_82”后面的数字会随着你每次登陆而变化,此时就无法通过id准确定位到element。
      所以推荐使用xpath的相对路径方法查找到该元素。

     2.iframe原因定位不到元素
      由于需要定位的元素在某一个frame里边,所以有时通过单独的id/name/xpath还是定位不到此元素
      比如以下一段xml源文件:
    <iframe id="left_frame" scrolling="auto" frameborder="0" src="index.php?m=Index&a=Menu" name="left_frame" noresize="noresize" style="height: 100%;visibility: inherit; width: 100%;z-index: 1">
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <body class="menuBg">
    <div id="menu_node_type_0">
    <table width="193" cellspacing="0" cellpadding="0" border="0">
    <tbody>
    <tr>
    <tr>
    <td id="c_1">
    <table class="menuSub" cellspacing="0" cellpadding="0" border="0" align="center">
    <tbody>
    <tr class="sub_menu">
    <td>
    <a href="index.php?m=Coupon&a=SearchCouponInfo" target="right_frame">密码重置</a>
    </td>
    </tr>
      原本可以通过
      WebElement element = driver.findElement(By.linkText("密码重置"));
      来定位此元素,但是由于该元素在iframe id="left_frame"这个frame里边  所以需要先通过定位frame然后再定位frame里边的某一个元素的方法定位此元素
      WebElement element =driver.switchTo().frame("left_frame").findElement(By.linkText("密码重置"));
       3.不在同一个frame里边查找元素
      大家可能会遇到页面左边一栏属于left_frame,右侧属于right_frame的情况,此时如果当前处在
      left_frame,就无法通过id定位到right_frame的元素。此时需要通过以下语句切换到默认的content
      driver.switchTo().defaultContent();
      例如当前所在的frame为left_frame
      WebElement xiaoshoumingxi_element = driver.switchTo().frame("left_frame").findElement(By.linkText("销售明细"));
      xiaoshoumingxi_element.click();
      需要切换到right_frame
      driver.switchTo().defaultContent();
      Select quanzhong_select2 = new Select(driver.switchTo().frame("right_frame").findElement(By.id("coupon_type_str")));
      quanzhong_select2.selectByVisibleText("售后0小时");
       4.  xpath描述错误
      这个是因为在描述路径的时候没有按照xpath的规则来写 造成找不到元素的情况出现
       5.点击速度过快  页面没有加载出来就需要点击页面上的元素
      这个需要增加一定等待时间,显示等待时间可以通过WebDriverWait 和util来实现
      例如:
      //用WebDriverWait和until实现显示等待 等待欢迎页的图片出现再进行其他操作
      WebDriverWait wait = (new WebDriverWait(driver,10));
      wait.until(new ExpectedCondition<Boolean>(){
      public Boolean apply(WebDriver d){
      boolean loadcomplete = d.switchTo().frame("right_frame").findElement(By.xpath("//center/div[@class='welco']/img")).isDisplayed();
      return loadcomplete;
      }
      });
      也可以自己预估时间通过Thread.sleep(5000);//等待5秒 这个是强制线程休息
       6.firefox安全性强,不允许跨域调用出现报错
      错误描述:uncaught exception: [Exception... "Component returned failure code: 0x80004005 (NS_ERROR_FAILURE) [nsIDOMNSHTMLDocument.execCommand]" nsresult: "0x80004005 (NS_ERROR_FAILURE)" location:
      解决办法:
      这是因为firefox安全性强,不允许跨域调用。
      Firefox 要取消XMLHttpRequest的跨域限制的话,第一
      是从 about:config 里设置 signed.applets.codebase_principal_support = true; (地址栏输入about:config 即可进行firefox设置)
      第二就是在open的代码函数前加入类似如下的代码: try { netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead"); } catch (e) { alert("Permission UniversalBrowserRead denied."); }
      最后看了乙醇的文章
    import java.io.File;
    importorg.openqa.selenium.By;
    importorg.openqa.selenium.WebDriver;
    importorg.openqa.selenium.chrome.ChromeDriver;
    importorg.openqa.selenium.support.ui.ExpectedCondition;
    importorg.openqa.selenium.support.ui.WebDriverWait;
    public classButtonDropdown {
    public static voidmain(String[] args) throws InterruptedException {
    WebDriver dr = newChromeDriver();
    File file = newFile("src/button_dropdown.html");
    String filePath = "file:///" + file.getAbsolutePath();
    System.out.printf("nowaccesss %s \n", filePath);
    dr.get(filePath);
    Thread.sleep(1000);
    //      定位text是watir-webdriver的下拉菜单
    //      首先显示下拉菜单
    dr.findElement(By.linkText("Info")).click();
    (newWebDriverWait(dr, 10)).until(new ExpectedCondition<Boolean>(){
    public Booleanapply(WebDriver d){
    returnd.findElement(By.className("dropdown-menu")).isDisplayed();
    }
    });
    //      通过ul再层级定位
    dr.findElement(By.className("dropdown-menu")).findElement(By.linkText("watir-webdriver")).click();
    Thread.sleep(1000);
    System.out.println("browser will be close");
    dr.quit();
    }
    }
      然后我自己定位的。
    public XiaoyuanactivityPage zipaixiuye(){
    driver.navigate().refresh();
    luntan.click();
    WebDriverWrapper.waitPageLoad(driver,3);
    (new WebDriverWait(driver, 10)).until(newExpectedCondition<Boolean>() {
    public Boolean apply(WebDriverdriver){
    returndriver.findElement(By.className("TFB_sub_li")).isDisplayed();
    }
    });
    driver.findElement(By.className("TFB_sub_li")).findElement(By.linkText("自拍秀")).click();
    returnPageFactory.initElements(this.getDriver(),
    XiaoyuanactivityPage.class);
    }
      总算成功了,成功来得真不容易啊!
      我现在还是不明白我之前的方法为什么开始可以,后面就不行了。
      但是我现在也不去探究了,我自己的问题已经解决了。
      谢谢分享文章的朋友。

    最新内容请见作者的GitHub页:http://qaseven.github.io/
    展开全文
  • Selenium 008 WebDriver 文档

    千次阅读 2021-03-24 08:34:44
    因为它是一个指示浏览器做什么的进程外库,而且web平台本质上是异步的,所以WebDriver不跟踪DOM的实时活动状态。这伴随着一些我们将在这里讨论的挑战。 根据经验,大多数由于使用Selenium和WebDriver而产生的间歇性...

    WebDriver 文档

    入门指南
    WebDriver 以本地化方式驱动浏览器,就像用户在本地或使用 Selenium 服务器的远程机器上所做的那样,这标志着浏览器自动化的飞跃。

    Selenium WebDriver 指的是语言绑定和各个浏览器控制代码的实现。 这通常被称为 WebDriver。

    Selenium WebDriver 是 W3C 推荐标准

    • WebDriver 被设计成一个简单和简洁的编程接口。
    • WebDriver 是一个简洁的面向对象 API。
    • 它能有效地驱动浏览器。

    了解组件

    使用 WebDriver 构建测试套件需要您理解并有效地使用许多不同的组件。就像软件中的一切一样, 不同的人对同一个想法使用不同的术语。下面是在这个描述中如何使用术语的细分。

    专业术语

    • API: 应用程序编程接口。这是一组用来操作 WebDriver 的 “命令”。
    • 库: 一个代码模块,它包含 api 和实现这些 api 所需的代码。库是对应于具体的语言的,例如 Java 的 .jar 文件,.NET
      的 .dll 文件,等等。
    • 驱动程序: 负责控制实际的浏览器。大多数驱动程序是由浏览器厂商自己创建的。
      驱动程序通常是与浏览器一起在系统上运行的可执行模块,而不是在执行测试套件的系统上。 (尽管它们可能是同一个系统。) 注意:
      有些人把驱动称为代理。
    • 框架: 用于支持 WebDriver 套件的附加库。这些框架可能是测试框架,如 JUnit 或 NUnit。
      它们也可能是支持自然语言特性的框架,如 Cucumber 或 Robotium。还可以编写和使用框架来操作或配置被测试的系统、
      数据创建、测试预言等等。

    组成部分

    至少,WebDriver 通过一个驱动程序与浏览器对话。通信有两种方式: WebDriver 通过驱动程序向浏览器传递命令, 然后通过相同的路径接收信息。
    在这里插入图片描述
    驱动程序是特定于浏览器的,例如 ChromeDriver 对应于谷歌的 Chrome/Chromium, GeckoDriver 对应于 Mozilla 的 Firefox 的,等等。驱动程序在与浏览器相同的系统上运行。 这可能与执行测试本身的系统相同,也可能不同。

    上面这个简单的例子就是 _直接_通信。与浏览器的通信也可以是通过 Selenium 服务器或 RemoteWebDriver 进行的 _远程_通信。RemoteWebDriver 与驱动程序和浏览器运行在同一个系统上。

    在这里插入图片描述

    远程通信也可以使用 Selenium Server 或 Selenium Grid 进行,这两者依次与主机系统上的驱动程序进行通信

    在这里插入图片描述

    应用框架

    WebDriver 有且只有一个任务: 通过上面的任何方法与浏览器通信。WebDriver 对测试一窍不通:它不知道如何比较事物、 断言通过或失败,当然它也不知道报告或 Given/When/Then 语法。

    这就是各种框架发挥作用的地方。至少你需要一个与绑定语言相匹配的测试框架,比如. NET 的 NUnit, Java 的 JUnit, Ruby 的 RSpec 等等。

    测试框架负责运行和执行 WebDriver 以及测试中相关步骤。因此,您可以认为它看起来类似于下图。

    测试框架
    像 Cucumber 这样的自然语言框架/工具可能作为上图中测试框架框的一部分存在, 或者它们可能将测试框架完全封装在它们自己的实现中。

    驱动要求

    通过 WebDriver,Selenium 支持市面上所有主流的浏览器,如 Chrom(ium)、Firefox、 Internet Explorer、Opera 和 Safari。 尽管并非所有浏览器都对远程控制提供官方支持, 但 WebDriver 尽可能使用浏览器的内置自动化支持来驱动浏览器。

    WebDriver 的目标是尽可能模拟真实用户与浏览器的交互。
    在不同的浏览器中,这可能有不同的级别。有关不同驱动程序特性的详细信息, 请参见 驱动程序特性。

    尽管所有的驱动程序共享一个面向用户的界面来控制浏览器,但它们设置浏览器会话的方式略有不同。 由于许多驱动程序实现是由第三方提供的,所以它们不包括在标准的 Selenium 发行版中。

    驱动程序实例化、配置文件管理和各种特定于浏览器的设置都是具体参数的例子,这些参数根据浏览器有 不同的需求。本节介绍了使用不同浏览器的基本要求。

    将可执行文件添加到 PATH 中

    大多数驱动程序需要 Selenium 额外的可执行文件才能与浏览器通信。您可以在启动 WebDriver 之前手动指定可执行文件的存放位置,但这会使测试的可移植性降低,因为可执行文件必须位于每台 计算机上的同一位置,或包含在测试代码存储库中。

    通过将包含 WebDriver 二进制文件的文件夹添加到系统 path 环境变量中,Selenium 将能够找到其他二进制文件,而无需您的测试代码来定位驱动程序的确切位置。

    • 创建一个目录来放置可执行文件,例如 C:\WebDriver\bin 或 /opt/WebDriver/bin
    • 将目录添加到您的 path 中:
      • 在 Windows 上 - 以管理员身份打开命令提示符,然后运行以下命令将目录永久添加到计算机上所有用户的路径中:
    setx /m path "%path%;C:\WebDriver\bin\"
    
    • 在 macOS 和 Linux 上的 Bash 用户 - 在终端中:
    export PATH=$PATH:/opt/WebDriver/bin >> ~/.profile
    
    • 现在您可以测试更改了。关闭所有打开的命令提示符,然后打开一个新的提示符。 输入您在上一步创建的文件夹中的某一个二进制文件的名称,例如:
    chromedriver
    
    • 如果您的 PATH 配置正确,您将看到一些有关驱动程序启动的输出:
    Starting ChromeDriver 2.25.426935 (820a95b0b81d33e42712f9198c215f703412e1a1) on port 9515
    Only local connections are allowed.
    

    您可以通过按 Ctrl + C 重新获得对命令提示符的控制。

    快速参考

    Chromium/Chrome Windows/macOS/Linux 谷歌 下载
    火狐 Windows/macOS/Linux Mozilla 下载

    Chromium/Chrome
    要驱动 Chrome 或 Chromium,您必须下载 chromedriver 并将其放在系统路径上的文件夹中。

    在 Linux 或 macOS 上,这意味着修改 PATH 环境变量。通过执行以下命令,您可以看到由冒号分隔的目录组成的系统路径:

    $ echo $PATH
    /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    

    要在路径上包含 chromedriver(如果还没有的话),请确保包含 chromedriver 二进制文件的父目录。 下面的行将设置当前 PATH 环境变量的内容,在冒号后面添加一个额外的路径:

    $ export PATH="$PATH:/path/to/chromedriver"
    

    当您的路径上有 chromedriver 时,您应该可以从任何目录执行 chromedriver 可执行文件。

    要实例化 Chrome/Chromium 会话,您可以执行以下操作:

    #简单赋值
    from selenium.webdriver import Chrome
    
    driver = Chrome()
    
    #或者使用上下文管理器
    from selenium.webdriver import Chrome
    
    with Chrome() as driver:
        #你自己的代码放在这个缩进中
    

    请记住,您必须设置 chromedriver 可执行文件的路径。可以使用下行代码实现:

    Chrome(executable_path='/path/to/chromedriver')
    

    chromedriver 被实现为 WebDriver 远程服务器,该服务器通过公开 Chrome 的内部自动化代理接口来指示浏览器该怎么做。

    火狐浏览器

    从 Selenium 3 开始,Mozilla 通过 geckodriver 接管了火狐驱动程序的实现。火狐的新驱动程序被称为 geckodriver,可与 Firefox 48 及更高版本一起使用。 由于正在开发 Firefox WebDriver,因此 Firefox 版本越新,支持越好。

    由于 geckodriver 是默认新的启动火狐浏览器的方式,您可以像 Selenium 2 那样实例化火狐浏览器:

    #简单赋值
    from selenium.webdriver import Firefox
    
    driver = Firefox()
    #或者使用上下文管理器
    from selenium.webdriver import Firefox
    
    with Firefox() as driver:
       #你自己的代码放在这个缩进中
    

    如果您不想使用 PATH 设置 geckodriver 的位置,请在代码中设置 geckodriver 的位置:

    Firefox(executable_path='/path/to/geckodriver')
    

    也可以在运行时设置属性:

    mvn test -Dwebdriver.gecko.driver=/path/to/geckodriver
    

    当前,可以通过安装 Firefox 47.0.1 或 45 ESR 并指定 marionette 功能为 false 来还原到功能更强大的旧版 Firefox 驱动程序。Firefox 的更高版本不再兼容。

    模拟浏览器

    HtmlUnit
    HtmlUnit 是一个 “针对 Java 程序的无图形界面浏览器”。它为 HTML 文档建模,并提供一个 API, 允许您调用页面、填写表单、单击链接等。它支持 JavaScript,能够使用 AJAX 库,根据使用的配置模拟 Chrome、Firefox 或 IE。它已经迁移到一个新位置 了。 源文件保存在 svn 上。

    PhantomJS
    PhantomJS 是一款基于 Webkit 的无头浏览器,尽管它的版本比谷歌 Chrome 或 Safari 要老得多。虽然曾经很流行, 但现在明智的做法是避免 PhantomJS。这个项目 从 8 月 5 日起 就一直没有被维护过,所以尽管网络会继续变化,PhantomJS 也不会更新。在谷歌宣布可以无头运行 Chrome 之后,现在 Mozilla 的火狐浏览器也提供了这个功能。

    WebDriver Bidi APIs

    在Selenium 4中, 引入了新的事件API, 使用户能够在事件发生时从浏览器捕获事件, 并非WebDriver用于其他API的传统请求/响应方法.

    WebDriver将在内部创建针对浏览器的WebSocket连接, 用于传输事件和命令.

    随着Selenium项目更多地用于实际案例, 相应的API列表将不断扩充. 如果缺少API, 请提出功能请求.

    变化监测
    变化监测是一种能力, 用于当特定元素的DOM发生变化时, 得以通过WebDriver BiDi捕获事件.

    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support.wait import WebDriverWait
    
    driver = webdriver.Chrome()
    async with driver.log.mutation_events() as event:
        pages.load("dynamic.html")
        driver.find_element(By.ID, "reveal").click()
        WebDriverWait(driver, 5)\
            .until(EC.visibility_of(driver.find_element(By.ID, "revealed")))
    
    assert event["attribute_name"] == "style"
    assert event["current_value"] == ""
    assert event["old_value"] == "display:none;"
    
      
    

    定位元素

    使用 WebDriver 时要学习的最基本的技术之一是如何查找页面上的元素。
    findElement(By) 方法返回另一个基本对象类型 WebElement。

    WebDriver 代表浏览器
    WebElement 表示特定的 DOM 节点(控件,例如链接或输入栏等)

    cheese = driver.find_element(By.ID, “cheese”)
    cheddar = cheese.find_elements_by_id(“cheddar”)

    WebDriver 和 WebElement 类型都实现了 搜索上下文 接口。在 WebDriver 中,这称为 基于角色的接口。基于角色的接口允许你确定特定的驱动程序实现是否支持给定的功能。

    cheddar = driver.find_element_by_css_selector("#cheese #cheddar")

    定位多个元素

    最喜欢的奶酪的订单列表:

    复数版本 findElements(By) 。此方法返回 web 元素的集合。如果只找到一个元素,它仍然返回(一个元素的)集合。如果没有元素被定位器匹配到,它将返回一个空列表。

    mucho_cheese = driver.find_elements_by_css_selector("#cheese li")

    8 种不同的内置元素定位策略

    class name 定位class属性与搜索值匹配的元素(不允许使用复合类名)
    css selector 定位 CSS 选择器匹配的元素
    id 定位 id 属性与搜索值匹配的元素
    name 定位 name 属性与搜索值匹配的元素
    link text 定位link text可视文本与搜索值完全匹配的锚元素
    partial link text 定位link text可视文本部分与搜索值部分匹配的锚点元素。如果匹配多个元素,则只选择第一个元素。
    tag name 定位标签名称与搜索值匹配的元素
    xpath 定位与 XPath 表达式匹配的元素

    Relative Locators

    findElement 方法现在支持witTagName()新方法其可返回RelativeLocator相对定位对象。

    Selenium是通过使用JavaScript函数 getBoundingClientRect() 来查找相对元素的。这个函数能够返回对应元素的各种属性例如:右,左,下,上。

    from selenium.webdriver.support.relative_locator import with_tag_name

    above() 元素上 返回当前指定元素位置上方的WebElement对象
    passwordField = driver.find_element(By.ID, “password”)
    emailAddressField = driver.find_element(with_tag_name(“input”).above(passwordField))

    below() 元素下 返回当前指定元素位置下方的WebElement对象
    emailAddressField = driver.find_element(By.ID, “email”)
    passwordField = driver.find_element(with_tag_name(“input”).below(emailAddressField))

    toLeftOf() 元素左 返回当前指定元素位置左方的WebElement对象
    submitButton = driver.find_element(By.ID, “submit”)
    cancelButton = driver.find_element(with_tag_name(“button”).to_left_of(submitButton))

    toRightOf() 元素右 返回当前指定元素位置右方的WebElement对象
    cancelButton = driver.find_element(By.ID, “cancel”)
    submitButton = driver.find_element(with_tag_name(“button”).to_right_of(cancelButton))

    near() 附近 返回当前指定元素位置附近大约px5050像素的WebElement对象
    emailAddressLabel = driver.find_element(By.ID, “lbl-email”)
    emailAddressField = driver.find_element(with_tag_name(“input”).near(emailAddressLabel))

    操控浏览器

    浏览器导航

    打开网站

    driver.get("https://selenium.dev")
    

    driver.current_url
    driver.back()
    driver.forward()
    driver.refresh()
    driver.title

    窗口和标签页

    WebDriver 没有区分窗口和标签页。如果你的站点打开了一个新标签页或窗口,Selenium 将允许您使用窗口句柄来处理它。 每个窗口都有一个唯一的标识符,该标识符在单个会话中保持持久性。

    driver.current_window_handle
    

    切换窗口或标签页

    单击在 <a href=“https://seleniumhq.github.io"target=”_blank”>新窗口 中打开链接, 则屏幕会聚焦在新窗口或新标签页上,但 WebDriver 不知道操作系统认为哪个窗口是活动的。 要使用新窗口,您需要切换到它。

    from selenium import webdriver
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    
    # 启动驱动程序
    with webdriver.Firefox() as driver:
    	# 打开网址
    	driver.get("https://seleniumhq.github.io")
    
        # 设置等待
        wait = WebDriverWait(driver, 10)
    
        # 存储原始窗口的 ID
        original_window = driver.current_window_handle
    
        # 检查一下,我们还没有打开其他的窗口
        assert len(driver.window_handles) == 1
    
        # 单击在新窗口中打开的链接
        driver.find_element(By.LINK_TEXT, "new window").click()
    
        # 等待新窗口或标签页
        wait.until(EC.number_of_windows_to_be(2))
    
        # 循环执行,直到找到一个新的窗口句柄
        for window_handle in driver.window_handles:
            if window_handle != original_window:
                driver.switch_to.window(window_handle)
                break
    
        # 等待新标签页完成加载内容
        wait.until(EC.title_is("SeleniumHQ Browser Automation"))
    ## 创建新窗口(或)新标签页并且切换
    

    Selenium 4 提供了一个新的 api NewWindow, 它创建一个新选项卡 (或) 新窗口并自动切换到它。
    创建一个新窗口 (或) 标签页,屏幕焦点将聚焦在新窗口或标签在上。您不需要切换到新窗口 (或) 标签页。如果除了新窗口之外, 您打开了两个以上的窗口 (或) 标签页,您可以通过遍历 WebDriver 看到两个窗口或选项卡,并切换到非原始窗口。

    注意: 该特性适用于 Selenium 4 及其后续版本。

    Java Python C# Ruby JavaScript Kotlin

    打开新标签页并切换到新标签页

    driver.switch_to.new_window(‘tab’)

    打开一个新窗口并切换到新窗口

    driver.switch_to.new_window(‘window’)
    关闭窗口或标签页
    当你完成了一个窗口或标签页的工作时,_并且_它不是浏览器中最后一个打开的窗口或标签页时,你应该关闭它并切换回你之前使用的窗口。 假设您遵循了前一节中的代码示例,您将把前一个窗口句柄存储在一个变量中。把这些放在一起,你会得到:

    Java Python C# Ruby JavaScript Kotlin

    #关闭标签页或窗口
    driver.close()

    #切回到之前的标签页或窗口
    driver.switch_to.window(original_window)
    如果在关闭一个窗口后忘记切换回另一个窗口句柄,WebDriver 将在当前关闭的页面上执行,并触发一个 No Such Window Exception 无此窗口异常。必须切换回有效的窗口句柄才能继续执行。

    在会话结束时退出浏览器
    当你完成了浏览器会话,你应该调用 quit 退出,而不是 close 关闭:

    Java Python C# Ruby JavaScript Kotlin
    driver.quit()
    退出将会
    关闭所有与 WebDriver 会话相关的窗口和选项卡
    结束浏览器进程
    结束后台驱动进程
    通知 Selenium Grid 浏览器不再使用,以便可以由另一个会话使用它(如果您正在使用 Selenium Grid)
    调用 quit() 失败将留下额外的后台进程和端口运行在机器上,这可能在以后导致一些问题。

    有的测试框架提供了一些方法和注释,您可以在测试结束时放入 teardown() 方法中。

    Java Python C# Ruby JavaScript Kotlin

    unittest teardown

    https://docs.python.org/3/library/unittest.html?highlight=teardown#unittest.TestCase.tearDown

    def tearDown(self):
    self.driver.quit()
    如果不在测试上下文中运行 WebDriver,您可以考虑使用 try / finally,这是大多数语言都提供的, 这样一个异常处理仍然可以清理 WebDriver 会话。

    Java Python C# Ruby JavaScript Kotlin

    try:
    #WebDriver 代码…
    finally:
    driver.quit()
    Python 的 WebDriver 现在支持 Python 上下文管理器,当使用 with 关键字时,可以在执行结束时自动退出驱动程序。

    with webdriver.Firefox() as driver:

    WebDriver 代码…

    在此缩进位置后 WebDriver 会自动退出

    Frames and Iframes
    框架是一种现在已被弃用的方法,用于从同一域中的多个文档构建站点布局。除非你使用的是 HTML5 之前的 webapp,否则你不太可能与他们合作。内嵌框架允许插入来自完全不同领域的文档,并且仍然经常使用。

    如果您需要使用框架或 iframe, WebDriver 允许您以相同的方式使用它们。考虑 iframe 中的一个按钮。 如果我们使用浏览器开发工具检查元素,我们可能会看到以下内容:

    Java Python C# Ruby JavaScript Kotlin

    这不会工作

    driver.find_element(By.TAG_NAME, ‘button’).click()
    但是,如果 iframe 之外没有按钮,那么您可能会得到一个 no such element 无此元素 的错误。 这是因为 Selenium 只知道顶层文档中的元素。为了与按钮进行交互,我们需要首先切换到框架, 这与切换窗口的方式类似。WebDriver 提供了三种切换到帧的方法。

    使用 WebElement
    使用 WebElement 进行切换是最灵活的选择。您可以使用首选的选择器找到框架并切换到它。

    Java Python C# Ruby JavaScript Kotlin

    存储网页元素

    iframe = driver.find_element(By.CSS_SELECTOR, “#modal > iframe”)

    切换到选择的 iframe

    driver.switch_to.frame(iframe)

    单击按钮

    driver.find_element(By.TAG_NAME, ‘button’).click()
    使用 name 或 id
    如果您的 frame 或 iframe 具有 id 或 name 属性,则可以使用该属性。如果名称或 id 在页面上不是唯一的, 那么将切换到找到的第一个。

    Java Python C# Ruby JavaScript Kotlin

    通过 id 切换框架

    driver.switch_to.frame(‘buttonframe’)

    单击按钮

    driver.find_element(By.TAG_NAME, ‘button’).click()
    使用索引
    还可以使用frame的索引, 例如可以使用JavaScript中的 window.frames 进行查询.

    Java Python C# Ruby JavaScript Kotlin

    切换到第 2 个框架

    driver.switch_to.frame(1)
    离开框架
    离开 iframe 或 frameset,切换回默认内容,如下所示:

    Java Python C# Ruby JavaScript Kotlin

    切回到默认内容

    driver.switch_to.default_content()
    窗口管理
    屏幕分辨率会影响 web 应用程序的呈现方式,因此 WebDriver 提供了移动和调整浏览器窗口大小的机制。

    获取窗口大小
    获取浏览器窗口的大小(以像素为单位)。

    Java Python C# Ruby JavaScript Kotlin

    分别获取每个尺寸

    width = driver.get_window_size().get(“width”)
    height = driver.get_window_size().get(“height”)

    或者存储尺寸并在以后查询它们

    size = driver.get_window_size()
    width1 = size.get(“width”)
    height1 = size.get(“height”)
    设置窗口大小
    恢复窗口并设置窗口大小。

    Java Python C# Ruby JavaScript Kotlin
    driver.set_window_size(1024, 768)
    得到窗口的位置
    获取浏览器窗口左上角的坐标。

    Java Python C# Ruby JavaScript Kotlin

    分别获取每个尺寸

    x = driver.get_window_position().get(‘x’)
    y = driver.get_window_position().get(‘y’)

    或者存储尺寸并在以后查询它们

    position = driver.get_window_position()
    x1 = position.get(‘x’)
    y1 = position.get(‘y’)
    设置窗口位置
    将窗口移动到设定的位置。

    Java Python C# Ruby JavaScript Kotlin

    将窗口移动到主显示器的左上角

    driver.set_window_position(0, 0)
    最大化窗口
    扩大窗口。对于大多数操作系统,窗口将填满屏幕,而不会阻挡操作系统自己的菜单和工具栏。

    Java Python C# Ruby JavaScript Kotlin
    driver.maximize_window()
    最小化窗口
    最小化当前浏览上下文的窗口. 这种命令的精准行为将作用于各个特定的窗口管理器.

    最小化窗口通常将窗口隐藏在系统托盘中.

    注意: 此功能适用于Selenium 4以及更高版本.

    Java Python C# Ruby JavaScript Kotlin
    driver.minimize_window()
    全屏窗口
    填充整个屏幕,类似于在大多数浏览器中按下 F11。

    Java Python C# Ruby JavaScript Kotlin
    driver.fullscreen_window()
    屏幕截图
    用于捕获当前浏览上下文的屏幕截图. WebDriver端点 屏幕截图 返回以Base64格式编码的屏幕截图.

    Java Python C# Ruby JavaScript Kotlin

    from selenium import webdriver

    driver = webdriver.Chrome()

    Navigate to url

    driver.get(“http://www.example.com”)

    Returns and base64 encoded string into image

    driver.save_screenshot(’./image.png’)

    driver.quit()
    元素屏幕截图
    用于捕获当前浏览上下文的元素的屏幕截图. WebDriver端点 屏幕截图 返回以Base64格式编码的屏幕截图.

    Java Python C# Ruby JavaScript Kotlin

    from selenium import webdriver
    from selenium.webdriver.common.by import By

    driver = webdriver.Chrome()

    Navigate to url

    driver.get(“http://www.example.com”)

    ele = driver.find_element(By.CSS_SELECTOR, ‘h1’)

    Returns and base64 encoded string into image

    ele.screenshot(’./image.png’)

    driver.quit()
    执行脚本
    在当前frame或者窗口的上下文中,执行JavaScript代码片段.

    Java Python C# Ruby JavaScript Kotlin

    // Stores the header element
    let header = await driver.findElement(By.css(‘h1’));

    // Executing JavaScript to capture innerText of header element
    let text = await driver.executeScript(‘return arguments[0].innerText’, header);
    打印页面
    打印当前浏览器内的页面

    注意: 此功能需要无头模式下的Chromium浏览器

    Java Python C# Ruby JavaScript Kotlin

    from selenium.webdriver.common.print_page_options import PrintOptions

    print_options = PrintOptions()
    print_options.page_ranges = ['1-2']
    
    driver.get("printPage.html")
    
    base64code = driver.print_page(print_options)
    

    等待

    WebDriver通常可以说有一个阻塞API。因为它是一个指示浏览器做什么的进程外库,而且web平台本质上是异步的,所以WebDriver不跟踪DOM的实时活动状态。这伴随着一些我们将在这里讨论的挑战。

    根据经验,大多数由于使用Selenium和WebDriver而产生的间歇性问题都与浏览器和用户指令之间的 竞争条件 有关。例如,用户指示浏览器导航到一个页面,然后在试图查找元素时得到一个 no such element 的错误。

    考虑下面的文档:

    <!doctype html>
    <meta charset=utf-8>
    <title>Race Condition Example</title>
    
    <script>
      var initialised = false;
      window.addEventListener("load", function() {
        var newElement = document.createElement("p");
        newElement.textContent = "Hello from JavaScript!";
        document.body.appendChild(newElement);
        initialised = true;
      });
    </script>
    

    这个 WebDriver的说明可能看起来很简单:

    driver.navigate("file:///race_condition.html")
    el = driver.find_element(By.TAG_NAME, "p")
    assert el.text == "Hello from JavaScript!"
    

    这里的问题是WebDriver中使用的默认页面加载策略页面加载策略听从document.readyState在返回调用 navigate 之前将状态改为"complete" 。因为p元素是在文档完成加载之后添加的,所以这个WebDriver脚本可能是间歇性的。它“可能”间歇性是因为无法做出保证说异步触发这些元素或事件不需要显式等待或阻塞这些事件。

    幸运的是,WebElement接口上可用的正常指令集——例如 WebElement.click 和 WebElement.sendKeys—是保证同步的,因为直到命令在浏览器中被完成之前函数调用是不会返回的(或者回调是不会在回调形式的语言中触发的)。高级用户交互APIs,键盘和鼠标是例外的,因为它们被明确地设计为“按我说的做”的异步命令。

    等待是在继续下一步之前会执行一个自动化任务来消耗一定的时间。

    为了克服浏览器和WebDriver脚本之间的竞争问题,大多数Selenium客户都附带了一个 wait 包。在使用等待时,您使用的是通常所说的显式等待。

    显式等待

    显示等待 是Selenium客户可以使用的命令式过程语言。它们允许您的代码暂停程序执行,或冻结线程,直到满足通过的 条件 。这个条件会以一定的频率一直被调用,直到等待超时。这意味着只要条件返回一个假值,它就会一直尝试和等待

    由于显式等待允许您等待条件的发生,所以它们非常适合在浏览器及其DOM和WebDriver脚本之间同步状态。

    为了弥补我们之前的错误指令集,我们可以使用等待来让 findElement 调用等待直到脚本中动态添加的元素被添加到DOM中:

    from selenium.webdriver.support.ui import WebDriverWait
    def document_initialised(driver):
        return driver.execute_script("return initialised")
    
    driver.navigate("file:///race_condition.html")
    WebDriverWait(driver).until(document_initialised)
    el = driver.find_element(By.TAG_NAME, "p")
    assert el.text == "Hello from JavaScript!"
    

    我们将 条件 作为函数引用传递, 等待 将会重复运行直到其返回值为true。“truthful”返回值是在当前语言中计算为boolean true的任何值,例如字符串、数字、boolean、对象(包括 WebElement )或填充(非空)的序列或列表。这意味着 空列表 的计算结果为false。当条件为true且阻塞等待终止时,条件的返回值将成为等待的返回值。

    有了这些知识,并且因为等待实用程序默认情况下会忽略 no such element 的错误,所以我们可以重构我们的指令使其更简洁:

    from selenium.webdriver.support.ui import WebDriverWait
    
    driver.navigate("file:///race_condition.html")
    el = WebDriverWait(driver).until(lambda d: d.find_element_by_tag_name("p"))
    assert el.text == "Hello from JavaScript!"
    

    在这个示例中,我们传递了一个匿名函数(但是我们也可以像前面那样显式地定义它,以便重用它)。传递给我们条件的第一个,也是唯一的一个参数始终是对驱动程序对象 WebDriver 的引用。在多线程环境中,您应该小心操作传入条件的驱动程序引用,而不是外部范围中对驱动程序的引用。

    因为等待将会吞没在没有找到元素时引发的 no such element 的错误,这个条件会一直重试直到找到元素为止。然后它将获取一个 WebElement 的返回值,并将其传递回我们的脚本。

    如果条件失败,例如从未得到条件为真实的返回值,等待将会抛出/引发一个叫 timeout error 的错误/异常。

    选项

    等待条件可以根据您的需要进行定制。有时候是没有必要等待缺省超时的全部范围,因为没有达到成功条件的代价可能很高。

    等待允许你传入一个参数来覆盖超时:

    WebDriverWait(driver, timeout=3).until(some_condition)
    

    预期的条件

    由于必须同步DOM和指令是相当常见的情况,所以大多数客户端还附带一组预定义的 预期条件 。顾名思义,它们是为频繁等待操作预定义的条件。

    不同的语言绑定提供的条件各不相同,但这只是其中一些:

    • alert is present
    • element exists
    • element is visible
    • title contains
    • title is
    • element staleness
    • visible text

    您可以参考每个客户端绑定的API文档,以找到期望条件的详尽列表:

    • Java’s org.openqa.selenium.support.ui.ExpectedConditions class
    • Python’s selenium.webdriver.support.expected_conditions class
    • .NET’s OpenQA.Selenium.Support.UI.ExpectedConditions type

    隐式等待

    还有第二种区别于显示等待 类型的 隐式等待 。通过隐式等待,WebDriver在试图查找_任何_元素时在一定时间内轮询DOM。当网页上的某些元素不是立即可用并且需要一些时间来加载时是很有用的。

    默认情况下隐式等待元素出现是禁用的,它需要在单个会话的基础上手动启用。将显式等待和隐式等待混合在一起会导致意想不到的结果,就是说即使元素可用或条件为真也要等待睡眠的最长时间。

    警告: 不要混合使用隐式和显式等待。这样做会导致不可预测的等待时间。例如,将隐式等待设置为10秒,将显式等待设置为15秒,可能会导致在20秒后发生超时。

    隐式等待是告诉WebDriver如果在查找一个或多个不是立即可用的元素时轮询DOM一段时间。默认设置为0,表示禁用。一旦设置好,隐式等待就被设置为会话的生命周期。

    driver = Firefox()
    driver.implicitly_wait(10)
    driver.get("http://somedomain/url_that_delays_loading")
    my_dynamic_element = driver.find_element(By.ID, "myDynamicElement")
    

    流畅等待

    流畅等待实例定义了等待条件的最大时间量,以及检查条件的频率。

    用户可以配置等待来忽略等待时出现的特定类型的异常,例如在页面上搜索元素时出现的NoSuchElementException。

    driver = Firefox()
    driver.get("http://somedomain/url_that_delays_loading")
    wait = WebDriverWait(driver, 10, poll_frequency=1, ignored_exceptions=[ElementNotVisibleException, ElementNotSelectableException])
    element = wait.until(EC.element_to_be_clickable((By.XPATH, "//div")))
    
    展开全文
  • Inproctester在后台使用了码头,但是它允许绕过任何套接字和http层直接将请求分发到正在测试的Web应用程序。 注意球衣 Inproctester提供了jersey-client实现,该实现允许将请求直接分派到打包为j2ee Web应用程序的...
  • WebDriver API

    千次阅读 多人点赞 2018-01-08 00:32:01
    WebDriver 就是通过这信息来找到不同的元素的。 WebDriver 提供了八种元素定位方法: (1)id (2)name (3)class name (4)tag name 标签名 (5) link text (6)partial
  • 1.动态id定位到元素forexample://WebElement xiexin_element=driver.findElement(By.id("_mail_component_82_82")); WebElementxiexin_element=driver.findElement(By.xpath("//span[contains(.,'写...
  • WebDriver允许我们设置默认的文件下载路径,也就是说,文件会自动下载并且存放到设置的目录中,下面以FireFox浏览器为例,执行文件的下载。 案例1 from selenium import webdriver from time import sleep import...
  • Selenium 的 webdriver

    2019-03-20 19:28:32
    Selenium 的 webdriver 2019-3-19 注意:我们目前正在编写这些部分的文档。我们相信这里的信息是准确的,但请注意我们仍然在编写本章。我们将提供更多信息,这将使本章更加扎实。 引进的webdriver Selenium 2.0的...
  • Selenium Webdriver原理终于搞清楚了

    千次阅读 2020-12-09 17:52:12
    前言 selenium1.x:这个时候的selenium,使用的是JavaScript注入技术与浏览器打交道。需要Selenium RC启动一个Server,将操作Web...这种Javascript注入技术的缺点是速度理想,而且稳定性大大依赖于Selenium内核对
  • 本文将介绍如何处理下拉和多选择操作 从下拉框中选择–>...2. 在WebDriver中将下拉框实例化为Select对象 例如,进入Mercury Tours的注册页面(http://demo.guru99.com/test/newtours/register.p...
  • WebDriver允许显示诸如警告之类的弹出窗口。要访问警报中的元素(比如它包含的消息),必须使用 switchTo().alert() 方法。 在下面的代码中,我们将使用此方法访问警报框,然后使用 getText() 方法检索其消息,然后...
  • windows下安装selenium+python3+chromewebdriver编写目的搭建过程python3.8.2安装pip版本更新selenium安装chrome浏览器安装webdriver安装 编写目的 本文章编写的目的主要是本次在windowes下安装selenium+webdriver...
  • Selenium-WebDriver的开发是为了更好地支持动态网页,页面元素可能会在重新加载页面的情况下发生变化。WebDriver的目标是提供精心设计的面向对象的API,为现代高级Web应用程序测试问题提供改进的支持。 **...
  • 在做web应用的自动化测试时,定位元素是必可少的,这个过程经常会碰到定位到元素的情况(报...这个是最常见的原因,首先要理解下frame的实质,frame中实际上是嵌入了另一个页面,而webdriver每次只能在一...
  • 转载:...1.动态id定位到元素 for example:  //WebElement xiexin_element = driver.findElement(By.id("_mail_component_82_82"));  WebElement xiexin_el...
  • 现在我们讨论的Selenium,通常是Selenium3(Selenium+WebDriver)。但在很多年前,Selenium与WebDriver是两个拥有不同原理的技术。 ​ Selenium1 #mermaid-svg-gC2Mlv6qckt6Ihxu .label{font-family:'trebuchet ms', ...
  • from selenium import webdriver是官方推荐的import方式,然后你可以通过webdriver.Firefox、webdriver.FirefoxProfile、webdriver.Chrome、webdriver.ChromeOptions、webdriver.Ie、webdriver.Opera、webdriver....
  • webdriver定位到元素

    2016-08-16 15:41:09
    1.动态id定位到元素 for example:  //WebElement xiexin_element = driver.findElement(By.id("_mail_component_82_82"));  WebElement xiexin_element = driver.findElement(By.xpath("//span[contains
  • 用键盘右下角的UP,DOWN按键来处理...from selenium import webdriverimport timefrom selenium.webdriver.common.keys import Keys#访问百度driver=webdriver.Chrome()driver.get("http://www.baidu.com")#搜索dri...
  • webdriver.Chrome参数解释

    千次阅读 2020-02-24 12:08:34
    最直接最讲道理的方式就是看源码,使用之前一定要学会看说明书。 打算使用jupyter演示的,但是jupyter支持看源码,所以使用Pycharm吧。 from selenium import webdriver Broswer = webdriver.Chrome(executable...
  • You can download Selenium WebDriver from the links that are mentioned below: Selenium WebDriver直接与浏览器通信,因此它需要像Selenium Server这样的任何独立组件。 它支持对软件测试人员有用的顶级编程...
  • 简介:Selenium WebDriver是一个浏览器自动化测试的API集合,提供很多与浏览器自动化交互的特性,并且这些API主要用于测试web程序。 python环境安装selenium 1.mac下安装配置pip(已安装python的mac) 打开终端,...
  • 前言上一篇文章《selenium webdriver 是怎么运行的》用了一个简单的例子——搭出租车,形象地讲解selenium webdriver 是如何运行的,而这一篇文章可以理解为深入了解selenium是如何和浏览器驱动进行交互,也可以认为...
  • from selenium import webdriver driver=webdriver.Firefox(executable_path='f://geckodriver') #executable_path方法指明浏览器驱动所在的目录 url='http://www.baidu.com' #想要访问的网址 driver.get(url) #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,772
精华内容 1,508
关键字:

webdriver 允许不安全的http

友情链接: FLUENT数据提取.zip