测试自动化脚本购物生的全选按钮

最新推荐文章于 2023-03-24 15:03:32 发布

为你为我

最新推荐文章于 2023-03-24 15:03:32 发布

阅读量493

点赞数

//八种查找控件以及from切换的封装

#-*- 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

#定义类继承单元测试
class FireFox(object):
    #打开浏览器
    def firefox_start(self,url):
        #打开浏览器
        self.driver=webdriver.Chrome(executable_path="D:\google\Chrome\Application\chromedriver.exe")
        #设置窗口最大化
        self.driver.maximize_window()
        #打开指定网页
        self.driver.get(url)
        #设置休眠
        self.TimeSleep(ENUMS.FIVE_TIME)
        pass

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

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

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

    #1查询空的的八种方法  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)

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

    #ID  输入内容
    def SendkeysID(self,ID,message):
        self.FindID(ID).send_keys(message)


    #2查询控件的八种方法 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)


        # 查找控件方式 8 种

    def FindNames(self, name):
        # 使用显示休眠,一共休眠20秒,每隔0.5秒休眠一次,

        names = (By.NAME, name)

        # 休眠
        WebDriverWait(self.driver, ENUMS.TWENTY_TIME, ENUMS.ONE_HALF).until(EC.presence_of_element_located(names))

        return self.driver.find_elements_by_name(name)

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

    #NAME输入内容
    def SendkeysName(self,name,message):
        self.FindName(name).send_keys(message)

    #3查询控件的八种方法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)

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

    #输入内容 Class
    def SendkeysClass(self,cls,message):
        self.FindClass(cls).send_keys(message)

    #4查询控件的八种方法 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 FindXpaths(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_elements_by_xpath(xpath)

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

    def SendKeysXpath(self,xpath,message):
        self.FindXpath(xpath).send_keys(message)

    #5查找控件的八种方法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)

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

    #输入内容 Css
    def SendKeysCss(self,css,message):
        self.FindCss(css).send_keys(message)

    #6查询控件的八种方法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)

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

    #输入内容Tag
    def FindTag(self,tag,message):
        self.FindTag(tag).send_keys(message)

    #7查找控件的八种方法Part
    def FindPart(self,part):
        parts=(By.PARTIAL_LINK_TEXT,part)
        WebDriverWait(self.driver,ENUMS.TWENTY_TIME,ENUMS.ONE_HALF).until(EC.presence_of_element_located(parts))
        return self.driver.find_element_by_partial_link_text(part)

    #点击事件 Part
    def ClickPart(self,part):
        self.FindPart(part).click()

     #输入内容Part
    def SendKeysPart(self,part,message):
        self.FindPart(part).send_keys(message)

    #8查询控件的八种方法 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)

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

    #输入内容 Link
    def SendKeysLink(self,link,message):
        self.FindLink(link).send_keys(message)

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

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

    #切换窗口的方法
    def switch_to_widow(self,current):
        #获取所有窗口
        allwindows=self.driver.window_handles
        #使用for循环进行切换
        for window in allwindows:
            if window!=current:
                self.driver.switch_to.window(window)

    #1ID设置点击事件，以及切换窗口的封装
    def ClickID_Window(self,ID):
       #获取当前窗口
       current_window= self.getCurrent_Window()
       #进行点击
       self.ClickID(ID)
       #设置休眠时间
       self.TimeSleep(ENUMS.FIVE_TIME)
       #切换窗口
       self.switch_to_widow(current_window)

    #2NAME设置点击事件，以及切换窗口的封装
    def ClickName_Window(self,name):
        #获取当前窗口
        current_window=self.getCurrent_Window()
        #设置点击事件
        self.ClickName(name)
        #设置休眠时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        #切换窗口
        self.switch_to_widow(current_window)

    #3设置点击事件
    def ClickClass_Window(self,cls):
        #获取当前窗口
        current_window=self.getCurrent_Window()
        #设置点击事件
        self.ClickClass(cls)
        #休眠
        self.TimeSleep(ENUMS.FIVE_TIME)
        #切换窗口
        self.switch_to_widow(current_window)

    #4Xpath设置点击事件，以及切换窗口的封装
    def ClickXpath_Window(self,xpath):
        #获取所有窗口
        current_window=self.getCurrent_Window()
        #设置点击事件
        self.ClickXpath(xpath)
        self.TimeSleep(ENUMS.FIVE_TIME)
        #休眠
        #切换窗口
        self.switch_to_widow(current_window)

    #5Tag设置点击事件 对切换窗口进行封装
    def ClickTag_Window(self,tag):
        #获取所有窗口
        current_window=self.getCurrent_Window()
        #点击事件
        self.ClickTag(tag)
        #休眠
        self.TimeSleep(ENUMS.FIVE_TIME)
        #切换窗口
        self.switch_to_widow(current_window)

    #6Css设置点击事件，对切换窗口的封装
    def ClickCss_Window(self,css):
        #获取所有窗口
        current_window=self.getCurrent_Window()
        #设置点击事件
        self.ClickCss(css)
        #休眠
        self.TimeSleep(ENUMS.FIVE_TIME)
        #切换窗口
        self.switch_to_widow(current_window)

    #7Link点击事件以及切换窗口的封装
    def ClickLink_Window(self,link):
        #获取所有窗口
        current_window=self.getCurrent_Window()
        #设置点击事件
        self.ClickLink(link)
        #休眠
        self.TimeSleep(ENUMS.FIVE_TIME)
        #切换窗口
        self.switch_to_widow(current_window)

    #8Part 点击事件以及切换窗口的封装
    def ClickPart_Window(self,part):
        #获取所有窗口
        current_window=self.getCurrent_Window()
        #设置点击事件
        self.ClickPart(part)
        #设置休眠
        self.TimeSleep(ENUMS.FIVE_TIME)
        self.switch_to_widow(current_window)

    ## 1ID通过js定位当前窗口
    def switch_to_view_js_ID(self,ID):
        # # 执行 js arguments[0].scrollIntoView();
        self.driver.execute_script("arguments[0].scrollIntoView():",self.FindID(ID))

    #2name通过js定位当前窗口
    def switch_to_view_js_Name(self,name):
        #执行js arguments[0].scrollIntoView();
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindName(name))

    #3class 通过js定位
    def switch_to_view_js_Class(self,cls):
        #执行js，arguments[].scrollIntoView()
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindClass(cls))

    #4Xpath 通过js定位当前窗口
    def switch_to_view_js_Xpath(self,xpath):
        #执行js，arguments[0].scrollIntoView()
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindXpath(xpath))

    #5Tag通过js定位当前窗口
    def switch_to_view_js_Tag(self,tag):
        #执行js arguments[0].scrollIntoView()
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindXpath(tag))

    #6Css通过JS定位当前窗口
    def switch_to_view_js_Css(self,css):
        #执行js，aruments[0].scrollIntoView()
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindCss(css))

    #7Link通过js定位当前窗口
    def switch_to_view_js_Link(self,link):
        #智能型js aruments[0].scrollIntoView()
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindLink(link))

    #8Part 通过js定位当前窗口
    def switch_to_view_js_Part(self,part):
        #执行js aruments[0].scrollIntoView()
        self.driver.execute_script("arguments[0].scrollIntoView();",self.FindPart(part))

    # 切换到frame Name
    def seitch_to_name_frame(self, name):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindName(name))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到frame Name

    def seitch_to_ID_frame(self,ID):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindID(ID))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass







    #未做
        # 切换到frame ID

    def seitch_to_id_frame(self, ID):

        # 切换到frame里面
        self.driver.switch_to.frame(self.FindID(ID))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到frame Name

    def seitch_to_name_frame(self, name):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindName(name))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到frame Class

    def seitch_to_class_frame(self, cls):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindClass(cls))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到frame xpath

    def seitch_to_xpath_frame(self, xpath):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindXpath(xpath))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到frame tag

    def seitch_to_tag_frame(self, tag):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindTag(tag))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到frame tag

    def seitch_to_css_frame(self, css):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindCss(css))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

        # 切换到原声的方法

    def switch_to_content(self):

        # 切换到本地
        self.driver.switch_to.default_content()

        # 封装断言, 查找控件,获取内容,断言前后是不是一致

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

        # 查找控件,获取内容
        self.message = self.FindClass(cls).text
        # 进行断言
        self1.assertEqual(self.message, expect)

        pass

        # 通过 title去断言

    def AssertEquilTitle(self, self1, expect):

        # 设置休眠,在这里使用强制等待
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 查找控件,获取内容
        self.message = self.getTitle()
        # 进行断言
        self1.assertEqual(self.message, expect)

        pass

        # 断言数量

    def AssertEquilCount(self, self1, cls, number):

        # 查询一组控件,进行断言
        clses = self.FindClasses(cls)

        # 进行断言
        self1.assertEqual(len(clses), number)

        pass

        # 断言控件是不是可见

    def AssertTrueID(self, self1, ID):

        # 设置休眠 给网络请求或者逻辑判断的加载时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 进行断言
        self1.assertTrue(self.FindID(ID).is_displayed())

        # 通过 class 查询一组列表的元素

    def FindClasses(self, cls):

        # 查询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_elements_by_class_name(cls)

        # 通过指定下标进行点击的

    def ClickClasses(self, cls, index):

        # 进行点击
        self.FindClasses(cls)[index].click()

        # 休眠方式有三种
        # 1: 强制休眠  强制休眠,当代码执行到该句代码的时候,进行休眠,当休眠结束执行接写来的代码
        # 2: 隐式休眠  隐式休眠,当窗口打开,开始计算休眠时间,这里指定的是浏览器的总共休眠时间,如果这里用到1毛,就在总休眠时间里面减去1秒
        # 3: 显示休眠  显式休眠,可以设置指定的休眠时间,同时可以设置每隔几秒检查一次元素右没有加载,如果加载了,休眠时间就结束了

        # 查询一组切换窗口的方法

    def ClickWindowClsses(self, cls, index):

        # 获取当前窗口
        current = self.driver.current_window_handle
        # 查询一组控件,进行点击
        self.ClickClasses(cls, index)
        # 设置休眠 这里设置休眠的原因是 1: 有的电脑反应慢,点击完成以后,一会才跳转,而我们的代码执行的比较快,所以需要进行休眠一会再获取所有窗口,不然获取的窗口只有一个
        # 2: 我们点击完成以后,这里一般有逻辑判断,需要请求网络加载数据需要时间,所以需要休眠
        # 使用强制休眠 设置休眠时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 获取所有的窗口
        all_window = self.switch_to_window(current)

 # 切换到frame ID
    def seitch_to_id_frame(self,ID):

        # 切换到frame里面
        self.driver.switch_to.frame(self.FindID(ID))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame Name
    def seitch_to_name_frame(self, name):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindName(name))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame Class
    def seitch_to_class_frame(self, cls):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindClass(cls))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame xpath
    def seitch_to_xpath_frame(self, xpath):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindXpath(xpath))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame tag
    def seitch_to_tag_frame(self, tag):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindTag(tag))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame tag
    def seitch_to_css_frame(self, css):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindCss(css))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到原声的方法
    def switch_to_content(self):

        # 切换到本地
        self.driver.switch_to.default_content()

    # 封装断言, 查找控件,获取内容,断言前后是不是一致
    def AssertEquilClass(self,self1,cls,expect):

        # 查找控件,获取内容
        self.message = self.FindClass(cls).text
        # 进行断言
        self1.assertEqual(self.message,expect)

        pass

    # 通过 title去断言
    def AssertEquilTitle(self,self1,expect):

        # 设置休眠,在这里使用强制等待
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 查找控件,获取内容
        self.message = self.getTitle()
        # 进行断言
        self1.assertEqual(self.message,expect)

        pass

    # 断言数量
    def AssertEquilCount(self,self1,cls,number):

        # 查询一组控件,进行断言
        clses = self.FindClasses(cls)

        # 进行断言
        self1.assertEqual(len(clses), number)

        pass

    # 断言控件是不是可见
    def AssertTrueID(self,self1,ID):

        # 设置休眠 给网络请求或者逻辑判断的加载时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 进行断言
        self1.assertTrue(self.FindID(ID).is_displayed())

    # 通过 class 查询一组列表的元素
    def FindClasses(self,cls):

        # 查询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_elements_by_class_name(cls)

    # 通过指定下标进行点击的
    def ClickClasses(self,cls,index):

        # 进行点击
        self.FindClasses(cls)[index].click()

        # 休眠方式有三种
        # 1: 强制休眠  强制休眠,当代码执行到该句代码的时候,进行休眠,当休眠结束执行接写来的代码
        # 2: 隐式休眠  隐式休眠,当窗口打开,开始计算休眠时间,这里指定的是浏览器的总共休眠时间,如果这里用到1毛,就在总休眠时间里面减去1秒
        # 3: 显示休眠  显式休眠,可以设置指定的休眠时间,同时可以设置每隔几秒检查一次元素右没有加载,如果加载了,休眠时间就结束了

    # 查询一组切换窗口的方法
    def ClickWindowClsses(self,cls,index):

        # 获取当前窗口
        current = self.driver.current_window_handle
        # 查询一组控件,进行点击
        self.ClickClasses(cls,index)
        # 设置休眠 这里设置休眠的原因是 1: 有的电脑反应慢,点击完成以后,一会才跳转,而我们的代码执行的比较快,所以需要进行休眠一会再获取所有窗口,不然获取的窗口只有一个
        # 2: 我们点击完成以后,这里一般有逻辑判断,需要请求网络加载数据需要时间,所以需要休眠
        # 使用强制休眠 设置休眠时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 获取所有的窗口
        all_window = self.switch_to_window(current)

        # 切换到frame ID


def seitch_to_id_frame(self, ID):
    # 切换到frame里面
    self.driver.switch_to.frame(self.FindID(ID))
    # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
    pass

    # 切换到frame Name


def seitch_to_name_frame(self, name):
    # 切换到frame里面
    self.driver.switch_to.frame(self.FindName(name))
    # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
    pass

    # 切换到frame Class


def seitch_to_class_frame(self, cls):
    # 切换到frame里面
    self.driver.switch_to.frame(self.FindClass(cls))
    # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
    pass

    # 切换到frame xpath


def seitch_to_xpath_frame(self, xpath):
    # 切换到frame里面
    self.driver.switch_to.frame(self.FindXpath(xpath))
    # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
    pass

    # 切换到frame tag


def seitch_to_tag_frame(self, tag):
    # 切换到frame里面
    self.driver.switch_to.frame(self.FindTag(tag))
    # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
    pass

    # 切换到frame tag


def seitch_to_css_frame(self, css):
    # 切换到frame里面
    self.driver.switch_to.frame(self.FindCss(css))
    # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
    pass

    # 切换到原声的方法


def switch_to_content(self):
    # 切换到本地
    self.driver.switch_to.default_content()

    # 封装断言, 查找控件,获取内容,断言前后是不是一致


def AssertEquilClass(self, self1, cls, expect):
    # 查找控件,获取内容
    self.message = self.FindClass(cls).text
    # 进行断言
    self1.assertEqual(self.message, expect)

    pass

    # 通过 title去断言


def AssertEquilTitle(self, self1, expect):
    # 设置休眠,在这里使用强制等待
    self.TimeSleep(ENUMS.FIVE_TIME)
    # 查找控件,获取内容
    self.message = self.getTitle()
    # 进行断言
    self1.assertEqual(self.message, expect)

    pass

    # 断言数量


def AssertEquilCount(self, self1, cls, number):
    # 查询一组控件,进行断言
    clses = self.FindClasses(cls)

    # 进行断言
    self1.assertEqual(len(clses), number)

    pass

    # 断言控件是不是可见


def AssertTrueID(self, self1, ID):
    # 设置休眠 给网络请求或者逻辑判断的加载时间
    self.TimeSleep(ENUMS.FIVE_TIME)
    # 进行断言
    self1.assertTrue(self.FindID(ID).is_displayed())

    # 通过 class 查询一组列表的元素


def FindClasses(self, cls):
    # 查询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_elements_by_class_name(cls)

    # 通过指定下标进行点击的


def ClickClasses(self, cls, index):
    # 进行点击
    self.FindClasses(cls)[index].click()

    # 休眠方式有三种
    # 1: 强制休眠  强制休眠,当代码执行到该句代码的时候,进行休眠,当休眠结束执行接写来的代码
    # 2: 隐式休眠  隐式休眠,当窗口打开,开始计算休眠时间,这里指定的是浏览器的总共休眠时间,如果这里用到1毛,就在总休眠时间里面减去1秒
    # 3: 显示休眠  显式休眠,可以设置指定的休眠时间,同时可以设置每隔几秒检查一次元素右没有加载,如果加载了,休眠时间就结束了

    # 查询一组切换窗口的方法


def ClickWindowClsses(self, cls, index):
    # 获取当前窗口
    current = self.driver.current_window_handle
    # 查询一组控件,进行点击
    self.ClickClasses(cls, index)
    # 设置休眠 这里设置休眠的原因是 1: 有的电脑反应慢,点击完成以后,一会才跳转,而我们的代码执行的比较快,所以需要进行休眠一会再获取所有窗口,不然获取的窗口只有一个
    # 2: 我们点击完成以后,这里一般有逻辑判断,需要请求网络加载数据需要时间,所以需要休眠
    # 使用强制休眠 设置休眠时间
    self.TimeSleep(ENUMS.FIVE_TIME)
    # 获取所有的窗口
    all_window = self.switch_to_window(current)

 # 切换到frame ID
    def seitch_to_id_frame(self,ID):

        # 切换到frame里面
        self.driver.switch_to.frame(self.FindID(ID))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame Name
    def seitch_to_name_frame(self, name):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindName(name))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame Class
    def seitch_to_class_frame(self, cls):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindClass(cls))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame xpath
    def seitch_to_xpath_frame(self, xpath):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindXpath(xpath))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame tag
    def seitch_to_tag_frame(self, tag):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindTag(tag))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到frame tag
    def seitch_to_css_frame(self, css):
        # 切换到frame里面
        self.driver.switch_to.frame(self.FindCss(css))
        # 注意 pass没有任何意义,只是在写代码的时候怕报错,用来占位的
        pass

    # 切换到原声的方法
    def switch_to_content(self):

        # 切换到本地
        self.driver.switch_to.default_content()

    # 封装断言, 查找控件,获取内容,断言前后是不是一致
    def AssertEquilClass(self,self1,cls,expect):

        # 查找控件,获取内容
        self.message = self.FindClass(cls).text
        # 进行断言
        self1.assertEqual(self.message,expect)

        pass

    # 通过 title去断言
    def AssertEquilTitle(self,self1,expect):

        # 设置休眠,在这里使用强制等待
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 查找控件,获取内容
        self.message = self.getTitle()
        # 进行断言
        self1.assertEqual(self.message,expect)

        pass

    # 断言数量
    def AssertEquilCount(self,self1,cls,number):

        # 查询一组控件,进行断言
        clses = self.FindClasses(cls)

        # 进行断言
        self1.assertEqual(len(clses), number)

        pass

    # 断言控件是不是可见
    def AssertTrueID(self,self1,ID):

        # 设置休眠 给网络请求或者逻辑判断的加载时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 进行断言
        self1.assertTrue(self.FindID(ID).is_displayed())

    # 通过 class 查询一组列表的元素
    def FindClasses(self,cls):

        # 查询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_elements_by_class_name(cls)

    # 通过指定下标进行点击的
    def ClickClasses(self,cls,index):

        # 进行点击
        self.FindClasses(cls)[index].click()

        # 休眠方式有三种
        # 1: 强制休眠  强制休眠,当代码执行到该句代码的时候,进行休眠,当休眠结束执行接写来的代码
        # 2: 隐式休眠  隐式休眠,当窗口打开,开始计算休眠时间,这里指定的是浏览器的总共休眠时间,如果这里用到1毛,就在总休眠时间里面减去1秒
        # 3: 显示休眠  显式休眠,可以设置指定的休眠时间,同时可以设置每隔几秒检查一次元素右没有加载,如果加载了,休眠时间就结束了

    # 查询一组切换窗口的方法
    def ClickWindowClsses(self,cls,index):

        # 获取当前窗口
        current = self.driver.current_window_handle
        # 查询一组控件,进行点击
        self.ClickClasses(cls,index)
        # 设置休眠 这里设置休眠的原因是 1: 有的电脑反应慢,点击完成以后,一会才跳转,而我们的代码执行的比较快,所以需要进行休眠一会再获取所有窗口,不然获取的窗口只有一个
        # 2: 我们点击完成以后,这里一般有逻辑判断,需要请求网络加载数据需要时间,所以需要休眠
        # 使用强制休眠 设置休眠时间
        self.TimeSleep(ENUMS.FIVE_TIME)
        # 获取所有的窗口
        all_window = self.switch_to_window(current)














class ENUMS (Enum):
       #两秒
       TWO_TIME=2
       #五秒
       FIVE_TIME=5
       #二十秒
       TWENTY_TIME = 2
       #十秒
       TEN_TIME=10
       #0.5
       ONE_HALF=0.5

//打开指定网页的封装

#-*- coding:utf-8 -*-
#测试环境有三种
#生产环境，预生产环境，测试环境

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

      JD_SHOPCAR="https://cart.jd.com/cart.action#none"

//购物车的全选按钮以及总价的计算 shopcarpy块

#-*- coding:utf-8 -*-
import unittest
from selenium import webdriver
#声明类继承单元测试
from util import fiefoxutil,urlutil

class ShopCar(unittest.TestCase):
       #实例化对象
       @classmethod
       def setUpClass(self):
           self.firefox=fiefoxutil.FireFox()
           #实例化URL
           self.URL=urlutil.URL()

       #打开浏览器
       def setUp(self):
           #打开浏览器
           self.firefox.firefox_start(self.URL.JD_SHOPCAR)
           pass

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

       #测试用例
       def test_shop_car(self):

           self.firefox.ClickLink("登录")
           #休眠，因为有from需要弹出，切换窗口的时候需要时间
           self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)
           #切换fram
           self.firefox.seitch_to_ID_frame("dialogIframe")
           #点击账号登陆
           self.firefox.ClickClass("login-tab-r")
           #输入账号
           self.firefox.SendkeysID("loginname","13521169273")
           #输入密码
           self.firefox.SendkeysID("nloginpwd","geili2016.")
           #点击登陆
           self.firefox.ClickID("loginsubmit")
           self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)
           #第一条购物车的流程测试用例，点击全选按钮将所有商品的总价加起来
           self.firefox.ClickName("toggle-checkboxes")
           #休眠 点击全选按钮的时候需要事件反应
           self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)
           #判断没意见商品是否被点上
           self.checkItems=self.firefox.FindNames("checkItem")
           for index in self.checkItems:
               #判断选没选中，如果没选中，点击选中
               if index.get_attribute("checked")!="true":
                   index.click()
                   #休眠，因为点击全选按钮的时候下面商品的按钮需要时间选中
                   self.firefox.TimeSleep(fiefoxutil.ENUMS.TWO_TIME)

           #计算所有商品的总价与总计的总价是否相等
           #开始查找一组控件，返回的list列表
           self.prices=self.firefox.FindXpaths("//div[@class='item-form']/div[6]/strong")
           #使用for循环打印
           #注意网页里面获取的内容使unicode编码格式
           #首先我们需要对unicode格式进行编码格式，编码为UTF-8格式
           #对编码的格式进行替换，将￥提交未空，再转为float类型，我们就可以加法晕算了
           self.checkItems=self.firefox.FindNames("checkItem")
           #定义变量sum进行相加
           suns=0
           for index in range(0,len(self.prices)):
               #得到内容
               price_before=self.prices[index].text
               #进行UTF-8编码
               price_after=price_before.encode("UTF-8")
               #对字符串进行替换
               price_replace=price_after.replace("￥"," ")
               #最后转为Float类型
               price_float=float(price_replace)
               #打印内容
               print price_float
               #判断如果是选中的就加起来，没有选中就不加起来
               print self.checkItems[index].get_attribute("checked")
               if self.checkItems[index].get_attribute("checked")=="true":
                   suns+=price_float

           print "总价",suns
           #查找总价的控件，进行断言，
           ems=self.firefox.FindXpath("//div[@class='price-sum']/div/span/em").text.encode("utf-8").replace("￥","")
           #获取内容
           message=float(ems)
           #进行断言
           self.assertEqual(suns,message)


           pass

//购物车的全选按钮反选， shopchecbox块

#-*- coding:utf-8 -*-
#导入单元测试
import unittest
#导入
from util import fiefoxutil,urlutil

#声明类继承单元测试
class ShopCheckbox(unittest.TestCase):

       #实例化工具类
       @classmethod
       def setUpClass(self):
           #实例化工具类
           self.firefox=fiefoxutil.FireFox()
           self.URL=urlutil.URL()

       #打开浏览器
       def setUp(self):
           self.firefox.firefox_start(self.URL.JD_SHOPCAR)
           pass

       def tearDown(self):
           #关闭
           self.firefox.firefox_close()
           pass

       #登陆的方法
       def test_login(self):
           # 点击登陆按钮，登陆进去
           # 点击登陆按钮
           self.firefox.ClickLink("登录")
           # 休眠
           self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)
           self.firefox.seitch_to_ID_frame("dialogIframe")
           self.firefox.TimeSleep(fiefoxutil.ENUMS.TWO_TIME)
           self.firefox.ClickClass("login-tab-r")
           self.firefox.SendkeysID("loginname", "13521169273")
           self.firefox.SendkeysID("nloginpwd", "geili2016.")
           self.firefox.ClickID("loginsubmit")
           self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)
           pass

       #登陆的方法
       def test_checkbox_four_one(self):
           self.test_login()
           # self.firefox.ClickClass("jdcheckbox")

           #测试用例如下，因为上面和下面都有全部选择按钮，首先我i们点击上面的全选按钮
           #然后判断下面的几种商品有没有被选中，如果全部选中了，把第一件设为不选中
           #如果有几个是选中的有几个是未选中的，我们就将第一个不选中，其他的讯中‘
           self.firefox.ClickClass("jdcheckbox")
           #休眠
           self.firefox.TimeSleep(fiefoxutil.ENUMS.TWO_TIME)
           #查询其余的是否被选中
           self.checkItems=self.firefox.FindNames("checkItem")
           for index in range(0,len(self.checkItems)):
               if index==0:
                   if self.checkItems[index].get_attribute("checked")=="true":
                       #点击以下设为不选中
                       self.checkItems[index].click()
                       #设置休眠时间，因为选中以后，需要时间像服务器提交数据
               else:
                   if self.checkItems[index].get_attribute("checked")!="true":
                       #点击以下，设为不选中
                       self.checkItems[index].click()
                       self.firefox.TimeSleep(fiefoxutil.ENUMS.TWO_TIME)

           #再次重新查找控件，判断是不是第一个未选中，后面四个是选中的
           #查询五个checkbox是不是全部选中，因为数据发生了改变，所以我们重新查找
           self.checkItems=self.firefox.FindNames("checkItem")
           #查询for循环。和断言来判断是不是符合我们的预期
           for index in range(0,len(self.checkItems)):
               if index==0:
                   #断言获取的属性值是不是为空
                   self.assertEqual(self.checkItems[index].get_attribute("checked"),None)

               else:
                   isSelect=self.checkItems[index].get_attribute("checked")
                   self.assertTrue(isSelect)
           #通过class查询一组全部选择控件
           self.jdcheckboxs=self.firefox.FindNames("toggle-checkboxes")
           for index in range(0,len(self.jdcheckboxs)):
               print index
               #加入休眠
               self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)
               #获取属性，进行断言，判断是否被选中
               self.assertEqual(self.jdcheckboxs[index].get_attribute("checked"),None)


       #验证复选框的全部选中有没有效果
       def test_select_all(self):
           #调用登陆的方法
           self.test_login()
           self.checkItems=self.firefox.FindNames("checkItem")
           for item in self.checkItems:
               if item.get_attribute("checked")!="true":
                   item.click()
                   self.firefox.TimeSleep(fiefoxutil.ENUMS.FIVE_TIME)

           self.toggle_checkboxes=self.firefox.FindNames("toggle-checkboxes")
           for index in self.toggle_checkboxes:
               self.assertEqual(index.get_attribute("checked"),"true")
           pass

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

//suit 生成自动化测试用例

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

# 导入单元测试
import unittest
# 导入单元测试
from unit import shopcar,shopcheckbox
# 导入自动化测试报告
import HTMLTestRunner
# 导入os包
import os

# 设置系统编码格式
# 导入sys
import sys
# 重新加载
reload(sys)
# 设置编码格式
sys.setdefaultencoding("UTF-8")
# 注意如果设置以上三句代码,报告有可能还乱码,咱们还需要设置自动化测试报告里面的编码格式

# 实例化套件
suit = unittest.TestSuite()

# 将单元测试加入到套件里面
# suit.addTest(unittest.makeSuite(login.Login))
# suit.addTest(unittest.makeSuite(shop.Shop))
#suit.addTest(unittest.makeSuite(shopcar.ShopCar))
suit.addTest(unittest.makeSuite(shopcheckbox.ShopCheckbox))


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



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


# 运行
runner.run(suit)

为你为我

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
测试自动化脚本购物生的全选按钮

//八种查找控件以及from切换的封装#-*- coding:utf-8 -*-#导包from enum import Enumfrom selenium import webdriver#导入休眠包import time#三种休眠的包from selenium.webdriver.support.wait import WebDriverWaitfrom selenium.w
复制链接

扫一扫