自动化测试(5) | Selenium Python WebDr

2016-06-15 本文已影响2456人厲铆兄

WebDriver 设计模式

欢迎阅读WebDriver进阶讲义。本篇讲义将会重点介绍Selenium WebDriver 自动化框架的设计，着重使用Page Object设计模式，以及使用HTML测试报告和集成测试报告并自动发送邮件。

Page Object 设计模式

在讨论设计模式之前，我们首先接着上一个讲义，来讨论自动化测试框架。

什么是框架？

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。可以说，一个框架是一个可复用的设计构件，它规定了应用的体系结构，阐明了整个设计、协作构件之间的依赖关系、责任分配和控制流程，表现为一组抽象类以及其实例之间协作的方法，它为构件复用提供了上下文(Context)关系。因此构件库的大规模重用也需要框架。其实目前为止，框架还没有统一定义，我比较喜欢Ralph Johnson所给出的定义：

一个框架是一个可复用设计，它是由一组抽象类及其实例间协作关系来表达的【Johnson 98】。这个定义是从框架内涵的角度来定义框架的，当然也可以从框架用途的角度来给出框架的定义：一个框架是在一个给定的问题领域内，一个应用程序的一部分设计与实现【Bosch 97】。

为什么要用框架？

又是一个理所当然的问题。因为软件系统发展到今天已经很复杂了，特别是服务器端软件，涉及到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。

为什么要搭建自动化测试框架？

从前我以为，自动化测试最重要的事情是找对象（To Find Test Object）。现在我明白了一个道理，没有框架的自动化测试是找不到对象的，即使找到了也不会幸福的。就跟现实中，没有车没有房的人是很难找到对象的一个道理。

自动化测试的开发，通常是由自动化测试的需求决定的。这个需求主要包括：

自动化测试更便于实施。这个说的是，你写测试脚本要方便。一个好的自动化测试框架是可以让不那么懂技术的人也可以写自动化测试脚本的，哼。

解决自动化测试脚本本身存在的问题，如异常处理和场景恢复。

测试易于维护。自动化测试项目，基本都是没有好的管理以及维护，一定是个大坑。我可以很负责地说，自动化测试没有一年半载，你是看不到产出的。所以管理及维护就成了最重要的事情。而好的框架，可以减少你在管理维护中所投入的人力物力精力。

可重用性。框架的意义之一就在于可重用吧。所以在框架里，你可以实现一些通用功能，简化脚本开发过程。

美观易读的测试报告。拿Selenium来说，它产出的测试报告只是基于测试脚本的，并没有那种基于测试集的报告，所以如果你要，测试框架里可以实现。

还有很多测试需求，我没办法一一列举出来，多数需求我们都可以在测试框架里去定制。现在可以回答上面那个问题了，record & playback是不会幸福的，你需要自动化测试框架。

请慎重考虑是否需要自动化测试

自动化测试的特点（成本投入高，风险大）

自动化测试是个很傲娇的东西，它很挑项目。首先项目周期要长，但是需求不会频繁变更；其次系统中多数对象要可以被识别，并且不存在大量第三方插件。而且你要清楚，你不能指望自动化测试去帮你发现新的bug，自动化测试本身是不具备想象力的（相对于手工测试）。它的优势在于反复迭代，它的价值产出在于长期的回归测试，以保证被测产品长期稳定地版本更新。

关于自动化测试的切入点，通常要在完整的系统测试之后才算具备引入自动化测试的基本条件。

目前我所做的自动化测试成功案例，无一不具备良好的管理和优良的测试框架。二者缺一，自动化测试必然成为大坑。填坑的成本，很高。

Page Object 设计原理

Page Object设计模式是Selenium自动化测试项目的最佳设计模式之一，强调测试、逻辑、数据和驱动相互分离。

Page Object模式是Selenium中的一种测试设计模式，主要是将每一个页面设计为一个Class，其中包含页面中需要测试的元素（按钮，输入框，标题等），这样在Selenium测试页面中可以通过调用页面类来获取页面元素，这样巧妙的避免了当页面元素id或者位置变化时，需要改测试页面代码的情况。当页面元素id变化时，只需要更改测试页Class中页面的属性即可。

它的好处如下：

集中管理元素对象
集中管理一个page内的公共方法
后期维护方便

Page Object 的对象

WebDriver封装
- 这里是对Selenium的封装，完成封装以后的基本封装代码。
Page 基类
- 设计了一个基本的Page类，以便所有的页面进行继承，该类标明了一个sub page类的基本功能和公共的功能。
Sub Pages(s)子类
- 具体的页面的类，定义了某个具体的页面的功能。
Tests 类
- 这部分描述的是具体的测试用例。
定义Test Suite
- 多个测试用例添加在一个Test套件里面，一起执行。
定义Test Runner
- 设计测试的Runner，开启整个测试，并且对测试的结果生成HTML测试报告，并通过邮件发送到指定邮箱。
定义测试的主入口
- 定义测试的主要入口类，代码的入口

HTML测试报告

HTML测试报告需要引入HTMLTestRunner

from ranzhiWeekend import HTMLTestRunner

HTMLTestRunner是基于Python2.7的，我们的课程讲义基于Python3.x，那么需要对这个文件做一定的修改。

测试的示例代码如下

        # 声明一个测试套件
        suite = unittest.TestSuite()
        # 添加测试用例到测试套件
        suite.addTest(RanzhiTests("test_ranzhi_login"))

        # 创建一个新的测试结果文件
        buf = open("./result.html", "wb")

        # 声明测试运行的对象
        runner = HTMLTestRunner.HTMLTestRunner(stream=buf,
                                               title="Ranzhi Test Result",
                                               description="Test Case Run Result")
        # 运行测试，并且将结果生成为HTML
        runner.run(suite)

        # 关闭文件输出
        buf.close()

集成测试报告

使用邮件发送HTML测试报告的脚本如下

        # 打开测试报告结果
        f = open("./result.html", "rb")

        # 将测试结果放到邮件的主体中
        mailBody = f.read()
        # 关闭测试结果的文件
        f.close()

        # 声明一个邮件对象，用刚刚得到的邮件主体
        msg = MIMEText(mailBody, "html", "utf-8")
        # 设置邮件的主题
        msg["subject"] = Header("Automation Test Result", "utf-8")

        # 创建一个SMTP服务对象
        # simple message transfer protocol
        # 简单的消息转移协议
        smtpMail = smtplib.SMTP()

        # 连接SMTP的服务器
        smtpMail.connect("mail.51testing.com")

        # 登录SMTP的服务器
        smtpMail.login("liutingli@51testing.com", "123456789")

        # 使用SMTP的服务器发送邮件
        smtpMail.sendmail("liutingli@51testing.com", targetEmail, msg.as_string())

        # 退出SMTP对象
        smtpMail.quit()

自动化测试框架示例

WebDriver封装

# coding=utf-8
from selenium import webdriver
from selenium.webdriver.support.select import Select


class AutomateDriver(object):
    """
    a simple demo of selenium framework tool
    """

    def __init__(self):

        driver = webdriver.Firefox()
        try:
            self.driver = driver
        except Exception:
            raise NameError("Firefox Not Found!")


    def clearCookies(self):
        """
        clear all cookies after driver init
        """
        self.driver.delete_all_cookies()

    def refreshBrowser(self):
        self.driver.refresh()

    def maximizeWindow(self):
        self.driver.maximize_window()

    def navigate(self, url):
        self.driver.get(url)

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

    def closeBrowser(self):
        self.driver.close()

    def getElement(self, selector):
        """
        to locate element by selector
        :arg
        selector should be passed by an example with "i,xxx"
        "x,//*[@id='langs']/button"
        :returns
        DOM element
        """
        if ',' not in selector:
            return self.driver.find_element_by_id(selector)
        selector_by = selector.split(',')[0]
        selector_value = selector.split(',')[1]

        if selector_by == "i" or selector_by == 'id':
            element = self.driver.find_element_by_id(selector_value)
        elif selector_by == "n" or selector_by == 'name':
            element = self.driver.find_element_by_name(selector_value)
        elif selector_by == "c" or selector_by == 'class_name':
            element = self.driver.find_element_by_class_name(selector_value)
        elif selector_by == "l" or selector_by == 'link_text':
            element = self.driver.find_element_by_link_text(selector_value)
        elif selector_by == "p" or selector_by == 'partial_link_text':
            element = self.driver.find_element_by_partial_link_text(selector_value)
        elif selector_by == "t" or selector_by == 'tag_name':
            element = self.driver.find_element_by_tag_name(selector_value)
        elif selector_by == "x" or selector_by == 'xpath':
            element = self.driver.find_element_by_xpath(selector_value)
        elif selector_by == "s" or selector_by == 'selector_selector':
            element = self.driver.find_element_by_css_selector(selector_value)
        else:
            raise NameError("Please enter a valid type of targeting elements.")

        return element

    def type(self, selector, text):
        """
        Operation input box.

        Usage:
        driver.type("i,el","selenium")
        """
        el = self.getElement(selector)
        el.clear()
        el.send_keys(text)

    def click(self, selector):
        """
        It can click any text / image can be clicked
        Connection, check box, radio buttons, and even drop-down box etc..

        Usage:
        driver.click("i,el")
        """
        el = self.getElement(selector)
        el.click()

    def selectByIndex(self, selector, index):
        """
        It can click any text / image can be clicked
        Connection, check box, radio buttons, and even drop-down box etc..

        Usage:
        driver.select_by_index("i,el")
        """
        el = self.getElement(selector)
        Select(el).select_by_index(index)

    def clickByText(self, text):
        """
        Click the element by the link text

        Usage:
        driver.click_text("新闻")
        """
        self.getElement('p,' + text).click()

    def submit(self, selector):
        """
        Submit the specified form.

        Usage:
        driver.submit("i,el")
        """
        el = self.getElement(selector)
        el.submit()

    def executeJs(self, script):
        """
        Execute JavaScript scripts.

        Usage:
        driver.js("window.scrollTo(200,1000);")
        """
        self.driver.execute_script(script)

    def getAttribute(self, selector, attribute):
        """
        Gets the value of an element attribute.

        Usage:
        driver.get_attribute("i,el","type")
        """
        el = self.getElement(selector)
        return el.getAttribute(attribute)

    def getText(self, selector):
        """
        Get element text information.

        Usage:
        driver.get_text("i,el")
        """
        el = self.getElement(selector)
        return el.text

    def getDisplay(self, selector):
        """
        Gets the element to display,The return result is true or false.

        Usage:
        driver.get_display("i,el")
        """
        el = self.getElement(selector)
        return el.is_displayed()

    def getTitle(self):
        '''
        Get window title.

        Usage:
        driver.get_title()
        '''
        return self.driver.title

    def getUrl(self):
        """
        Get the URL address of the current page.

        Usage:
        driver.get_url()
        """
        return self.driver.current_url

    def acceptAlert(self):
        '''
            Accept warning box.

            Usage:
            driver.accept_alert()
            '''
        self.driver.switch_to.alert.accept()

    def dismissAlert(self):
        '''
        Dismisses the alert available.

        Usage:
        driver.dismissAlert()
        '''
        self.driver.switch_to.alert.dismiss()

    def implicitlyWait(self, secs):
        """
        Implicitly wait. All elements on the page.

        Usage:
        driver.implicitly_wait(10)
        """
        self.driver.implicitly_wait(secs)

    def switchFrame(self, selector):
        """
        Switch to the specified frame.

        Usage:
        driver.switch_to_frame("i,el")
        """
        el = self.getElement(selector)
        self.driver.switch_to.frame(el)

    def switchDefaultFrame(self):
        """
        Returns the current form machine form at the next higher level.
        Corresponding relationship with switch_to_frame () method.

        Usage:
        driver.switch_to_frame_out()
        """
        self.driver.switch_to.default_content()

    def openNewWindow(self, selector):
        '''
        Open the new window and switch the handle to the newly opened window.

        Usage:
        driver.open_new_window()
        '''
        original_windows = self.driver.current_window_handle
        el = self.getElement(selector)
        el.click()
        all_handles = self.driver.window_handles
        for handle in all_handles:
            if handle != original_windows:
                self.driver._switch_to.window(handle)

Base Page类

class RanzhiBasePage():
    def __init__(self, driver, baseUrl):
        """
        构造方法
        :param driver: 封装好的webdriver
        :param baseUrl: 然之系统的基本url http://【localhost:808】/ranzhi/www
        """

        self.baseUrl = baseUrl
        self.driver = driver

    def openPage(self, url):
        """
        打开然之系统的页面，通过拼接URL的方式
        :param url: /sys/index.html
        :return:
        """
        self.driver.navigate(self.baseUrl + url)

Sub Page类

from ranzhiWeekend.ranzhi_base_page import RanzhiBasePage


class RanzhiSubLoginPage(RanzhiBasePage):
    def __init__(self, driver, baseUrl):
        """

        :param driver:
        :param baseUrl:
        """
        # 调用其 基类 RanzhiBasePage的 构造函数
        # 实现 基类 的构造函数的功能
        super().__init__(driver, baseUrl)
        self.loginPageUrl = "/sys/user-login.html"
        self.mainPageUrl = "/sys/index.html"
        self.driver.clearCookies()

    def login(self, userName, password):
        self.openPage(self.loginPageUrl)
        # self.driver.clearCookies()
        self.driver.implicitlyWait(5)
        self.driver.type("account", userName)
        self.driver.type("password", password)
        self.driver.click("submit")

    def getMainPage(self):
        return self.baseUrl + self.mainPageUrl

Tests Case 类

import unittest
from time import sleep

from ranzhiWeekend.automate_driver import AutomateDriver
from ranzhiWeekend.ranzhi_sub_login_page import RanzhiSubLoginPage

"""
1. 导入 unittest
2. 继承 unittest.TestCase
3. 写用例 方法以 test 开头
4. 考虑使用 setUp() 和 tearDown()
"""


class RanzhiTests(unittest.TestCase):
    def setUp(self):
        """
        开始每个测试前的准备事项
        :return:
        """
        self.autoDriver = AutomateDriver()
        self.baseUrl = "http://localhost:808/ranzhi/www"

    def tearDown(self):
        """
        结束每个测试后的清理工作
        :return:
        """
        self.autoDriver.quitBrowser()

    def test_ranzhi_login(self):
        """
        测试用例：测试然之登录
        :return:
        """
        # 新建然之的页面对象
        loginPage = RanzhiSubLoginPage(self.autoDriver, self.baseUrl)

        # 利用然之的页面对象进行登录
        loginPage.login("admin", "admin")
        sleep(2)
        # 断言 是否登录成功
        self.assertEqual(loginPage.getMainPage(), self.autoDriver.getUrl(), u"登录失败")

Tests Runner类

import smtplib
import unittest
from email.header import Header
from email.mime.text import MIMEText

from ranzhiWeekend import HTMLTestRunner
from ranzhiWeekend.ranzhi_tests_0605 import RanzhiTests


class RanzhiTestRunner():

    def runTest(self):
        """
        运行测试用例
        :return:
        """

        # 声明一个测试套件
        suite = unittest.TestSuite()
        # 添加测试用例到测试套件
        suite.addTest(RanzhiTests("test_ranzhi_login"))

        # 创建一个新的测试结果文件
        buf = open("./result.html", "wb")

        # 声明测试运行的对象
        runner = HTMLTestRunner.HTMLTestRunner(stream=buf,
                                               title="Ranzhi Test Result",
                                               description="Test Case Run Result")
        # 运行测试，并且将结果生成为HTML
        runner.run(suite)

        # 关闭文件输出
        buf.close()

    def sendEmail(self, targetEmail):
        """
        发送邮件
        :param targetEmail:
        :return:
        """

        # 打开测试报告结果
        f = open("./result.html", "rb")

        # 将测试结果放到邮件的主体中
        mailBody = f.read()
        # 关闭测试结果的文件
        f.close()

        # 声明一个邮件对象，用刚刚得到的邮件主体
        msg = MIMEText(mailBody, "html", "utf-8")
        # 设置邮件的主题
        msg["subject"] = Header("Automation Test Result", "utf-8")

        # 创建一个SMTP服务对象
        # simple message transfer protocol
        # 简单的消息转移协议
        smtpMail = smtplib.SMTP()

        # 连接SMTP的服务器
        smtpMail.connect(“***.******.com")

        # 登录SMTP的服务器
        smtpMail.login(“*******@*****.com", “*********")

        # 使用SMTP的服务器发送邮件
        smtpMail.sendmail(“*******@********.com", targetEmail, msg.as_string())

        # 退出SMTP对象
        smtpMail.quit()

main函数入口

if __name__ == "__main__":
    # 实例化一个runner
    runner = RanzhiTestRunner()

    # 执行测试
    runner.runTest()

    # 发送测试结果
    runner.sendEmail(“********@******.com")