selenium2 python自动化测试实战(回归测试)

selenium2 python自动化测试实战

最近接手商城的项目，针对后台测试，功能比较简单，但是流程比较繁多，涉及到前后台的交叉测试。在对整个项目进行第一轮测试完成之后，考虑以后回归测试任务比较重，为了减轻回归测试的工作量，所以考虑后台可以进行部分自动化测试。

之前一个项目使用robotframework进行回归测试，了解了python语言，所以这次就使用python2.7+selenium2进行自动化回归测试了。

配置环境

• python2.7
• 运行工具pycharm2017

一、项目结构介绍

mztestpro/

|------------bbs/

||---------------data/

|||-------------------upload.au3

|||-------------------upload.exe

||---------------report/

|||----------------------image/

||||----------------------------login.jpg

||||----------------------------addproduct.jpg

|||----------------------Y-02-02 10_27_10result.html

|||----------------------Y-02-02 10_28_10result.html

||---------------test_case/

|||-------------------------models/

||||-------------------------------driver.py

||||-------------------------------function.py

||||-------------------------------myunit.py

|||-------------------------page_obj/

||||----------------------------------agentPage.py

||||----------------------------------agentQueryPage.py

||||----------------------------------base.py

||||----------------------------------employeePage.py

||||----------------------------------employeeQueryPage.py

||||----------------------------------hotelPage.py

||||----------------------------------hotelQueryPage.py

||||----------------------------------productcategoryPage.py

||||----------------------------------productcategoryQueryPage.py

||||----------------------------------productinfoPage.py

||||----------------------------------productinfoQueryPage.py

||||----------------------------------rolePage.py

||||----------------------------------roleQueryPage.py

||||----------------------------------userPage.py

||||----------------------------------userQueryPage.py

||||----------------------------------warehousePage.py

||||----------------------------------warehouseQueryPage.py

|||-------------------------agent_sta.py

|||-------------------------employee_sta.py

|||-------------------------hotel_sta.py

|||-------------------------login_sta.py

|||-------------------------productcategory.py

|||-------------------------productinfo_sta.py

|||-------------------------role_sta.py

|||-------------------------user_sta.py

|||-------------------------warehouse_sta.py

|------------driver/

||-----------------sun.jpg

||-----------------upload.au3

||-----------------upload.exe

||-----------------upload1.au3

||-----------------upload1.exe

|------------package/

||--------------------addr.py

||--------------------card.py

||--------------------HTMLTestRunner.py

|------------run_bbs_test.py

|------------startup.bat

|­­­­­------------自动化测试项目说明文档.docx

项目结构如图所示

项目框架采用的是po模式，如果对框架有疑问可以参考selenium+python自动化测试系列(一)：登录或Selenium2+Python自动化测试实战

1.mztestpro测试项目模块介绍

bbs:用于存放BBS项目的测试用例、测试报告和测试数据等。

driver：用于存放浏览器驱动。如selenium­server­standalone­2.47.0jar、chromedriver.exe、IEDriverServer.exe等。在执行测试前根据执行场景将浏览器驱动复制到系统环境path目录下。

package：用于存放自动化所用到的扩展包。例如：HTMLTestRunner.py属于一个单独模块和随机手机号和身份证号模块

run_bbs_test.py：项目主程序。用来运行商城（BBS）自动化用例。

startup.bat：用于启动selenium server，默认启动driver目录下的selenium­server­standalone­2.44.0.jar。

自动化测试项目说明文档.docx：介绍当前项目的架构、配置和使用说明。

2.bbs目录

data：该目录用来存放测试相关数据。

report：用于存放HTML测试报告。其下面创建了image目录用于存放测试过程中的截图。

test_case：测试用例目录，用于存放测试用例及相关模块。

3.test_case

models：该目录下存放了一些公共的配置函数及公共类。

page_obj：该目录用于存放测试用例的页面对象（Page Object）。根据自定义规则，以“*Page.py”命名的文件为封装的页面对象文件。

_sta.py：测试用例文件。根据测试文件匹配规则，以“_sta.py”命名的文件被当作自动化测试用例执行。

二、编写公共模块

首先定义驱动文件：

...\mztestpro\bbs\test_case\models\driver.py

driver.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
from selenium.webdriver import Remote
from selenium import webdriver
import sys
# 启动浏览器
reload(sys)
sys.setdefaultencoding('utf8')
def browser():
		driver = webdriver.Firefox()
		return driver

if __name__ == '__main__':
	dr = browser()
	dr.get("http://192.168.16.6/hotelManage")
	dr.quit()

定义浏览器驱动函数browser()，该函数可以进行配置，根据我们的需要，配置测试用例在不同的主机及浏览器下运行。

自定义测试框架类：

...\mztestpro\bbs\test_case\models\myunit.py

myunit.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
import unittest,sys
from selenium import webdriver
from driver import browser
reload(sys)
sys.setdefaultencoding('utf8')

class MyTest(unittest.TestCase):
	def setUp(self):
	self.driver = browser()
	self.driver.implicitly_wait(10)
	self.driver.maximize_window()

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

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

定义MyTest()类用于集成unittest.TestCase类，因为笔者创建的所有测试类中setUp()与tearDown()方法所做的

事情相同，所以，将他们抽象为MyTest()类，好处就是在编写测试用例时不再考虑这两个方法的实现。

定义截图函数：

...\mztestpro\bbs\test_case\models\function.py

function.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
from selenium import webdriver
import os,sys
reload(sys)
sys.setdefaultencoding('utf8')
# 截图函数
def insert_img(driver, file_name):
	base_dir = os.path.dirname(os.path.dirname(__file__))
	base_dir = str(base_dir)
	base_dir = base_dir.replace('\\', '/')
	base = base_dir.split('test_case')[0]
	file_path = base + "report/image/" + file_name
	driver.get_screenshot_as_file(file_path)

if __name__ == '__main__':
	driver = webdriver.Firefox()
	driver.get("http://192.168.16.6/hotelManage")
	insert_img(driver, 'login.jpg')
	driver.quit()

创建截图函数insert_img()，为了保持自动化项目的移植性，采用相对路径的方式将测试截图保持到.\report\image目录中。

三、编写Page Object

首先创建基础Page基础类(商城为例)：

...\mztestpro\bbs\test_case\page_obj\base.py

base.py

# -*-coding:utf-8-*-
# _author_ = "janehost"

from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import sys
reload(sys)
sys.setdefaultencoding('utf8')
class Page(object):

	'''
	页面基础类，用于所有页面的继承
	'''

	base_url = "http://192.168.16.6/hotelManage"

	def __init__(self, selenium_driver, base_url=base_url, parent=None):
		self.base_url = base_url
		self.driver = selenium_driver
		self.timeout = 30
		self.parent = parent

	def _open(self, url):
		url = self.base_url + url
		self.driver.get(url)
		assert self.on_page(), 'Did not land on %s' % url

	def open(self):
		self._open(self.url)

	def on_page(self):
		#return (self.driver.current_url).encode('utf-8') == (self.base_url + self.url)
		return self.driver.current_url.encode('utf-8') == (self.base_url + self.url)

	def find_element(self, *loc):
		# return self.driver.find_element(*loc)
		try:
		# 确保所有元素是可见的
		# 注意：以下入参为元组的元素，需要加*。python存在这种特性，就是将入参放在元组里。
		#WebDriverWait(self.driver,10).until(lambda driver: driver.find_element(*loc).is_displayed())
		# 注意：以下入参本身是元组，不需要加*
			WebDriverWait(self.driver, 10).until(EC.visibility_of_element_located(loc))
			return self.driver.find_element(*loc)
		except:
			print u"%s 页面中未能找到 %s 元素"%(self, loc)

	def find_elements(self, *loc):
		return self.driver.find_elements(*loc)

	def script(self, src):
		return self.driver.execute_script(src)

	def swtich_frame(self, loc):
		return self.driver.swith_to_frame(loc)

	def send_keys(self, loc, value, clear_first=True, click_first=True):
		try:
			# getattr相当于self.loc
			loc = getattr(self, "_%s" % loc)
			if click_first:
				self.find_element(*loc).click()
			if clear_first:
				self.find_element(*loc).clear()
			self.find_element(*loc).send_keys(value)
		except ArithmeticError:
			print u"%s 页面中未能找到 %s 元素" % (self, loc)

创建页面基础类，通过__init__()方法初始化参数：浏览器驱动、URL地址、超时时长等。定义基本方法：open()用于打开BBS地址：find_element()和find_elements()分别用来定位单个与多个元素；创建script()方法可以更简便地调用JavaScript代码。当然还可以对更多的WebDriver方法进行重定义。

创建BBS登录对象类：

...\mztestpro\bbs\test_case\page_obj\loginPage.py

loginPage.py

登录页面元素的封装page_obj\loginPage.py，代码如下

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：创建登录页面对象，对用户登录页面上的用户名/密码输入框、登录按钮和
提示信息等元素的定位进行封装。
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class login(Page):

	'''
	用户登录界面
	'''
	url = '/'
	# 登录用户名的定位
	login_username_loc = (By.ID, 'username')
	# 登录密码的定位
	login_password_loc = (By.ID,'password')
	# 登录按钮的定位
	login_button_loc = (By.CSS_SELECTOR,'.btn.btn-success.btn-block')
	# 登录错误提示的定位
	login_error_loc = (By.ID,'error_msg')
	# 登录成功用户名信息
	login_user_success_loc = (By.XPATH, 'html/body/div[3]/div[2]/ul/li[1]/a/strong')

	# 登录用户名
	def login_username(self, username):
		self.find_element(*self.login_username_loc).clear()
		self.find_element(*self.login_username_loc).send_keys(username)

	# 登录密码
	def login_password(self, password):
		self.find_element(*self.login_password_loc).clear()
		self.find_element(*self.login_password_loc).send_keys(password)

	# 登录按钮
	def login_button(self):
	self.find_element(*self.login_button_loc).click()

	# 统一登录入口
	def user_login(self, username="testuser01", password="testgood001"):
	# 获取用户名和页面登录
		self.open()
		self.login_username(username)
		self.login_password(password)
		self.login_button()
		sleep(3)

	# 登录错误提示信息
	def login_error_hint(self):
		return self.find_element(*self.login_error_loc).text

	# 登录成功用户名信息
	def login_user_success(self):
		#return self.find_element(*self.login_user_success_loc).text
		username = self.find_element(*self.login_user_success_loc).text
		username = username.strip('您好：')
		return username

创建登录页面对象，对用户登录页面上的用户名/密码输入框、登录按钮和提示信息等元素的定位进行封装。除此之外，还创建user_login()方法作为系统统一登录的入口。关于对操作步骤的封装可以放在Page Object当中，也可以放在测试用例当中，这个主要根据具体的需求来衡量。这里之所以要放在Page Object当中，主要考虑到还会有其他的测试用例调用到该登录方法。为username 和 password 入参数设置了默认值是为了方便其他用例在调用user_login()时不用再传递登录用户信息，因为该系统大多用例的执行使用该账号即可，同时也方便了在账号失效时的修改。

hotelPage.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：创建登录页面对象，对用户登录页面上的用户名/密码输入框、登录按钮和
提示信息等元素的定位进行封装。除此之外，还创建user_login()方法作为系统统
一登录的入口。关于对操作步骤的封装可以放在Page Object当中，
也可以放在测试用例当中，这个主要根据具体的需求来衡量。这里之所以要放在
Page Object当中，主要考虑到还会有其他的测试用例调用到该登录方法。
为username 和 password 入参数设置了默认值是为了方便其他用例在调用
user_login()时不用再传递登录用户信息，因为该系统大多用例的执行使用该账号
即可，同时也方便了在账号失效时的修改。
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class hotel(Page):

	'''
	酒店添加界面
	'''
	url = '/hotel/add'
	# 酒店名称的定位
	hotel_name_loc = (By.NAME, 'hotel.hotel_name')
	# 酒店联系人的定位
	hotel_contacts_loc = (By.NAME, 'hotel.contacts')
	# 酒店联系电话的定位
	hotel_phone_loc = (By.NAME, 'hotel.phone')
	# 酒店邮箱的定位
	hotel_email_loc = (By.NAME, 'hotel.email')
	# 酒店地址的定位
	hotel_address_loc = (By.NAME, 'hotel.address')
	# 酒店对账日的定位,前期默认
	# 酒店床垫最小消费时间的定位
	hotel_hour_loc = (By.NAME, 'hotel.min_hour')
# 酒店照片上传，使用autoit进行上传操作
	hotel_pic_loc = (By.ID, 'upload1')
	# 酒店添加页面中的保存按钮的定位
	hotel_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button')

	# 酒店名称
	def add_hotel_name(self, hotel_name):
		self.find_element(*self.hotel_name_loc).clear()
		self.find_element(*self.hotel_name_loc).send_keys(hotel_name)

	# 酒店联系人
	def add_hotel_contacts(self, hotel_contacts):
		self.find_element(*self.hotel_contacts_loc).clear()
		self.find_element(*self.hotel_contacts_loc).send_keys(hotel_contacts)

	# 酒店联系电话
	def add_hotel_phone(self, hotel_phone):
		self.find_element(*self.hotel_phone_loc).clear()
		self.find_element(*self.hotel_phone_loc).send_keys(hotel_phone)

	# 酒店邮箱
	def add_hotel_email(self, hotel_email):
		self.find_element(*self.hotel_email_loc).clear()
		self.find_element(*self.hotel_email_loc).send_keys(hotel_email)

	# 酒店地址
	def add_hotel_address(self, hotel_address):
		self.find_element(*self.hotel_address_loc).clear()
		self.find_element(*self.hotel_address_loc).send_keys(hotel_address)

	# 酒店床垫最小消费市场
	def add_hotel_hour(self, hotel_hour):
		self.find_element(*self.hotel_hour_loc).clear()
		self.find_element(*self.hotel_hour_loc).send_keys(hotel_hour)

	# # 酒店页面js打开方法
	# def get_hotel_url(self, url):
	# self.script(self.base_url+url)

	# 酒店添加页面保存按钮
	def add_hotel_button(self):
		self.find_element(*self.hotel_button_loc).click()

	# 统一酒店添加入口
	def add_hotel(self, hotel_name="test", hotel_contacts="123456",
		hotel_phone="15245898745", hotel_email="23090932@qq.com",
		hotel_address="weosdsdf", hotel_hour="2"):
		# 获取酒店添加页面
		self.open()
		# self.script(self.base_url + self.url)
		self.add_hotel_name(hotel_name)
		sleep(3)
		self.add_hotel_contacts(hotel_contacts)
		self.add_hotel_phone(hotel_phone)
		sleep(3)
		self.add_hotel_email(hotel_email)
		self.add_hotel_address(hotel_address)
		self.add_hotel_hour(hotel_hour)
		sleep(3)
		self.add_hotel_button()
		sleep(3)

		# 错误提示信息

hotelQueryPage.py

    主要为了验证添加的酒店信息正确，酒店添加成功之后页面会跳转到酒店查询页面中。

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在酒店query页面中，获取酒店的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class hotelquery(Page):

	'''
	酒店query界面
	'''
	hotel_query_url = '/hotel/query'
	# 酒店名称的定位
	wineshop_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')

	# 获取酒店名称
	def get_hotel_name(self):
		# self.open()
		wineshop_name = self.find_element(*self.wineshop_name_loc).text
		return wineshop_name

agentPage.py

    主要是酒店的代理商和代理商query页面封装

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：代理商新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class agent(Page):

	'''
	代理商新增页面
	'''
	url = '/agent/toEdit'
	# 代理商编号的定位
	agent_code_loc = (By.NAME, 'agent.code')
	# 代理商名称的定位
	agent_name_loc = (By.NAME, 'agent.name')
	# 代理商联系电话的定位
	agent_phone_loc = (By.NAME, 'agent.phone')
	# 代理商邮箱的定位
	agent_email_loc = (By.NAME, 'agent.email')
	# 代理商地址定位
	agent_address_loc = (By.NAME, 'agent.address')
	# 代理商提成率的定位
	agent_payment_loc = (By.NAME, 'agent.payment_rate')
		# 代理商折扣率的定位
	agent_discount_loc = (By.NAME, 'agent.discount_rate')

	# 代理商添加页面中的保存按钮的定位
	agent_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button')

	# 代理商编号
	def get_agent_code(self):
		return self.find_element(*self.agent_code_loc).get_attribute("value")

	# 代理商名称
	def add_agent_name(self, agent_name):
		self.find_element(*self.agent_name_loc).clear()
		self.find_element(*self.agent_name_loc).send_keys(agent_name)

	# 代理商联系电话
	def add_agent_phone(self, agent_phone):
		self.find_element(*self.agent_phone_loc).clear()
		self.find_element(*self.agent_phone_loc).send_keys(agent_phone)

	# 代理商邮箱
	def add_agent_email(self, agent_email):
		self.find_element(*self.agent_email_loc).clear()
		self.find_element(*self.agent_email_loc).send_keys(agent_email)

	# 代理商地址
	def add_agent_address(self, agent_address):
		self.find_element(*self.agent_address_loc).clear()
		self.find_element(*self.agent_address_loc).send_keys(agent_address)

	# 代理商提成率
	def add_agent_payment(self, agent_payment):
		self.find_element(*self.agent_payment_loc).clear()
		self.find_element(*self.agent_payment_loc).send_keys(agent_payment)

	# 代理商折扣率
	def add_agent_discount(self, agent_discount):
		self.find_element(*self.agent_discount_loc).clear()
		self.find_element(*self.agent_discount_loc).send_keys(agent_discount)

	# 代理商添加页面保存按钮
	def add_agent_button(self):
		self.find_element(*self.agent_button_loc).click()

	# 统一代理商添加入口
	def add_agent(self, agent_name="test", agent_phone="15245898745",
		agent_email="23090932@qq.com", agent_address="weosdsdf",
		agent_payment="20", agent_discount="50"):
		# 获取代理商添加页面
		self.open()
		# self.script(self.base_url + self.url)
		# 获取添加页面的代理商编码
		# agent_code = self.find_element(*self.agent_code_loc).get_attribute("value")
		# return agent_code
		self.add_agent_name(agent_name)
		sleep(3)
		self.add_agent_phone(agent_phone)
		self.add_agent_email(agent_email)
		sleep(3)
		self.add_agent_address(agent_address)
		self.add_agent_payment(agent_payment)
		self.add_agent_discount(agent_discount)
		sleep(3)
		self.add_agent_button()
		sleep(3)
		# 代理商编号

agentQueryPage.py

    代理商query页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在代理商query页面中，获取代理商的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class agentquery(Page):

   '''
    代理商query页面
   '''
 agent_query_url = '/agent/query'
 # 代理商编号的定位
 factor_code_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')
 # 代理商名称定位
 factor_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[2]')

  # 获取代理商编码
 def get_factor_code(self):
    # self.open()
     factor_code = self.find_element(*self.factor_code_loc).text
     return factor_code

  # 获取代理商名称
 def get_factor_name(self):
     factor_name = self.find_element(*self.factor_name_loc).text
     return factor_name

productcategoryPage.py

产品类型页面page类

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：产品类型新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class productcategory(Page):
		'''
		产品类型添加页面
		'''
		url = "/product/toEditCategory"
		# 产品类型名称定位
		productcategory_name_loc = (By.NAME, 'productCategory.name')
		# 产品类型描述定位
		productcategory_des_loc = (By.NAME, 'productCategory.description')
		# 产品类型有效性定位
		productcategory_enable_loc = (By.NAME,
                              'html/body/div[1]/form/div[2]/div[3]/div/div[1]/i')
		# 产品类型禁用定位
		productcategory_disable_loc = (By.NAME,
                               'html/body/div[1]/form/div[2]/div[3]/div/div[2]/i')
		# 产品类型保存按钮
		productcategory_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button')

		# 产品名称
		def add_productcategory_name(self, productcategory_name):
    		self.find_element(*self.productcategory_name_loc).clear()
    		self.find_element(*self.productcategory_name_loc).send_keys(productcategory_name)

	# 产品类型
		def add_productcategory_des(self, productcategory_des):
    		self.find_element(*self.productcategory_des_loc).clear()
    		self.find_element(*self.productcategory_des_loc).send_keys(productcategory_des)

	# 产品类型有效性
		def add_productcategory_en(self):
    		self.find_element(*self.productcategory_enable_loc).click()

	# 产品类型无效
		def add_productcategory_dis(self):
    		self.find_element(*self.productcategory_disable_loc).click()

		# 产品类型保存按钮
		def add_productcategory_button(self):
    		self.find_element(*self.productcategory_button_loc).click()

	# 产品类型统一添加入口
		def add_productcategory(self, productcategory_name = 'prodoctcategory001',
                        productcategory_des = 'productcategorydes001'):
    		self.open()
    		self.add_productcategory_name(productcategory_name)
    		self.add_productcategory_des(productcategory_des)
    		self.add_productcategory_button()

productcategoryQueryPage.py

主要是产品类型查询页面元素

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在产品类型query页面中，获取酒店的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class productcategoryquery(Page):

		'''
		产品类型query界面
		'''
		productcategory_query_url = '/product/queryCategory'
		# 产品类型名称的定位
		category_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')
		# 产品类型状态定位
		category_state_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[3]')

	# 产品类型名称
	def get_category_name(self):
		category_name = self.find_element(*self.category_name_loc).text
    		return category_name

	# 产品类型状态
		def get_category_state(self):
    		# self.open()
    		category_state = self.find_element(*self.category_name_loc).text
    		return category_state

pageinfoPage.py

产品信息页面page

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：产品信息新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep
import os

class productinfo(Page):
		'''
		产品信息添加页面
		'''
		url = "/product/toEdit"
		# 未实现
		filepath = "C:\Users\Admin\PycharmProjects\untitled1\mztestpro\driver\upload1.exe"

	#产品名称定位
		product_name_loc = (By.NAME, 'product.name')
		# 产品类型定位
		product_category_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[2]/div[1]/div/div/div/input')
		# 产品类型选择按钮定位
		productinfo_category_loc = (By.XPATH,
                              'html/body/div[1]/form/div[2]/div[2]/div[1]/div/div/dl/dd[2]')
		# 产品信息租赁单价定位
		product_rent_loc = (By.NAME, 'product.rent_price')
		# 产品销售单价定位
		product_sale_loc = (By.NAME, 'product.sales_price')
		# 是否热销产品，此处默认选择否

		#产品描述定位
		product_des_loc = (By.NAME, 'product.description')
		# 产品出口绑定编号，是-[默认是否]
		product_bind_loc =(By.XPATH, 'html/body/div[1]/form/div[2]/div[4]/div/div[1]/i')
		# 产品上传图片
		'''
        	# 针对input格式的文件或图片上传可以使用下面此方法进行操作
        	# 导航图的定位和上传
        	#self.driver.find_element_by_id("upload1").clear()
        	self.driver.find_element_by_id("upload1").send_keys("C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(3)
        	# 产品详情图的定位和上传
        	self.driver.find_element_by_id("test2").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)
        	# 第二张产品详情图的上传
        	self.driver.find_element_by_id("test2").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)
        	# 第三张产品详情图的上传
        	self.driver.find_element_by_id("test2").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)
        	# 第四张产品详情图的上传
        	self.driver.find_element_by_id("test2").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)

        	#产品导航多图上传
        	self.driver.find_element_by_id("test3").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)
        	# 第二张产品导航图的上传
        	self.driver.find_element_by_id("test3").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)
        	# 第三张产品导航图的上传
        	self.driver.find_element_by_id("test3").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	#第四张产品导航图的上传
        	self.driver.find_element_by_id("test3").send_keys(
            "C:\Users\Admin\PycharmProjects\untitled1\hotel\pic\sun.jpg")
        	time.sleep(5)
        '''

		# 第一步首先定位上传导航图的按钮
		product_upload1_loc = (By.ID, 'upload1')
		# 产品详情图片上传
		product_upload2_loc = (By.ID, 'test2')
		#产品导航多图上传
		product_upload3_loc = (By.ID, 'test3')

		# 产品信息保存按钮
		product_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button[1]')

		# 产品名称
		def add_product_name(self, product_name):
    		self.find_element(*self.product_name_loc).clear()
    		self.find_element(*self.product_name_loc).send_keys(product_name)

	# 产品类型
		def add_product_category(self):
   			self.find_element(*self.product_category_loc).click()

	# 产品信息中产品类型下拉选择
		def add_product_select(self):
    		self.find_element(*self.productinfo_category_loc).click()

	# 租赁单价
		def add_product_rent(self, product_rent):
    		self.find_element(*self.product_rent_loc).clear()
    		self.find_element(*self.product_rent_loc).send_keys(product_rent)

	# 销售单价
		def add_product_sale(self, product_sale):
    		self.find_element(*self.product_sale_loc).clear()
    		self.find_element(*self.product_sale_loc).send_keys(product_sale)

	# 是否热销产品下拉选择--未完成

		# 产品描述
		def add_product_des(self, product_des):
    		self.find_element(*self.product_des_loc).clear()
    		self.find_element(*self.product_des_loc).send_keys(product_des)

	# 添加产品绑定设备
		def add_product_bind(self):
    		self.find_element(*self.product_bind_loc).click()

	# 使用auotIt进行导航图上传
		def add_product_pic1(self):
    		self.find_element(*self.product_upload1_loc).click()
    	# 调用upload.exe文件
    		os.system("C:\Users\Admin\PycharmProjects\untitled1\mztestpro\driver\upload1.exe")

	# 使用autoIt进行产品详情图上传
		def add_product_pic2(self):
    		self.find_element(*self.product_upload2_loc).click()
    		# 调用upload.exe文件
    		os.system("C:\Users\Admin\PycharmProjects\untitled1\mztestpro\driver\upload1.exe")

	# 使用autoIt进行导航多图上传
		def add_product_pic3(self):
    		self.find_element(*self.product_upload3_loc).click()
    		# 调用upload.exe文件
    		os.system("C:\Users\Admin\PycharmProjects\untitled1\mztestpro\driver\upload1.exe")

	# 产品类型保存按钮
		def add_product_button(self):
    		self.find_element(*self.product_button_loc).click()

	# 产品类型统一添加入口
		def add_product(self, product_name='product001',product_rent='10',
                product_sale='20', product_des='productinofdes'):
    		self.open()
    		# 产品名称输入
    		self.add_product_name(product_name)
    		# 点击产品类型
    		self.add_product_category()
    		# 产品类型下拉框选择
    		self.add_product_select()
    		# 产品租赁单价输入
    		self.add_product_rent(product_rent)
    		# 产品销售单价输入
    		self.add_product_sale(product_sale)
    		# 产品热销产品默认

    		#产品描述输入
    		self.add_product_des(product_des)
    		# 产品图片上传
    		self.add_product_pic1()
    		#详情图片上传
    		# sleep(3)
    		self.add_product_pic2()
    		# sleep(4)
    		self.add_product_pic3()
    		sleep(3)
    		self.add_product_pic3()
    		# 产品保存按钮
    		self.add_product_button()

productinfoQueryPage.py

产品信息页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在产品类型query页面中，获取酒店的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class productinfoquery(Page):

		'''
		产品信息query界面
		'''
		productinfo_query_url = '/product/query'
		# 产品信息名称的定位
		productinfo_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')
		# 产品信息编码定位
		productinfo_code_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[2]')

	# 产品信息名称
		def get_productinfo_name(self):
    		productinfo_name = self.find_element(*self.productinfo_name_loc).text
    		return productinfo_name

	# 产品类型状态
		def get_productinfo_code(self):
    		# self.open()
    		productinfo_code = self.find_element(*self.productinfo_code_loc).text
    		return productinfo_code

warehouse.py

仓库信息页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：仓库新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class warehouse(Page):

		'''
		仓库新增页面
		'''
		url = '/warehouse/toEdit'
		# 仓库编号的定位
		warehouse_code_loc = (By.NAME, 'house.code')
		# 仓库名称的定位
		warehouse_name_loc = (By.NAME, 'house.name')
		# 仓库省市县定位
		warehouse_province_loc = (By.ID, 'province')
		warehouse_city_loc = (By.ID, 'city')
		warehouse_region_loc = (By.ID, 'region')
		warehouse_street_loc = (By.ID, 'street')
		# 仓库地址定位
		warehouse_address_loc = (By.ID, 'detail')
		# 仓库联系人的定位
		warehouse_contacts_loc = (By.ID, 'contacts')
		# 仓库联系电话的定位
		warehouse_phone_loc = (By.ID, 'phone')

	 # 仓库状态的定位
		warehouse_statue_loc = (By.XPATH, ".//*[@id='app']/form/div[2]/div[1]/div[3]/div/div/input")
		# 仓库描述信息定位
		warehouse_des_loc = (By.NAME, 'house.description')
		# 仓库添加页面中的保存按钮的定位
		warehouse_button_loc = (By.XPATH, ".//*[@id='app']/form/div[3]/div/button")

		# 仓库编号
		def get_warehouse_code(self):
    		return self.find_element(*self.warehouse_code_loc).get_attribute("value")

	# 仓库名称
		def add_warehouse_name(self, warehouse_name):
   	 		self.find_element(*self.warehouse_name_loc).clear()
    		self.find_element(*self.warehouse_name_loc).send_keys(warehouse_name)

	# 仓库省市区信息
		def add_warehouse_province(self,warehouse_province):
    		self.find_element(*self.warehouse_province_loc).clear()
    		self.find_element(*self.warehouse_province_loc).send_keys(warehouse_province)

		def add_warehouse_city(self,warehouse_city):
    		self.find_element(*self.warehouse_city_loc).clear()
    		self.find_element(*self.warehouse_city_loc).send_keys(warehouse_city)

		def add_warehouse_region(self,warehouse_region):
    		self.find_element(*self.warehouse_region_loc).clear()
    		self.find_element(*self.warehouse_region_loc).send_keys(warehouse_region)

		def add_warehouse_street(self, warehouse_street):
    		self.find_element(*self.warehouse_street_loc).clear()
    		self.find_element(*self.warehouse_street_loc).send_keys(warehouse_street)

    		# 仓库详细地址
		def add_warehouse_address(self, warehouse_address):
    		self.find_element(*self.warehouse_address_loc).clear()
    		self.find_element(*self.warehouse_address_loc).send_keys(warehouse_address)

    		# 仓库联系人
		def add_warehouse_contacts(self, warehouse_contacts):
    		self.find_element(*self.warehouse_contacts_loc).clear()
    		self.find_element(*self.warehouse_contacts_loc).send_keys(warehouse_contacts)

	# 仓库联系电话
		def add_warehouse_phone(self, warehouse_phone):
    		self.find_element(*self.warehouse_phone_loc).clear()
    		self.find_element(*self.warehouse_phone_loc).send_keys(warehouse_phone)

	# 仓库描述信息
		def add_warehouse_des(self, warehouse_des):
    		self.find_element(*self.warehouse_des_loc).clear()
    		self.find_element(*self.warehouse_des_loc).send_keys(warehouse_des)

	# 仓库添加页面保存按钮
		def add_warehouse_button(self):
    		self.find_element(*self.warehouse_button_loc).click()

		# 统一仓库添加入口
		def add_warehouse(self, warehouse_name="warehouse001",
                  warehouse_province="15245898745", warehouse_city='city15245898745',
                  warehouse_region='region15245898745', warehouse_street='street15245898745',
                  warehouse_address="23090932address", warehouse_contacts="warehousecontacts",
                  warehouse_phone='15245898745',warehouse_des='deswarehousecontacts'):
    		# 获取仓库添加页面
    		self.open()
    		# self.script(self.base_url + self.url)
    		# 获取添加页面的仓库编码
    		# agent_code = self.find_element(*self.agent_code_loc).get_attribute("value")
    		# return agent_code
    		self.add_warehouse_name(warehouse_name)
    		sleep(3)
    		self.add_warehouse_province(warehouse_province)
    		self.add_warehouse_city(warehouse_city)
    		sleep(3)
    		self.add_warehouse_region(warehouse_region)
    		self.add_warehouse_street(warehouse_street)
    		self.add_warehouse_address(warehouse_address)
    		self.add_warehouse_contacts(warehouse_contacts)
    		self.add_warehouse_phone(warehouse_phone)
    		self.add_warehouse_des(warehouse_des)
    		sleep(3)
    		self.add_warehouse_button()
    		sleep(3)

warehouseQueryPage.py

仓库查询页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在仓库query页面中，获取仓库的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class warehousequery(Page):

		'''
		仓库query页面
		'''
		agent_query_url = '/warehouse/query'
		# 仓库编号的定位
		depot_code_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')
		# 仓库名称定位
		depot_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[2]')

	# 获取仓库编码
		def get_depot_code(self):
		# self.open()
    		depot_code = self.find_element(*self.depot_code_loc).text
    		return depot_code

	# 获取仓库名称
		def get_depot_name(self):
    		depot_name = self.find_element(*self.depot_name_loc).text
    		return depot_name

employeePage.py

职员添加页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：职员新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class employee(Page):

		'''
		职员新增页面
		'''
		url = '/employee/toEdit'
		# 职员名称的定位
		employee_code_loc = (By.NAME, 'employees.employees_name')
		# 职员工号的定位
		employee_name_loc = (By.NAME, 'employees.job_number')
		# 职员性别为男
		employee_man_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[3]/div/div[1]/i')
		# 职员性别为女
		employee_wom_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[3]/div/div[2]/i')
		# 职员性别未知
		employee_sec_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[3]/div/div[3]/i')
		# 职员身份证号码定位
		employee_id_loc = (By.NAME, 'employees.card')
		# 职员联系电话的定位
		employee_phone_loc = (By.NAME, 'employees.phone')
		# 职员婚姻定位，这里选择默认

		# 职员文化程度，这里选择默认

		# 职员入职时间定位
		employee_date_loc = (By.ID, 'date')
		# 职员邮箱定位
		employee_email_loc = (By.NAME, 'employees.email')

		# 职员添加页面中的保存按钮的定位
		employee_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button[1]')

		# 职员名称
		def add_employee_name(self, employee_name):
   	 		self.find_element(*self.employee_name_loc).clear()
    		self.find_element(*self.employee_name_loc).send_keys(employee_name)

	# 职员工号
		def add_employee_code(self,employee_code):
    		self.find_element(*self.employee_code_loc).clear()
    		self.find_element(*self.employee_code_loc).send_keys(employee_code)

	# 职工身份证号码
		def add_employee_id(self, employee_id):
    		self.find_element(*self.employee_id_loc).clear()
    		self.find_element(*self.employee_id_loc).send_keys(employee_id)

	# 职员联系电话
		def add_employee_phone(self, employee_phone):
    		self.find_element(*self.employee_phone_loc).clear()
    		self.find_element(*self.employee_phone_loc).send_keys(employee_phone)

    	# 职员入职时间
		def add_employee_date(self, employee_date):
    		self.find_element(*self.employee_date_loc).clear()
    		self.find_element(*self.employee_date_loc).send_keys(employee_date)

    		# 职员邮箱
		def add_employee_email(self, employee_email):
    		self.find_element(*self.employee_email_loc).clear()
    		self.find_element(*self.employee_email_loc).send_keys(employee_email)

	# 职员添加页面保存按钮
		def add_employee_button(self):
    		self.find_element(*self.employee_button_loc).click()

		# 统一职员添加入口
		def add_employee(self, employee_name="employee001", employee_code='employee001',
                 employee_id='500106200406101329', employee_phone="15645898745",
                 employee_date='2018-01-11', employee_email="23090932@qq.com" ):
    		# 获取职员添加页面
    		self.open()
    		# self.script(self.base_url + self.url)
    		# 获取添加页面的职员编码
    		# employee_code = self.find_element(*self.employee_code_loc).get_attribute("value")
    		# return employee_code
    		self.add_employee_name(employee_name)
    		self.add_employee_code(employee_code)
    		sleep(3)
    		self.add_employee_id(employee_id)
    		self.add_employee_phone(employee_phone)
    		self.add_employee_date(employee_date)
    		self.add_employee_email(employee_email)
    		sleep(3)
    		self.add_employee_button()
    		sleep(3)

employeeQueryPage.py

职员查询页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在职员query页面中，获取代理商的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class employeequery(Page):

		'''
		职员query页面
		'''
		employee_query_url = '/employee/query'
		# 职员工号的定位
		staff_code_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[2]')
		# 职员名称定位
		staff_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')

	# 获取职员编码
		def get_staff_code(self):
    		# self.open()
    		staff_code = self.find_element(*self.staff_code_loc).text
    		return staff_code

	# 获取职员名称
		def get_staff_name(self):
    		staff_name = self.find_element(*self.staff_name_loc).text
    		return staff_name

rolePage.py

角色新增页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：角色新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class role(Page):

		'''
		角色新增页面
		'''
		url = '/role/toEdit'
		# 角色名称的定位
		role_name_loc = (By.NAME, 'role.role_name')
		# 角色描述定位
		role_des_loc = (By.NAME, 'role.role_desc')
		# 角色用户定位
		role_select_loc = (By.XPATH, ".//*[@id='b']/option[1]")
		# 选中角色的用户
		role_selected_loc = (By.NAME, 'bb')
		# 职员添加页面中的保存按钮的定位
		role_button_loc = (By.XPATH, 'html/body/div[1]/form/div[7]/div/button[1]')

		# 角色名称
		def add_role_name(self, role_name):
    		self.find_element(*self.role_name_loc).clear()
    		self.find_element(*self.role_name_loc).send_keys(role_name)

	# 角色描述
		def add_role_desc(self, role_desc):
    		self.find_element(*self.role_des_loc).clear()
    		self.find_element(*self.role_des_loc).send_keys(role_desc)

	# 角色用户操作
		def add_role_select(self):
    		self.find_element(*self.role_select_loc).click()
    		self.find_element(*self.role_selected_loc).click()

	# 角色添加页面保存按钮
		def add_role_button(self):
    		self.find_element(*self.role_button_loc).click()

		# 统一角色添加入口
		def add_role(self, role_name="role001", role_desc='role001'):
    		# 获取角色添加页面
    		self.open()
    		# self.script(self.base_url + self.url)
    		# 获取添加页面的职员编码
    		# employee_code = self.find_element(*self.employee_code_loc).get_attribute("value")
    		# return employee_code
    		self.add_role_name(role_name)
    		self.add_role_desc(role_desc)
    		self.add_role_select()
    		sleep(3)
    		self.add_role_button()
    		sleep(3)

roleQueryPage.py

角色查询页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在角色query页面中，获取角色的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class rolequery(Page):

		'''
		角色query页面
		'''
		role_query_url = '/role/query'
		# 角色名称的定位
		part_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')

	# 获取职员编码
		def get_part_name(self):
    		# self.open()
    		part_name = self.find_element(*self.part_name_loc).text
    		return part_name

hotelpricePage.py

酒店单价管理页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：创建登录页面对象，对用户登录页面上的用户名/密码输入框、登录按钮和
提示信息等元素的定位进行封装。除此之外，还创建user_login()方法作为系统统
一登录的入口。关于对操作步骤的封装可以放在Page Object当中，
也可以放在测试用例当中，这个主要根据具体的需求来衡量。这里之所以要放在
Page Object当中，主要考虑到还会有其他的测试用例调用到该登录方法。
为username 和 password 入参数设置了默认值是为了方便其他用例在调用
user_login()时不用再传递登录用户信息，因为该系统大多用例的执行使用该账号
即可，同时也方便了在账号失效时的修改。
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class hotelprice(Page):

	'''
	酒店单价添加界面
	'''
	url = '/hUnitPrice/toEdit'
	# 酒店单价新增中的酒店名称
	hotelprice_name_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[1]/div/div/div/div/input')
	# 酒店名称选择
	hotelprice_name_selected_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[1]/div/div/div/dl/dd[2]')
	# 酒店单价中的产品信息
	hotelprice_product_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[2]/div/div/div/div/input')
	# 酒店产品选择信息
	hotelprice_product_selected_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[2]/div/div/div/dl/dd[2]')
	# 酒店单价中的最小采购数量
	hotelprice_min_loc = (By.NAME, 'hotelUnitPrice.min_qty')
	# 酒店单价中的最大采购数量
	hotelprice_max_loc = (By.NAME, 'hotelUnitPrice.max_qty')
	# 酒店单价管理中的单价信息
	hotelprice_price_loc = (By.NAME, 'hotelUnitPrice.price')

	# 酒店单价添加页面中的保存按钮的定位
	hotelprice_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button[1]')

	# 酒店单价添加的酒店名称
	def add_hotelprice_name(self):
		self.find_element(*self.hotelprice_name_loc).click()
		self.find_element(*self.hotelprice_name_selected_loc).click()

	# 酒店单价中添加的产品信息
	def add_hotelprice_product(self):
		self.find_element(*self.hotelprice_product_loc).click()
		self.find_element(*self.hotelprice_product_selected_loc).click()

	# 酒店单价中的最小采购数量
	def add_hotelprice_min(self, hotelprice_min):
		self.find_element(*self.hotelprice_min_loc).clear()
		self.find_element(*self.hotelprice_min_loc).send_keys(hotelprice_min)

	# 酒店单价中的最大采购数量
	def add_hotelprice_max(self, hotelprice_max):
		self.find_element(*self.hotelprice_max_loc).clear()
		self.find_element(*self.hotelprice_max_loc).send_keys(hotelprice_max)

	# 酒店单价中的单价信息
	def add_hotelprice_price(self, hotelprice_price):
		self.find_element(*self.hotelprice_price_loc).clear()
		self.find_element(*self.hotelprice_price_loc).send_keys(hotelprice_price)

	# # 酒店页面js打开方法
	#     def get_hotel_url(self, url):
	#         self.script(self.base_url+url)

	# 酒店单价添加页面保存按钮
	def add_hotelprice_button(self):
		self.find_element(*self.hotelprice_button_loc).click()

	# 统一酒店添加入口
	def add_hotelprice(self, hotelprice_min="1", hotelprice_max="1000",
              hotelprice_price="1000"):
		# 获取酒店添加页面
		self.open()
		# self.script(self.base_url + self.url)
		# 选择酒店单价管理中的酒店名称
		self.add_hotelprice_name()
		# 选择酒店单价管理中高端酒店产品
		self.add_hotelprice_product()
		# 输入采购的数量和单价信息
		self.add_hotelprice_min(hotelprice_min)
		sleep(3)
		self.add_hotelprice_max(hotelprice_max)
		self.add_hotelprice_price(hotelprice_price)
		sleep(3)
		self.add_hotelprice_button()
		sleep(3)

		# 错误提示信息

hotelpirceQueryPage.py

酒店单价管理查询页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在酒店query页面中，获取酒店的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class hotelpricequery(Page):

	'''
	酒店query界面
	'''
	hotel_query_url = '/hUnitPrice/query'
		# 酒店单价产品名称的定位
		hotelproduct_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')
		# 酒店单价酒店名称定位
		hotelproduct_hotel_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[3]')

	# 获取酒店产品名称
		def get_hotelprice_name(self):
    		# self.open()
    		hotelproduct_name = self.find_element(*self.hotelproduct_name_loc).text
    		return hotelproduct_name

			# 获取酒店名称
		def get_hotelprice_hotel_name(self):
    		hotelproduct_hotel_name = self.find_element(*self.hotelproduct_hotel_name_loc).text
    		return hotelproduct_hotel_name

agentpricePage.py

代理商单价页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：创建登录页面对象，对用户登录页面上的用户名/密码输入框、登录按钮和
提示信息等元素的定位进行封装。除此之外，还创建user_login()方法作为系统统
一登录的入口。关于对操作步骤的封装可以放在Page Object当中，
也可以放在测试用例当中，这个主要根据具体的需求来衡量。这里之所以要放在
Page Object当中，主要考虑到还会有其他的测试用例调用到该登录方法。
为username 和 password 入参数设置了默认值是为了方便其他用例在调用
user_login()时不用再传递登录用户信息，因为该系统大多用例的执行使用该账号
即可，同时也方便了在账号失效时的修改。
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class agentprice(Page):

	'''
	代理商单价添加界面
	'''
	url = '/aUnitPrice/toEdit'
		# 代理商单价新增中的代理商名称
		agentprice_name_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[1]/div/div/div/div/input')
		# 代理商名称选择
		agentprice_name_selected_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[1]/div/div/div/dl/dd[2]')
		# 代理商单价中的产品信息
		agentprice_product_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[2]/div/div/div/div/input')
		# 代理商产品选择信息
		agentprice_product_selected_loc = (By.XPATH, 'html/body/div[1]/form/div[2]/div[2]/div/div/div/dl/dd[2]')
		# 代理商单价中的最小采购数量
		agentprice_min_loc = (By.NAME, 'agentUnitPrice.min_qty')
		# 代理商单价中的最大采购数量
		agentprice_max_loc = (By.NAME, 'agentUnitPrice.max_qty')
		# 代理商单价管理中的单价信息
		agentprice_price_loc = (By.ID, 'price')

		# 代理商单价添加页面中的保存按钮的定位
		agentprice_button_loc = (By.XPATH, 'html/body/div[1]/form/div[3]/div/button[1]')

	# 代理商单价添加的酒店名称
		def add_agentprice_name(self):
    		self.find_element(*self.agentprice_name_loc).click()
    		self.find_element(*self.agentprice_name_selected_loc).click()

	# 代理商单价中添加的产品信息
		def add_agentprice_product(self):
    		self.find_element(*self.agentprice_product_loc).click()
    		self.find_element(*self.agentprice_product_selected_loc).click()

	# 代理商单价中的最小采购数量
		def add_agentprice_min(self, agentprice_min):
    		self.find_element(*self.agentprice_min_loc).clear()
    		self.find_element(*self.agentprice_min_loc).send_keys(agentprice_min)

	# 代理商单价中的最大采购数量
		def add_agentprice_max(self, agentprice_max):
    		self.find_element(*self.agentprice_max_loc).clear()
    		self.find_element(*self.agentprice_max_loc).send_keys(agentprice_max)

	# 代理商单价中的单价信息
		def add_agentprice_price(self, agentprice_price):
    		self.find_element(*self.agentprice_price_loc).clear()
    		self.find_element(*self.agentprice_price_loc).send_keys(agentprice_price)

	# # 酒店页面js打开方法
	#     def get_hotel_url(self, url):
	#         self.script(self.base_url+url)

	# 代理商单价添加页面保存按钮
		def add_agentprice_button(self):
    		self.find_element(*self.agentprice_button_loc).click()

		# 统一代理商添加入口
		def add_agentprice(self, agentprice_min="1", agentprice_max="1000", agentprice_price="1000"):
    		# 获取代理商添加页面
    		self.open()
    		# self.script(self.base_url + self.url)
    		# 选择代理商单价管理中的酒店名称
    		self.add_agentprice_name()
    		# 选择代理商单价管理中高端酒店产品
    		self.add_agentprice_product()

    		# 输入采购的数量和单价信息
    		self.add_agentprice_min(agentprice_min)
    		sleep(3)
    		self.add_agentprice_max(agentprice_max)
    		self.add_agentprice_price(agentprice_price)
    		sleep(3)
    		self.add_agentprice_button()
    		sleep(3)

			# 错误提示信息

agentpriceQueryPage.py

代理商单价查询页面

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在酒店query页面中，获取酒店的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class agentpricequery(Page):

		'''
		代理商单价query界面
		'''
		agent_query_url = '/aUnitPrice/query'
		# 代理商单价产品名称的定位
		agentproduct_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')
		# 代理商单价酒店名称定位
		agentproduct_agent_name_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[3]')

	# 获取代理商单价产品名称
		def get_agentprice_name(self):
    		# self.open()
    		agentproduct_name = self.find_element(*self.agentproduct_name_loc).text
    		return agentproduct_name

		# 获取代理商单价名称
		def get_agentprice_agent_name(self):
    		agentproduct_agent_name = self.find_element(*self.agentproduct_agent_name_loc).text
    		return agentproduct_agent_name

userPage.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：用户新增页面
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from selenium.webdriver.support.select import Select

from base import Page
from time import sleep

class user(Page):

		'''
		职员用户页面
		'''
		url = '/user/toEdit'
		# 用户工号的定位
		user_code_loc = (By.ID, 'empIds')
		# 用户名的定位，默认修改
		user_name_loc = (By.ID, 'username')
		# 用户密码定位
		password = (By.ID, 'password')
		# 用户确认密码定位
		ppassword = (By.ID, 'ppassword')

		# 用户角色定位
		user_role_loc = (By.XPATH, ".//*[@id='b']/option[1]")
		# 用户角色选择定位
		user_select_loc = (By.NAME, 'bb')

		# 用户添加页面中的保存按钮的定位
		user_button_loc = (By.XPATH, 'html/body/div[1]/form/div[7]/div/button[1]')

		# 用户名称和工号
		def add_user_code(self):
    		Select(self.find_element(*self.user_code_loc)).select_by_index(1)

		# 用户名称
		def add_user_name(self, user_name):
    		self.find_element(*self.user_name_loc).clear()
    		self.find_element(*self.user_name_loc).send_keys(user_name)

		#用户密码
		def add_user_password(self, password):
    		self.find_element(*self.password).clear()
    		self.find_element(*self.password).send_keys(password)

		# 用户密码
		def add_user_ppassword(self, password):
    		self.find_element(*self.ppassword).clear()
    		self.find_element(*self.ppassword).send_keys(password)

    		# 用户角色选择操作
		def add_user_selected(self):
    		self.find_element(*self.user_role_loc).click()
    		self.find_element(*self.user_select_loc).click()

	# 用户添加页面保存按钮
		def add_user_button(self):
    		self.find_element(*self.user_button_loc).click()

		# 统一用户添加入口
		def add_user(self, username='sz001', password='123456', ppassword='123456'):
    		# 获取用户添加页面
    		self.open()
    		# self.script(self.base_url + self.url)
    		# 获取添加页面的职员编码
    		# employee_code = self.find_element(*self.employee_code_loc).get_attribute("value")
    		# return employee_code
    		self.add_user_code()
    		self.add_user_name(username)
    		self.add_user_password(password)
    		sleep(3)
    		self.add_user_ppassword(ppassword)
    		self.add_user_selected()
    		self.add_user_button()
    		sleep(3)

userQueryPage.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
"""
思路：在职员query页面中，获取代理商的名称
"""
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from base import Page
from time import sleep

class userquery(Page):

		'''
		用户query页面
		'''
		user_query_url = '/user/query'
		# 用户名称的定位
		customer_loc = (By.XPATH, 'html/body/div[1]/table/tbody/tr[1]/td[1]')

	# 获取用户名称
		def get_customer(self):
    		# self.open()
    		customer = self.find_element(*self.customer_loc).text
    		return customer

四、编写测试用例

现在开始编写测试用程序，因为前面已经做好了基础工作，此时测试用例的编写将会简单的许多，更能集中精力考虑用例的设计和事项。

创建BBS登录类：

...\mztestpro\bbs\test_case\login_sta.py

此处需要注意文件名的创建。例如，假设登录页的对象命名为loginPage.py，那么关于测试登录的用例文件应该命名为login_sta.py，这样方便后期用例报错时问题跟踪。尽量把一个页面上的元素定位封装到一个“Page.py”文件中，把针对这个页面的测试用例集中到一个“_sta.py”文件中

login_sta.py

登录测试用例信息test_case\login_sta.py，代码如下

# -*-coding:utf-8-*-
# _author_ = "janehost"
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.loginPage import login
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class loginTest(myunit.MyTest):

	'''
	测试用户登录
	'''

	def user_login_verify(self, username="", password=""):
		login(self.driver).user_login(username, password)

	def test_login1(self):
	'''用户名、密码为空登录'''
		self.user_login_verify()
		po = login(self.driver)
		self.assertEqual(po.login_error_hint(), '用户名或密码不能为空')
		function.insert_img(self.driver, "user_pawd_empty.jpg")

	def test_login2(self):
	'''用户名正确，密码为空登录验证'''
		self.user_login_verify(username="ces")
		po = login(self.driver)
		self.assertEqual(po.login_error_hint(), "用户名或密码不能为空")
		function.insert_img(self.driver,"pawd_empty.jpg")

	def test_login3(self):
	'''用户名为空，密码正确'''
		self.user_login_verify(password="12334ddf")
		po = login(self.driver)
		self.assertEqual(po.login_error_hint(),"用户名或密码不能为空")
		function.insert_img(self.driver, "user_empty.jpg")

	def test_login4(self):
	'''用户名和密码不匹配'''
		character = random.choice('abcdefghijklmnopqrstuvwxyz')
		username = "sdw" + character
		self.user_login_verify(username=username, password="2sdfd")
		po = login(self.driver)
		self.assertEqual(po.login_error_hint(), "用户名或密码错误")
		function.insert_img(self.driver, "user_pass_error.jpg")

	def test_login5(self):
	'''用户名、密码正确'''
		self.user_login_verify(username="adtest" , password="4dscsdx")
		sleep(3)
		po = login(self.driver)
		self.assertEqual(po.login_user_success(), u'adtest')
		function.insert_img(self.driver, "user_pwd_true.jpg")

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

    这样登录的测试用例就完成了。使用po模式之后，如果页面ui发生变化，我们只需要修改元素的定位方法，而不需要改动整个框架，相对而言比较快捷。

    根据登录测试用例，整理下自动化的测试思路：在整个商城页面中，尽量分页面进行操作。如登录页面，封装在一个page中，添加代理商封装在另外的一个页面中；页面和页面之间是独立的，互不影响。这里主页面的url是http://192.168.16.6/hotelManage而其他页面的url都是主页面+其他url拼接而成的。

以上登录的测试用例已经完成，接下来是酒店的测试用例编写

hotel_sta.py

    添加酒店的测试用例，这里主要添加了成功的测试用例；异常的用例中断言后期完善。

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.hotelPage import hotel
from page_obj.loginPage import login
from page_obj.hotelQueryPage import hotelquery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class hotelTest(myunit.MyTest):

'''
测试酒店添加
'''
def test_hotel(self):
	'''测试酒店添加'''
	username = "testeres01"
	password = "123456"
	po = login(self.driver)
	# po.user_login(username=username, password=password)
	po.user_login()
	function.insert_img(self.driver, "login_success.jpg")
	# 酒店添加
	num = ''.join(random.sample(string.digits, 8))
	# print num
	hotel_name = "name" + num
	contacts = "contacts" + num
	phone = "15256255412"
	email = "85135535656@mail.com"
	address = "address" + num
	min_hour = "1"
	# 酒店添加操作
	ho = hotel(self.driver)
	ho.add_hotel(hotel_name, contacts, phone, email, address, min_hour)
	# 酒店query操作
	hqo = hotelquery(self.driver)
	self.assertEqual(hqo.get_hotel_name(), hotel_name)
	function.insert_img(self.driver, "hotel_success.jpg")

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

agent_sta.py

代理商添加测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.agentPage import agent
from page_obj.loginPage import login
from page_obj.agentQueryPage import agentquery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class agentTest(myunit.MyTest):

		'''
		测试代理商添加
		'''
		def test_agent(self):
    		'''测试代理商添加'''
    		# username = "123456"
    		# password = "test123"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success1.jpg")
    		# 代理商添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		agent_name = "agent" + num
    		phone = "15356255412"
    		email = "86135535656@mail.com"
    		address = "address" + num
    		payment = "30"
    		discount = "60"
    		# 代理商添加操作
    		ao = agent(self.driver)
    		# agent_code = ao.get_agent_code()
    		ao.add_agent(agent_name, phone, email, address, payment, discount)

    		# agent_code = ao.add_agent(agent_name, phone, email, address, payment, discount)

    		# 代理商query操作,此处验证的是代理商的名称
    		aqo = agentquery(self.driver)
    		self.assertEqual(aqo.get_factor_name(), agent_name)
    		function.insert_img(self.driver, "agent_success.jpg")

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

agentpirce_sta.py

代理商单价测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.agentpricePage import agentprice
from page_obj.loginPage import login
from page_obj.agentpriceQueryPage import agentpricequery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class agentpriceTest(myunit.MyTest):

		'''
		测试代理商单价添加
		'''
		def test_hotelprice(self):
    		'''测试代理商单价添加'''
		username = "tester01"
    		password = "123456"
    		po = login(self.driver)
    		po.user_login(username=username, password=password)
    		#po.user_login()
    		function.insert_img(self.driver, "login_sys2_success.jpg")
    		# 代理商单价添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		min = "1"
    		max = "1000"
    		price = "1000"
    		# 代理商单价添加操作
    		apo = agentprice(self.driver)
    		apo.add_agentprice(min, max, price)
    		# 酒店单价query操作
    		apqo = agentpricequery(self.driver)
    		# self.assertEqual(apqo.get_hotelprice_hotel_name(), hotel_name)
    		function.insert_img(self.driver, "agentprice_success.jpg")

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

employee_sta.py

职员测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.employeePage import employee
from page_obj.loginPage import login
from page_obj.employeeQueryPage import employeequery
from mztestpro.package import card
sys.path.append("./models")
sys.path.append("./page_obj")

reload(sys)
sys.setdefaultencoding('utf8')
class employeeTest(myunit.MyTest):

		'''
		测试职员添加
		'''
		def test_employee(self):
    		'''测试职员添加'''
    		# username = "testeres01"
    		# password = "123456"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success4.jpg")
    		# 职员添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		employee_name = "employee" + num
    		# 随机身份证的验证
    		employee_id = card.getRandomIdNumber(0)[0]
    		phone = card.createPhone()
    		employee_time = "2018-01-11"
    		email = "86135535656@mail.com"
    		# 代理商添加操作
    		epo = employee(self.driver)
    		# agent_code = ao.get_agent_code()
    		epo.add_employee(employee_name, employee_name, employee_id, phone, employee_time, email)

    		# agent_code = ao.add_agent(agent_name, phone, email, address, payment, discount)

    		# 代理商query操作,此处验证的是代理商的名称
    		eqo = employeequery(self.driver)
    		self.assertEqual(eqo.get_staff_name(), employee_name)
    		function.insert_img(self.driver, "employee_success.jpg")

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

hotelprice_sta.py

酒店单价测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.hotelPricePage import hotelprice
from page_obj.loginPage import login
from page_obj.hotelPriceQueryPage import hotelpricequery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class hotelpriceTest(myunit.MyTest):

		'''
		测试酒店单价添加
		'''
		def test_hotelprice(self):
    		'''测试酒店单价添加'''
    		username = "tester01"
   	 		password = "123456"
    		po = login(self.driver)
    		po.user_login(username=username, password=password)
    		#po.user_login()
    		function.insert_img(self.driver, "login_sys_success.jpg")
    		# 酒店单价添加
    		num = ''.join(random.sample(string.digits, 8))
   	 		# print num
    		min = "1"
    		max = "1000"
    		price = "1000"
    		# 酒店单价添加操作
    		hpco = hotelprice(self.driver)
    		hpco.add_hotelprice(min, max, price)
    		# 酒店单价query操作
    		hpqo = hotelpricequery(self.driver)
    		# self.assertEqual(hpqo.get_hotelprice_hotel_name(), hotel_name)
    		function.insert_img(self.driver, "hotelprice_success.jpg")

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

productcategory_sta.py

产品类型测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.productcategoryPge import productcategory
from page_obj.loginPage import login
from page_obj.productcategoryQueryPage import productcategoryquery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class productcategoryTest(myunit.MyTest):

		'''
		测试产品类型添加
		'''
		def test_productcategory(self):
    		'''测试产品类型添加'''
    		username = "testeres01"
    		password = "123456"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success2.jpg")
    		# 酒店添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		productcategory_name = "productcategory" + num
    		productcategory_des = "productcategorydes" + num
    		# 产品类型添加操作
    		pco = productcategory(self.driver)
    		pco.add_productcategory(productcategory_name, productcategory_des)
    		# 产品类型query操作
    		pcq = productcategoryquery(self.driver)
    		self.assertEqual(pcq.get_category_name(), productcategory_name)
    		function.insert_img(self.driver, "category_success.jpg")

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

productinfo_sta.py

产品信息测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.productinfoPage import productinfo
from page_obj.loginPage import login
from page_obj.productinfoQueryPage import productinfoquery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class productinfoTest(myunit.MyTest):

		'''
		测试产品信息添加
		'''
		def test_productinfo(self):
    		'''测试产品信息添加'''
    		username = "testeres01"
    		password = "123456"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success3.jpg")
   	 		# 酒店添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		product_name = "product" + num
    		rent = "15"
    		sale = "55"
    		product_des = "productdes" + num
    		# 产品信息添加操作
    		pio = productinfo(self.driver)
    		pio.add_product(product_name, rent, sale, product_des)
    		# 产品类型query操作
    		piq = productinfoquery(self.driver)
    		self.assertEqual(piq.get_productinfo_name(), product_name)
    		function.insert_img(self.driver, "productinfo_success.jpg")

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

role_sta.py

角色测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.rolePage import role
from page_obj.loginPage import login
from page_obj.roleQueryPage import rolequery
from mztestpro.package import card
sys.path.append("./models")
sys.path.append("./page_obj")

reload(sys)
sys.setdefaultencoding('utf8')
class roleTest(myunit.MyTest):

		'''
		测试角色添加
		'''
		def test_role(self):
    		'''测试角色添加'''
    		# username = "testeres01"
    		# password = "123456"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success5.jpg")
    		# 角色添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		role_name = "role" + num
    		role_desc = "roledesc" + num
    		# 角色添加操作
    		ro = role(self.driver)
    		# agent_code = ao.get_agent_code()
    		ro.add_role(role_name, role_desc)

    		# agent_code = ao.add_agent(agent_name, phone, email, address, payment, discount)

    		# 角色query操作,此处验证的是角色的名称
    		rqo = rolequery(self.driver)
    		self.assertEqual(rqo.get_part_name(), role_name)
    		function.insert_img(self.driver, "role_success.jpg")

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

user_sta.py

用户测试用例信息

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.userPage import user
from page_obj.loginPage import login
from page_obj.userQueryPage import userquery
from mztestpro.package import card
sys.path.append("./models")
sys.path.append("./page_obj")

reload(sys)
sys.setdefaultencoding('utf8')
class userTest(myunit.MyTest):

		'''
		测试用户添加
		'''
		def test_employee(self):
    		'''测试用户添加'''
    		# username = "testeres01"
    		# password = "123456"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success6.jpg")
    		# 用户添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		user_name = "user" + num
    		pwd = "123456"

    		# 用户添加操作
    		uo = user(self.driver)
    		# agent_code = ao.get_agent_code()
    		uo.add_user(user_name, pwd, pwd)

    		# agent_code = ao.add_agent(agent_name, phone, email, address, payment, discount)

    		# 用户query操作,此处验证的是代理商的名称
    		uqo = userquery(self.driver)
    		self.assertEqual(uqo.get_customer(), user_name)
    		function.insert_img(self.driver, "user_success.jpg")

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

warehouse_sta.ppy

仓库添加测试用例

# -*-coding:utf-8-*-
# _author_ = "jane_host"
import string
from time import sleep
import unittest, random, sys
from models import myunit, function
from page_obj.warehousePage import warehouse
from page_obj.loginPage import login
from page_obj.warehouseQueryPage import warehousequery
sys.path.append("./models")
sys.path.append("./page_obj")
reload(sys)
sys.setdefaultencoding('utf8')
class warehouseTest(myunit.MyTest):

		'''
		测试仓库添加
		'''
		def test_agent(self):
    		'''测试仓库添加'''
    		# username = "testeres01"
    		# password = "123456"
    		po = login(self.driver)
    		# po.user_login(username=username, password=password)
    		po.user_login()
    		function.insert_img(self.driver, "login_success1.jpg")
    		# 仓库添加
    		num = ''.join(random.sample(string.digits, 8))
    		# print num
    		warehouse_name = "warehouse" + num
    		province = "province" + num
    		city = "city" + num
    		region = "region" + num
    		street = "street" + num
    		address = "address" + num
    		contacts = "contacts" + num
   			phone = "15556255412"
    		des = "waredes" + num
    		# 仓库添加操作
    		wo = warehouse(self.driver)
    		# agent_code = ao.get_agent_code()
    		wo.add_warehouse(warehouse_name, province, city, region, street,
                     address, contacts, phone, des)

    		# agent_code = ao.add_agent(agent_name, phone, email, address, payment, discount)

    		# 仓库query操作,此处验证的是仓库的名称
    		wqo = warehousequery(self.driver)
    		self.assertEqual(wqo.get_depot_name(), warehouse_name)
    		function.insert_img(self.driver, "warehouse_success.jpg")

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

五、执行测试用例

为了在测试用例运行过程中不影响做其他事，笔者选择调用远程主机或虚拟机来运行测试用例，那么这里就需要使用Selenium Grid（其包含Selenium Server）来调用远程节点。

创建用例执行程序：...\mztestpro\run_bbs_test.py

run_bbs_test.py

# -*-coding:utf-8-*-
# _author_ = "janehost"
import os
import smtplib
import sys
import time
import unittest
from email.mime.text import MIMEText

from mztestpro.package.HTMLTestRunner import HTMLTestRunner

reload(sys)
sys.setdefaultencoding('utf8')
# =========================邮件接收者============================
mailto_list = ["*****@qq.com"]
#============= 设置服务器，用户名、口令以及邮箱的后缀===============
mail_host = "smtp.126.com"
mail_user = "*******@126.com"
mail_pass = "************"
#===========================发送邮件============================
def send_mail(to_list, file_new):
		"""
		to_list: 发给谁
		sub: 主题
		content:内容
		send_mail("*******@126.com","商城测试报告"，"主要功能回归测试")
		"""
		f = open(file_new, 'rb')
		mail_body = f.read()
		f.close()
		me = mail_user
		msg = MIMEText(mail_body, 'html', 'utf-8')
		msg['Subject'] = u'自动化测试报告'
		msg['From'] = me
		msg['To'] = ";".join(to_list)
		try:
    		s = smtplib.SMTP()
    		s.connect(mail_host, 25)
    		s.login(mail_user, mail_pass)
    		s.sendmail(me, to_list, msg.as_string())
    		s.close()
    		return True
		except Exception, e:
    		print str(e)
    		return False
# ==============查找测试报告目录，找到最新生成的测试报告文件==========
def new_report(testreport):
		lists = os.listdir(testreport)
		lists.sort(key=lambda fn:os.path.getatime(testreport + "\\" + fn))
		file_new = os.path.join(testreport, lists[-1])
		print (file_new)
		return file_new

if __name__ == '__main__':
		now = time.strftime("Y-%m-%d %H_%M_%S")
		filename = './bbs/report/' + now + 'result.html'
		fp = open(filename, 'wb')
		runner = HTMLTestRunner(stream=fp, title=u'商城自动化测试报告',
                        description=u'环境：windows 10 浏览器：firefox')
		discover = unittest.defaultTestLoader.discover('./bbs/test_case',
                                               pattern='*_sta.py')
		runner.run(discover)
		fp.close()
		file_path = new_report('./bbs/report/')
		if send_mail(mailto_list, file_path):
    		print u"发送成功"
		else:
    		print u"发送失败"

执行过程中并没有任何改动，集成HTMLTestRunner生成的HTML测试报告，以及集成自动发邮件功能等。唯一需要注意的是，脚本中的路径建议使用相对路径，以便于项目被移动到任意目录下执行。

打开...\mztestpro\driver.py 文件，修改脚本运行的节点及浏览器。现在可以通过运行run_bbs_test.py来执行测试项目了。

小结：

如果你完成了前面的操作，那么这只是自动化项目的开始，不过，我们已经把基本架构设计完成，后面大部分工作就是编写各个页面的Page.py以及测试用_sta.py。在这个过程中会遇到各种各样的问题，如元素定位、架构的扩展，需要读者自己去克服这些问题。上面只是实现了正常测试用例的编写，适用于回归测试；至于异常测试用例根据需要后期完善。

​

六、HTMLTestRunne和其他公共类

HTMLTestRunner类和身份证自动生成，位置mztestpro\package\HTMLTestRunner.py、addr.py和card.py

参考随机身份证和手机号

链接： https://share.weiyun.com/85d3c89fbe3d614a1d6352c7b261ba10 （密码：oN7M）

参考：

小小的博客 [http://www.cnblogs.com/xiaozhiblog/p/5378723.html]

selenium2 python自动化测试实战(虫师)