自动化脚本参数化

     //封装类firefoxutil

#-*- coding:utf-8 -*-
#导包
from enum import Enum
from selenium import webdriver
#导入休眠包
import time
#导入休眠的包
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By

#声明类，继承object
class Firefoxutil(object):
      #打开浏览器
      def firefoxutil_start(self,url):
          #驱动
          self.driver=webdriver.Chrome(executable_path="D:\google\Chrome\Application\chromedriver.exe")
          #设置窗口最大化
          self.driver.maximize_window()
          self.driver.get(url)
          #设置休眠时间
          self.Titmesleep(ENUMS.TWO_TIME)

      #关闭浏览器
      def firefoxutil_close(self):
          self.driver.quit()
          pass

      #关闭当前网页
      def firefox_current(self):
          self.driver.close()
          pass


      #强制休眠
      def Titmesleep(self,number):
          time.sleep(number)
          pass

      #隐式休眠
      def TimeImplay(self,number):
          self.driver.implicitly_wait(number)
          pass

      #ID开始查找控件
      def FindID(self,ID):
          ids=(By.ID,ID)
          WebDriverWait(self.driver,ENUMS.TWENTY_TIME,ENUMS.ONE_HALF).until(EC.presence_of_element_located(ids))
          return self.driver.find_element_by_id(ID)

      #点击事件
      def ClickID(self,ID):
          self.FindID(ID).click()

      #输入
      def SendKeysID(self,ID,message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindID(ID).clear()
          self.FindID(ID).send_keys(message)

      #通过id获取控件内容
      def getIdText(self,ID):
          return self.FindID(ID).text

      #通过id判断控件是不是可见
      def isDispalyID(self,ID):
           return self.FindID(ID).is_displayed()

      #通过id判断控件有没有被选中
      def isSelectID(self,ID):
          return self.FindID(ID).is_selected()

      #通过id判断input标签，是不是可编辑，返回true表示可编辑，返回布尔，不可编辑
      def isEnableID(self,ID):
          return self.FindID(ID).is_enabled()

      #NAME查询控件
      def FindName(self,name):
          names=(By.NAME,name)
          WebDriverWait(self.driver,ENUMS.TWENTY_TIME,ENUMS.ONE_HALF).until(EC.presence_of_element_located(names))
          return self.driver.find_element_by_name(name)

      #点击事件
      def ClickName(self,name):
          self.FindName(name).click()

      #输入内容
      def SendKeysName(self,name,message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindName(name).clear()
          self.FindName(name).send_keys(message)

      #通过name获取控件的内容
      def getNameText(self,name):
          return self.FindName(name).text

      def isDispalyNmae(self,name):
          return self.FindName(name).is_displayed()

      def isSelectNmae(self,name):
          return self.FindName(name).is_selected()

      def isEnableNmae(self,name):
          return self.FindName(name).is_enabled()

      #class查找控件
      def FindClass(self,cls):
          clss=(By.CLASS_NAME,cls)
          WebDriverWait(self.driver,ENUMS.TWENTY_TIME,ENUMS.ONE_HALF).until(EC.presence_of_element_located(clss))

          return self.driver.find_element_by_class_name(cls)

      #点击事件
      def ClickClass(self,cls):
          self.FindClass(cls).click()

      #输入内容
      def SendKeysClass(self,cls,message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindClass(cls).clear()
          self.FindClass(cls).send_keys(message)

      #获取控件的内容
      def getClassText(self,cls):
          return self.FindClass(cls).text


      def isDispalyClass(self,cls):
          self.FindClass(cls).is_displayed()

      def isSelectClass(self, cls):
          self.FindClass(cls).is_selected()

      def isEnableClass(self, cls):
          self.FindClass(cls).is_enabled()

      # Xpath查找控件
      def FindXpath(self, xpath):
          xpaths = (By.XPATH, xpath)
          WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(xpaths))
          return self.driver.find_element_by_xpath(xpath)

      # 点击事件
      def ClickXpath(self, xpath):
          self.FindXpath(xpath).click()

      # 输入内容
      def SendKeysXpath(self,xpath, message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindXpath(xpath).clear()
          self.FindXpath(xpath).send_keys(message)

      # 获取控件的内容
      def getXpathText(self, xpath):
          self.FindXpath(xpath).text

      def isDispalyXpath(self, xpath):
          self.FindXpath(xpath).is_displayed()

      def isSelectXpath(self, xpath):
          self.FindXpath(xpath).is_selected()

      def isEnableXpath(self,xpath):
          self.FindXpath(xpath).is_enabled()

      # Tag查找控件
      def FindTag(self, tag):
          tags = (By.TAG_NAME, tag)
          WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(tags))
          return self.driver.find_element_by_tag_name(tag)

      # 点击事件
      def ClickTag(self,tag):
          self.FindTag(tag).click()

      # 输入内容
      def SendKeysTag(self, tag, message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindTag(tag).clear()
          self.FindTag(tag).send_keys(message)

      # 获取控件的内容
      def getTagText(self, tag):
          self.FindTag(tag).text

      def isDispalyTag(self, tag):
          self.FindTag(tag).is_displayed()

      def isSelectTag(self, tag):
          self.FindTag(tag).is_selected()

      def isEnableTag(self, tag):
          self.FindTag(tag).is_enabled()

      #css查找控件
      def FindCss(self, css):
          csses = (By.CSS_SELECTOR, css)
          WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(csses))
          return self.driver.find_element_by_css_selector(css)

      # 点击事件
      def ClickCss(self, css):
          self.FindCss(css).click()

      # 输入内容
      def SendKeysCss(self, css, message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindCss(css).clear()
          self.FindCss(css).send_keys(message)

      # 获取控件的内容
      def getCssText(self, css):
          self.FindCss(css).text

      def isDispalyCss(self, css):
          self.FindCss(css).is_displayed()

      def isSelectCss(self, css):
          self.FindCss(css).is_selected()

      def isEnableCss(self, css):
          self.FindCss(css).is_enabled()

      # Link查找控件
      def FindLink(self, link):
          links = (By.LINK_TEXT, link)
          WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(links))
          return self.driver.find_element_by_link_text(link)

      # 点击事件
      def ClickLink(self, link):
          self.FindLink(link).click()

      # 输入内容
      def SendKeysLink(self, link, message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindLink(link).clear()
          self.FindLink(link).send_keys(message)

      # 获取控件的内容
      def getLinkText(self, link):
          self.FindLink(link).text

      def isDispalyLink(self, link):
          self.FindLink(link).is_displayed()

      def isSelectLink(self,link):
          self.FindLink(link).is_selected()

      def isEnableLink(self, link):
          self.FindLink(link).is_enabled()

      # Link查找控件
      def FindPary(self, pary):
          parys = (By.LINK_TEXT, pary)
          WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(parys))
          return self.driver.find_element_by_partial_link_text(pary)

      # 点击事件
      def ClickPary(self, pary):
          self.FindPary(pary).click()

      # 输入内容
      def SendKeysPary(self, pary, message):
          # 查找控件.首先清空数据,同时再输入内容
          self.FindPary(pary).clear()
          self.FindPary(pary).send_keys(message)

      # 获取控件的内容
      def getParyText(self, pary):
          self.FindPary(pary).text

      def isDispalyPary(self, pary):
          self.FindPary(pary).is_displayed()

      def isSelectPary(self, pary):
          self.FindPary(pary).is_selected()

      def isEnablePary(self, pary):
          self.FindPary(pary).is_enabled()

      #切换窗口
      #获取当前窗口
      def getCurrentWindow(self):
          return self.driver.current_window_handle

      #获取所有窗口，进行切换
      def seitch_to_window(self,current_window):
          self.Titmesleep(ENUMS.TWO_TIME)
          #获取所有窗口
          all_windows=self.driver.window_handles
          for window in all_windows:
              if window!=current_window:
                  self.driver.switch_to.window(window)

      #通过id点击进行切换窗口的方法
      def ClickID_switch_to_window(self,ID):
           current_window=self.getCurrentWindow()
           self.ClickID(ID)
           #切换
           self.seitch_to_window(current_window)

      # 通过Name点击进行切换窗口的方法
      def ClickName_switch_to_window(self, name):
           current_window = self.getCurrentWindow()
           self.ClickName(name)
           # 切换
           self.seitch_to_window(current_window)

      # 通过Class点击进行切换窗口的方法
      def ClickClass_switch_to_window(self, cls):
           current_window = self.getCurrentWindow()
           self.ClickClass(cls)
           # 切换
           self.seitch_to_window(current_window)

      # 通过Xpath点击进行切换窗口的方法
      def ClickXpath_switch_to_window(self, xpath):
           current_window = self.getCurrentWindow()
           self.ClickXpath(xpath)
           # 切换
           self.seitch_to_window(current_window)

      # 通过Css点击进行切换窗口的方法
      def ClickCss_switch_to_window(self, css):
           current_window = self.getCurrentWindow()
           self.ClickCss(css)
           # 切换
           self.seitch_to_window(current_window)

      # 通过XTag点击进行切换窗口的方法
      def ClickTag_switch_to_window(self, tag):
           current_window = self.getCurrentWindow()
           self.ClickTag(tag)
           # 切换
           self.seitch_to_window(current_window)

      # 通过Link点击进行切换窗口的方法
      def ClickLink_switch_to_window(self, link):
           current_window = self.getCurrentWindow()
           self.ClickLink(link)
           # 切换
           self.seitch_to_window(current_window)

      # 通过Link点击进行切换窗口的方法
      def ClickPary_switch_to_window(self, pary):
           current_window = self.getCurrentWindow()
           self.ClickPary(pary)
           # 切换
           self.seitch_to_window(current_window)

      #切换frameID
      def switch_to_frame_id(self,ID):
          self.driver.switch_to.frame(self.ClickID(ID))

      # 切换frameName
      def switch_to_frame_Name(self, name):
          self.driver.switch_to.frame(self.ClickName(name))

      # 切换frameClass
      def switch_to_frame_Class(self, cls):
          self.driver.switch_to.frame(self.ClickClass(cls))

      # 切换frameXpath
      def switch_to_frame_Xpath(self, xpath):
          self.driver.switch_to.frame(self.ClickXpath(xpath))

      # 切换frameTag
      def switch_to_frame_Tag(self, tag):
          self.driver.switch_to.frame(self.ClickTag(tag))

      # 切换frameCss
      def switch_to_frame_Css(self, css):
          self.driver.switch_to.frame(self.ClickCss(css))

      # 切换frameLink
      def switch_to_frame_Link(self, link):
          self.driver.switch_to.frame(self.ClickLink(link))

      # 切换framePary
      def switch_to_frame_Pary(self, pary):
          self.driver.switch_to.frame(self.ClickPary(pary))

      #切出frame
      def checkout_frame(self):
          self.driver.switch_to.default_content()

      #执行js的定位到指定位置
      def exe_js_id(self,ID):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindID(ID))
          pass

      #执行js的定位到指定位置
      def exe_js_Name(self,name):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindName(name))
          pass

      #执行js定位到指定的位置
      def exe_js_Class(self,cls):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindClass(cls))
          pass

      #执行js定位到指定位置
      def exe_js_Xpath(self,xpath):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindXpath(xpath))
          pass

      #执行js到指定位置
      def exe_js_Tag(self,tag):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindTag(tag))
                                     #arguments[0].scrollIntoView();
                                     #arguments[0].scrollIntoView();
          pass

      #执行js到指定位置
      def exe_js_Css(self,css):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindCss(css))
          pass

      #执行js到指定位置
      def exe_js_Link(self,link):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindLink(link))
          pass

      #执行js到指定位置
      def exe_js_Pary(self,pary):
          self.driver.execute_script("arguments[0].scrollIntoView();",self.FindPary(pary))
          pass

      #获取title
      def getTitle(self):
          return self.driver.title

      #断言
      #断言是单元测试语法，如果我们在这里想封装断言，必须将单元测试的self传递过去
      def AssertTitle(self,self1,expect):
          self1.assertEqual(self.getTitle(),expect)
          pass

      #断言控件内容分为八种，
      #id断言
      def AssertId(self,self1,exepect,ID):
          self1.assertEqual(self.getTitle(ID),exepect)

      # 断言控件内容分为八种，
      # id断言
      def AssertName(self, self1, exepect, name):
          self1.assertEqual(self.getTitle(name), exepect)

      # 断言控件内容分为八种，
      # Class断言
      def AssertClass(self, self1, exepect, cls):
          self1.assertEqual(self.getTitle(cls), exepect)

      # 断言控件内容分为八种，
      # id断言
      def AssertXpath(self, self1, exepect, xpath):
          self1.assertEqual(self.getTitle(xpath), exepect)

      # 断言控件内容分为八种，
      # id断言
      def AssertCss(self, self1, exepect, css):
          self1.assertEqual(self.getTitle(css), exepect)

      # 断言控件内容分为八种，
      # id断言
      def AssertLink(self, self1, exepect, link):
          self1.assertEqual(self.getTitle(link), exepect)

      # 断言控件内容分为八种，
      # id断言
      def AssertPary(self, self1, exepect, pary):
          self1.assertEqual(self.getTitle(pary), exepect)

      # 断言控件内容分为八种，
      # id断言
      def AssertTag(self, self1, exepect, tag):
          self1.assertEqual(self.getTitle(tag), exepect)


      # 断言控件内容,分为八种,通过 id断言,
      def AssertId(self, self1, expect, ID):

          self1.assertEqual(self.getIdText(ID), expect)

      def AssertClass(self, self1, expect, cls):

          self1.assertEqual(self.getClassText(cls), expect)


      def AssertName(self,self1,expect,name):
          self1.assertEqual(self.getNameText(name),expect)

      def AssertXpath(self,self1,expect,xpath):
          self1.assertEqual(self.getXpathText(xpath),expect)

      def AssertCss(self,self1,expect,css):
          self1.assertEqual(self.getCssText(css),expect)

      def AssertTag(self,self1,expect,tag):
          self1.assertEqual(self.getTagText(tag),expect)

      def AssertLink(self,self1,expect,link):
          self1.assertEqual(self.getLinkText(link),expect)

      def AssertPary(self,self1,expect,pary):
          self1.assertEqual(self.getParyText(pary),expect)

#定义枚举类
class ENUMS(Enum):
    # 两秒
    TWO_TIME = 2
    # 五秒
    FIVE_TIME = 5
    # 10 秒
    TEN_TIME = 10
    # 20 秒
    TWENTY_TIME = 20
    # 0.5 秒
    ONE_HALF = 0.5

    //打开指定网页urlUtil

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

class URL(object):
     def __init__(self):

        pass

     JD_LOGIN="https://passport.com/new/login.aspx?ReturnUrl=https%3A%2F%2Fwww.jd.com%2F%3Fcu%3Dtrue%26utm_source%3Dbaidu-pinzhuan%26utm_medium%3Dcpc%26utm_campaign%3Dt_288551095_baidupinzhuan%26utm_term%3D0f3d30c8dba7459bb52f2eb5eba8ac7d_0_082628e0c03044529c8e6a76f3dde1ff"

    //C 代码逻辑层

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

from  util import firefoxutil
#定义一个类继承object
class LoginControl(object):
    #类被实例化时候执行方法
    #对应的java里面的构造方法
    def __init__(self,firefox):
        #self.firefox=firefoxutil.Firefoxutil()

        self.firefox=firefox
        pass

    #封装输入用户名的方法
    def LoginSendkeyUwPw(self,username,password):
        #查找用户名和密码
        self.firefox.ClickClass("login-tab-r")
        self.firefox.SendKeysID("loginname",username)
        self.firefox.SendKeysID("nloginpwd", password)
        self.firefox.ClickID("loginsubmit")
        pass

     //M测试用例层

#-*- coding:utf-8 -*-
#导入csv文件
import csv
#导入os包
import os
#声明类继承object
class LoginData(object):

    #读取登陆测试用例的文件方法
    #面试题，写测试用例或者看测试用例的时候，如何知道这条测试用例能不能写自动化
    #可以在测试用例里面加一个类型，通过类型判断能不能写自动化脚本
    def getData(self):
        #指定读写路径
        #获取当前路径，如果在suit运行，当前路径就是suit路径，也就是说在哪个类运行，就是那个类的路径
        current_file=os.getcwd()
        #指定现在的文件路径
        files=os.path.dirname(current_file)+"/login/loginm/qwe.csv"
        #打开文件
        #面试题，oppo与file的区别，
        #oppo是新增的语法，file是老语法
        filename=open(files,'rb')
        #通过csv读取出来
        data=csv.reader(filename)
        return data

    #登陆页面点击所有连接的方法
    def get_click_about_me(self):

        #指定读写路径
        current_file=os.getcwd()
        files=os.path.dirname(current_file)+"/login/loginm/jdlogin_foot.csv"
        filename=open(files,'rb')
        #通过csv读取出来
        data=csv.reader(filename)
        return data

    测试用例.csv结尾的

0,关于我们,企业简介-京东商城
0,联系我们,联系我们-京东商城
0,人才招聘,京东招聘官网
0,商家入驻,商家入驻-入驻流程 - 京东全品类专题活动-京东
0,广告服务,广告服务 - 京东全品类专题活动-京东
0,手机京东,手机京东 - 京东
0,友情链接,友情链接
0,销售联盟,京东联盟
0,京东社区,京东社区 - 京东电脑、办公|游戏设备专题活动-京东
0,京东公益,京东公益
1,English Site,JD.com Global Online Shopping Site: Online Shopping for Electronics,Clothing,Toys and More

     //运行所需的代码

  

#-*- coding:utf-8 -*-
#导入单元测试
import unittest
from util import firefoxutil,urlutil
#导入控制类
from login.loginc import logincontrol
from login.loginm import login_data
class JdLogin(unittest.TestCase):

       #实例化工具类
       @classmethod
       def setUpClass(self):
           self.firefox=firefoxutil.Firefoxutil()
           self.URL=urlutil.URL()
           #实例化控制对象
           self.login=logincontrol.LoginControl(self.firefox)
           self.loginm=login_data.LoginData()
       #打开浏览器
       def setUp(self):
           self.firefox.firefoxutil_start(self.URL.JD_LOGIN)

       #关闭浏览器
       def tearDown(self):
                  self.firefox.firefoxutil_close()

       #测试用例，
       def test_us_pw(self):
           #MVC模式
           #m层对应的是测试用例层
           #v层对应的是单元测试
           #c层对应的是逻辑代码层
           #使用for循环，获取内容，同时断言
           for index in self.loginm.getData():
               self.login.LoginSendkeyUwPw(index[0].decode("UTF-8"),index[1].decode("UTF-8"))

               self.firefox.Titmesleep(firefoxutil.ENUMS.TWO_TIME)
               #休眠，因为for循环，所以我们每次登陆的时候都需要休眠
               if int(index[3].decode("UTF-8"))==0:
                   self.firefox.AssertClass(self,index[2].decode("UTF-8"),"msg-error")
                   self.firefox.Titmesleep(firefoxutil.ENUMS.TWO_TIME)


               else:
                   self.firefox.AssertTitle(self,index[2].decode("UTF-8"))
           pass

       def test_click_about_me(self):

           for index in self.loginm.get_click_about_me():
               #获取当前窗口
               self.firefox.Titmesleep(6)
               current=self.firefox.getCurrentWindow()
               print index[1].decode("UTF-8")
               #点击关于我们
               self.firefox.ClickLink_switch_to_window(index[1].decode("UTF-8"))
               #判断0，就断言下标为2
               if int(index[0].decode("UTF-8"))==0:
                   self.firefox.AssertTitle(self,index[2].decode("UTF-8"))
               else:
                   self.firefox.AssertTitle(self,index[2].decode("UTF-8")+", "+index[3].decode("UTF-8")+", "+index[4].decode("UTF-8"))
               #关闭当前网页
               self.firefox.firefox_current()
               #切换导登陆页面
               self.firefox.driver.switch_to_window(current)
           pass

     //suit类

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

# 导入单元测试包
import unittest
# 倒包
from unit import jdlogin
# 导入自动化测试报告
import HTMLTestRunner
# 导入os包
import os
# 设置系统编码格式
import sys
reload(sys)
sys.setdefaultencoding("UTF-8")

# 实例化 suit

suit = unittest.TestSuite()


# 将单元测试加入到测试套件里面
suit.addTest(unittest.makeSuite(jdlogin.JdLogin))


# 指定自动化测试报告路径
files = os.getcwd() + "/jd.html"
# 指定读写方式 wb 以二进制的方式进行写入  rb 以二进制的方式进行读取 rb+ 以二进制的方式进行读写
filename = open(files,'wb')

# 运行自动化测试报告
runner = HTMLTestRunner.HTMLTestRunner(stream=filename,title=u"登陆测试",description=u"这是登陆测试用例")

runner.run(suit)