转载来自：https://www.cnblogs.com/AlwinXu/p/5836709.html

1 什么是selenium

Selenium 是一个基于浏览器的自动化工具，它提供了一种跨平台、跨浏览器的端到端的web自动化解决方案。Selenium主要包括三部分：Selenium IDE、Selenium WebDriver 和Selenium Grid：

  • Selenium IDE：Firefox的一个扩展，它可以进行录制回放，并可以把录制的操作以多种语言（例如java，python等）的形式导出成测试用例。
  • Selenium WebDriver：提供Web自动化所需的API，主要用作浏览器控制、页面元素选择和调试。不同的浏览器需要不同的WebDriver。
  • Selenium Grid：提供了在不同机器的不同浏览器上运行selenium测试的能力

本文中主要使用python结合Selenium WebDriver库进行自动化测试框架的搭建。

2 自动化测试框架

一个典型的自动化测试框架一般包括用例管理模块、自动化执行控制器、报表生成模块和日志模块等，这些模块之间不是相互孤立的，而是相辅相成的。
基于Selenium的web自动化框架 - 图1
下面来介绍下每个模块的逻辑单元：

  • 用例管理模块

用例管理模块包括用例的添加、修改、删除等操作单元，这些单元也会涉及到用例书写的模式，测试数据的管理、可复用库等

  • 自动化执行控制器

控制器是自动化用例执行的组织模块，主要负责以什么方式去执行用例。比较典型的控制器有用户图形界面（GUI）和“commandline+文件”两种。

  • 报表生成模块

报表生成模块主要负责执行完用例以后生成报表，报表一般以HTML格式居多，信息主要包括用例的执行情况及相应的总结报告。另外还可以添加发送邮件功能。

  • 日志模块

日志模块主要用来记录用例的执行情况，以便于更高效的调查用例失败信息及追踪用例执行情况。

3 自动化框架的设计与实现

3.1 需求分析

测试对象是一个典型的后台系统的Web展现平台，基于此平台设计的自动化框架要包含测试用例管理、测试执行控制、测试报表及测试日志的生成，整体测试框架要轻量易用。

3.2 概要设计

概要设计包括了四个大的模块：公共库模块（可复用函数、日志管理、报表管理以及发送邮件管理）、用例仓库（具体用例的管理）、页面管理（单独对Web页面进行抽象，封装页面元素和操作方法）以及执行模块。
概要设计类图：

基于Selenium的web自动化框架 - 图2

3.3 详细设计与实现

3.3.1 页面管理

  1.             测试Web对象是一个典型的单页面应用，因此采用页面模式（page pattern）来进行组织：<br />![](https://cdn.nlark.com/yuque/0/2021/png/12782194/1615463122523-2f5f36ba-9d82-41de-bf52-b3c4dd124bb9.png#align=left&display=inline&height=101&margin=%5Bobject%20Object%5D&originHeight=101&originWidth=327&size=0&status=done&style=none&width=327)<br />页面模式是页面与测试用例之间的桥梁，它将每个页面抽象成一个单独的页面类，为测试用例提供页面元素的定位和操作。<br />页面模式的类图如下：<br />![](https://cdn.nlark.com/yuque/0/2021/png/12782194/1615463177025-1f463124-4f23-48e7-96c5-8e85bba3d59c.png#align=left&display=inline&height=665&margin=%5Bobject%20Object%5D&originHeight=665&originWidth=480&size=0&status=done&style=none&width=480)<br />![](https://cdn.nlark.com/yuque/0/2021/jpeg/12782194/1615463212756-a832e6cc-e0a0-46f4-9dd3-586605508823.jpeg#align=left&display=inline&height=317&margin=%5Bobject%20Object%5D&originHeight=317&originWidth=684&size=0&status=done&style=none&width=684)
  1. class BasePage(object):  
  2.     """description of class"""  
  4.     #webdriver instance  
  5.     def __init__(self, driver):  
  6.         self.driver = driver

LoginPage页面继承自BasePage，并进行Login Page的元素定位及操作实现。代码中定位了username和password，并且添加了设置用户名和密码的操作。

  1. from BasePage import BasePage  
  2. from selenium.webdriver.common.by import By  
  3. from selenium.webdriver.common.keys import Keys  
  5. class LoginPage(BasePage):  
  6.     """description of class"""  
  7.      #page element identifier  
  8.     usename = (By.ID,'username')  
  9.     password = (By.ID, 'password')  
  10.     dialogTitle = (By.XPATH,"//h3[@class=\"modal-title ng-binding\"]")  
  11.     cancelButton = (By.XPATH,'//button[@class=\"btn btn-warning ng-binding\"][@ng-click=\"cancel()\"]')  
  12.     okButton = (By.XPATH,'//button[@class=\"btn btn-primary ng-binding\"][@ng-click=\"ok()\"]')  
  14.     #Get username textbox and input username  
  15.     def set_username(self,username):  
  16.         name = self.driver.find_element(*LoginPage.usename)  
  17.         name.send_keys(username)  
  19.     #Get password textbox and input password, then hit return  
  20.     def set_password(self, password):  
  21.         pwd = self.driver.find_element(*LoginPage.password)  
  22.         pwd.send_keys(password + Keys.RETURN)  
  24.     #Get pop up dialog title  
  25.     def get_DiaglogTitle(self):  
  26.         digTitle = self.driver.find_element(*LoginPage.dialogTitle)  
  27.         return digTitle.text  
  29.     #Get "cancel" button and then click  
  30.     def click_cancel(self):  
  31.         cancelbtn = self.driver.find_element(*LoginPage.cancelButton)  
  32.         cancelbtn.click()  
  34.      #click Sign in  
  35.     def click_SignIn(self):  
  36.         okbtn = self.driver.find_element(*LoginPage.okButton)  
  37.         okbtn.click()

采用页面模式来管理页面和测试用例有很多好处，主要体现在：

  • 简单并且清晰

每个页面都有单独的类来封装页面元素和操作，让页面操作更加具体化，而不是相对独立的。
比如未使用页面模式，测试用例的输入用户名和密码的代码：

  1.  #enter username and password  
  2. driver.find_element_by_id("username").clear()  
  3. driver.find_element_by_id("username").send_keys("sbxadmin")  
  4. driver.find_element_by_id("password").clear()  
  5. driver.find_element_by_id("password").send_keys("password"+Keys.RETURN)

使用页面模式之后，输入用户名和密码的代码：

  1. #Step2: Open Login page  
  2. login_page = BasePage.LoginPage(self.driver)  
  3. #Step3: Enter username  
  4. login_page.set_username("username")  
  5. #Step4: Enter password  
  6. login_page.set_password("password")

通过对比我们不难发现，未使用页面模式的代码组织比较混乱，步骤多，可读性非常差，不难想象，一个通篇都是find_element_by_id或者send_Keys的测试用例到底有多糟糕！而使用了页面模式之后，在哪个页面做什么操作都非常清晰，非常接近测试用例的步骤，易读性非常好。

  • 可复用性好

由于页面操作都被封装在了页面类中，所以页面方法和容易调用，可复用性非常好。而未使用页面模式的用例只能每次都实现一遍。

  • 可维护性好

由于测试目标页面的多变性，页面元素的定位经常需要改变，利用了页面模式后，只需要修改一遍其页面类中的定位就可以对所用用到该元素的测试用例生效；而在未使用该模式的情况下，必须修改每一个用到该元素的测试用例，非常容易遗漏，工作量也非常大。
综合以上页面模式的各种优点，我们在以后的web自动化中可以多使用该模式来组织页面。

3.3.2 公共库模块

  1.             公共库模块是为创建测试用例服务的，它主要包括常量、公共函数、日志管理、报表管理以及发送邮件管理等。<br />                公共库模块涉及到的功能一般多而杂，在设计的时候只要遵循高内聚低耦合就可以了。比如常量、变量和一些公共函数可以放在同一个文件中Common.py：
  1. from datetime import datetime  
  3. def driverPath():  
  4.     return r'C:\Users\xua\Downloads\chromedriver_win32\chromedriver.exe'  
  5. def baseUrl():  
  6.     return "https://xxx.xxx.xxx.xxx:9000"  
  7. #change time to str  
  8. def getCurrentTime():  
  9.     format = "%a %b %d %H:%M:%S %Y"  
  10.     return datetime.now().strftime(format) 
  11. # Get time diff  
  12. def timeDiff(starttime,endtime):  
  13.     format = "%a %b %d %H:%M:%S %Y"  
  14.     return datetime.strptime(endtime,format) - datetime.strptime(starttime,format)

测试用例信息类用来标识测试用例，并且包括执行用例执行结果信息，主要包括以下字段：

  1. class TestCaseInfo(object):  
  2.     """description of class"""  
  3.     def __init__(self, id="",name="",owner="",result="Failed",starttime="",endtime="",secondsDuration="",errorinfo=""):  
  4.         self.id = id  
  5.         self.name = name  
  6.         self.owner = owner  
  7.         self.result = result  
  8.         self.starttime = starttime  
  9.         self.endtime = endtime  
  10.   self.secondsDuration = secondsDuration  
  11.   self.errorinfo = errorinfo

测试用例信息需要在每个测试用例中实例化，以便对测试用例进行标记，并最终体现在测试报告中。
日志主要用来记录测试用例执行步骤及产生的错误信息，不同的信息有不同的日志级别，比如Information，Warning，Critical和Debug。由于每个测试用例产生的日志条目比较少，所以在测试框架中只利用了最高级别的日志打印，即Debug级别，该级别也会将其他所有的日志级别的信息同样打印出来。在具体的实现中引用了Python标准库中的logging类库，以便更方便的控制日志输出：

  1. import logging  
  2. import ResultFolder  
  4. logger = logging.getLogger()  
  5. logger.setLevel(logging.DEBUG)  
  8. def CreateLoggerFile(filename):  
  9.     try:  
  10.         fulllogname = ResultFolder.GetRunDirectory()+"\\"+filename+".log"  
  11.         fh = logging.FileHandler(fulllogname)  
  12.         fh.setLevel(logging.DEBUG)  
  13.         formatter = logging.Formatter('%(asctime)s [line:%(lineno)d] %(message)s')  
  14.         fh.setFormatter(formatter)  
  15.         logger.addHandler(fh)  
  16.     except Exception as err:  
  17.         logger.debug("Error when creating log file, error message: {}".format(str(err)))  
  20. def Log(message):  
  21.     logger.debug(message)

报表管理及发送邮件模块实现了报表（html格式）的生成及自动发送邮件的功能。报表和邮件依附于当前测试的执行，每次执行都会独立的触发报表生成和邮件发送。该模块主要运用了Python中的lxml、smtplib和email库。

3.3.3 用例仓库

  1.             用例仓库主要用来组织自动化测试用例。每条测试用例都被抽象成一个独立的类，并且均继承自unittest.TestCase类。 Python中的unittest库提供了丰富的测试框架支持，包括测试用例的setUp和tearDown方法，在实现用例的过程中可以重写。依托页面管理和公共库模块实现的页面方法和公共函数，每一个测试用例脚本的书写都会非常清晰简洁，一个简单的Floor Manager Lite的登录用例如下：  
  1. class Test_TC_Login(unittest.TestCase):  
  2.     def setUp(self):  
  3.         self.driver = webdriver.Chrome(cc.driverPath())  
  4.         self.base_url = cc.baseUrl()  
  5.         self.testCaseInfo = TestCaseInfo(id=1,name="Test case name",owner='xua')  
  6.         self.testResult = TestReport()  
  7.         LogUtility.CreateLoggerFile("Test_TC_Login")  
  8.     def test_A(self):  
  9.         try:  
  10.             self.testCaseInfo.starttime = cc.getCurrentTime()  
  11.             #Step1: open base site  
  12.             LogUtility.Log("Open Base site"+self.base_url)  
  13.             self.driver.get(self.base_url)  
  15.             #Step2: Open Login page  
  16.             login_page = LoginPage(self.driver)  
  18.             #Step3: Enter username & password  
  19.             LogUtility.Log("Login web using username")  
  20.             login_page.set_username("username")  
  21.             login_page.set_password("password")  
  23.             time.sleep(2)  
  24.             #Checkpoint1: Check popup dialog title  
  25.             LogUtility.Log("Check whether sign in dialog exists or not")  
  26.             self.assertEqual(login_page.get_DiaglogTitle(),"Sign in")  
  28.             #time.sleep(3)  
  29.             #Step4: Cancel dialog  
  30.             login_page.click_cancel()  
  31.             self.testCaseInfo.result = "Pass"  
  33.         except Exception as err:  
  34.             self.testCaseInfo.errorinfo = str(err)  
  35.             LogUtility.Log(("Got error: "+str(err)))  
  36.         finally:  
  37.             self.testCaseInfo.endtime = cc.getCurrentTime()  
  38.             self.testCaseInfo.secondsDuration = cc.timeDiff(self.testCaseInfo.starttime,self.testCaseInfo.endtime)  
  39.     def tearDown(self):  
  40.         self.driver.close()  
  41.         self.testResult.WriteHTML(self.testCaseInfo)  
  43. if __name__ == '__main__':  
  44.     unittest.main()

从这个测试用例中，我们可以看到

  1. Setup中定义了执行测试用例前的一些实例化工作
  2. tearDown对执行完测试做了清理和写日志文件工作
  3. 测试步骤、测试数据和测试检查点非常清晰，易修改（比如用户名密码）

  4. 日志级别仅有Debug，所以写日志仅需用同一Log方法

    3.3.4 用例执行模块（控制器）

    1.          执行模块主要用来控制测试用例脚本的批量执行，形成一个测试集。用例的执行引用了Python标准库中的subprocess来执行nosetests的shell命令，从而执行给定测试用例集中的用例。测试用例集是一个简单的纯文本文件，实现过程中利用了.txt文件testcases.txt：
    1. Test_Login_pass.py  
    2. Test_Login_Fail.py  
    3. #Test_MainPage_CheckSecurityTableInfo.py  
    4. Test_MainPage_EditSecurityInfo.py

    用例前没有“#“标记的测试用例脚本会被执行，而有”#“标记的则会被忽略，这样可以很方便的控制测试集的执行，当然也可以创建不同的文件来执行不同的测试集。
    具体的调用代码如下：

    1. def LoadAndRunTestCases(self):  
    2.  try:  
    3.      f = open(self.testcaselistfile)  
    4.      testfiles = [test for test in f.readlines() if not test.startswith("#")]  
    5.      f.close()  
    6.      for item in testfiles:  
    7.          subprocess.call("nosetests "+str(item).replace("\\n",""),shell = True)  
    8.  except Exception as err:  
    9.      LogUtility.logger.debug("Failed running test cases, error message: {}".format(str(err)))  
    10.  finally:  
    11.      EmailUtils.send_report()

    3.4 执行结果

    测试用例执行完毕后主要有两种输出：日志和测试报告。测试报告会html附件的形式通过邮件发出，例如：
    基于Selenium的web自动化框架 - 图3

    4 需要改进的模块

    对于现有实现的测试框架，已经可以满足web对象的自动化需求，但还是有些可以改进提高的地方，比如：

  5. 针对部分测试用例是否可以尝试数据驱动

  6. 添加屏幕截图功能
  7. 封装selenium中By库中的函数，以便更高效的定位页面元素等
  8. 结合业界优秀的自动化框架和实践持续改进

5 总结

  1.      基于selenium实现的web自动化框架不仅轻量级而且灵活，可以快速的开发自动化测试用例。结合本篇中的框架设计以及一些好的实践，希望对大家以后的web自动化框架的设计和实现有所帮助。<br /> <br />源代码：[https://github.com/AlvinXuCH/WebAutomaiton](https://github.com/AlvinXuCH/WebAutomaiton)