Python 从无到有搭建WebUI自动化测试框架_python ui自动化框架

from selenium import webdriver
driver = webdriver.Chrome()
driver.get('https://www.baidu.com')

class BrowserOperator(object):
 
    def __init__(self):
        self.conf = Config()
        self.driver_path = os.path.join(BASEFACTORYDIR, 'chromedriver.exe')
        self.driver_type = str(self.conf.get('base', 'browser_type')).lower()

def open_url(self, **kwargs):
    """
    打开网页
    :param url:
    :return: 返回 webdriver
    """
    try:
        url = kwargs['locator']
    except KeyError:
        return False, '没有URL参数'

    try:
        if self.driver_type == 'chrome':
            #处理chrom弹出的info
            # chrome_options = webdriver.ChromeOptions()
            # #option.add_argument('disable-infobars')
            # chrome_options.add_experimental_option("excludeSwitches", ['enable-automation'])
            # self.driver = webdriver.Chrome(options=chrome_options, executable_path=self.driver_path)
            self.driver = webdriver.Chrome(executable_path=self.driver_path)
            self.driver.maximize_window()
            self.driver.get(url)
        elif self.driver_type == 'ie':
            print('IE 浏览器')
        else:
            print('火狐浏览器')
    except Exception as e:
        return False, e
    return True, self.driver

wd = BrowserOperator()
wd.open_url(locator='https://www.qq.com')

wd = BrowserOperator()
isOK, deiver = wd.open_url(locator='https://www.qq.com')
time.sleep(5)
deiver.find_elements_by_xpath('//*[@id="sougouTxt"]')[0].send_keys('飞人')
deiver.find_elements_by_xpath('//*[@id="searchBtn"]')[0].click()

def close_browser(self, **kwargs):
    """
    关闭浏览器
    :return:
    """
    time.sleep(1)
    self.driver.quit()
    time.sleep(2)
    return True, '关闭浏览器成功'

wd = BrowserOperator()
isOK, deiver = wd.open_url(locator='https://www.qq.com')
time.sleep(5)
deiver.find_elements_by_xpath('//*[@id="sougouTxt"]')[0].send_keys('飞人')
deiver.find_elements_by_xpath('//*[@id="searchBtn"]')[0].click()
wd.close_browser()

import os
import win32gui
import win32con
import time
from selenium import webdriver
from common.getconf import Config
from common.getfiledir import BASEFACTORYDIR
from pywinauto import application
 
 
 
class BrowserOperator(object):
 
    def __init__(self):
        self.conf = Config()
        self.driver_path = os.path.join(BASEFACTORYDIR, 'chromedriver.exe')
        self.deriver_type = str(self.conf.get('base', 'browser_type')).lower()
 
    def open_url(self, **kwargs):
        """
        打开网页
        :param url:
        :return: 返回 webdriver
        """
        try:
            url = kwargs['locator']
        except KeyError:
            return False, '没有URL参数'
        try:
            if self.deriver_type == 'chrome':
                #处理chrom弹出的info
                # chrome_options = webdriver.ChromeOptions()
                # #option.add_argument('disable-infobars')
                # chrome_options.add_experimental_option("excludeSwitches", ['enable-automation'])
                # self.driver = webdriver.Chrome(options=chrome_options, executable_path=self.driver_path)
                self.driver = webdriver.Chrome(executable_path=self.driver_path)
                self.driver.maximize_window()
                self.driver.get(url)
            elif self.deriver_type == 'ie':
                print('IE 浏览器')
            else:
                print('火狐浏览器')
        except Exception as e:
            return False, e
        return True, self.driver
 
 
 
 
    def close_browser(self, **kwargs):
        """
        关闭浏览器
        :return:
        """
        time.sleep(1)
        self.driver.quit()
        time.sleep(2)
        return True, '关闭浏览器成功'
 
 
    def upload_file(self, **kwargs):
        """
        上传文件
        :param kwargs:
        :return:
        """
        try:
            dialog_class = kwargs['type']
            file_dir = kwargs['locator']
            button_name = kwargs['index']
        except KeyError:
            return True, '没传对话框的标记或没传文件路径,'
 
        if self.deriver_type == "chrome":
            title = "打开"
        elif self.deriver_type == "firefox":
            title = "文件上传"
        elif self.deriver_type == "ie":
            title = "选择要加载的文件"
        else:
            title = ""  # 这里根据其它不同浏览器类型来修改
            # 找元素
            # 一级窗口"#32770","打开"
        dialog = win32gui.FindWindow(dialog_class, title)
        if dialog == 0:
            return False, '传入对话框的class定位器有误'
        # 向下传递
        ComboBoxEx32 = win32gui.FindWindowEx(dialog, 0, "ComboBoxEx32", None)  # 二级
        comboBox = win32gui.FindWindowEx(ComboBoxEx32, 0, "ComboBox", None)  # 三级
        # 编辑按钮
        edit = win32gui.FindWindowEx(comboBox, 0, 'Edit', None)  # 四级
        # 打开按钮
 
        button = win32gui.FindWindowEx(dialog, 0, 'Button', button_name)  # 二级
        if button == 0:
            return False, '按钮text属性传值有误'
        # 输入文件的绝对路径，点击“打开”按钮
        win32gui.SendMessage(edit, win32con.WM_SETTEXT, None, file_dir)  # 发送文件路径
        time.sleep(1)
        win32gui.SendMessage(dialog, win32con.WM_COMMAND, 1, button)  # 点击打开按钮
        return True, '上传文件成功'

import os
import time
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver import Chrome
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By
from common.getfiledir import SCREENSHOTDIR

class WebdriverOperator(object):
 
    def __init__(self, driver:Chrome):
        self.driver = driver

def get_screenshot_as_file(self):
    """
    截屏保存
    :return:返回路径
    """
    pic_name = str.split(str(time.time()), '.')[0] + str.split(str(time.time()), '.')[1] + '.png'
    screent_path = os.path.join(SCREENSHOTDIR, pic_name)
    self.driver.get_screenshot_as_file(screent_path)
    return screent_path

from basefactory.browseroperator import BrowserOperator
from basefactory.webdriveroperator import WebdriverOperator
 
bo = BrowserOperator()
isOK, deiver = bo.open_url(locator='https://www.qq.com')
wb = WebdriverOperator(deiver)
result = wb.get_screenshot_as_file()     #调用截图方法，返回路径打印
print(result)

def web_implicitly_wait(self, **kwargs):
    """
    隐式等待
    :return:
    type  存时间
    """
    try:
        s = kwargs['time']
    except KeyError:
        s = 10
    try:
        self.driver.implicitly_wait(s)
    except NoSuchElementException:
        return False, '隐式等待设置失败'
    return True, '隐式等待设置成功'

from basefactory.browseroperator import BrowserOperator
from basefactory.webdriveroperator import WebdriverOperator
 
bo = BrowserOperator()
isOK, deiver = bo.open_url(locator='https://www.baidu.com')
wb = WebdriverOperator(deiver)
isOK, result = wb.web_implicitly_wait()    #设置隐式等待，打印隐式等待的结果
print(result)
deiver.find_elements_by_xpath('//*[@id="kw"]')[0].send_keys('飞人')
deiver.find_elements_by_xpath('//*[@id="su"]')[0].click()
deiver.find_elements_by_xpath('//*[@id="rs"]/div')

def web_element_wait(self, **kwargs):
    """
    等待元素可见
    :return:
    """
    try:
        type = kwargs['type']
        locator = kwargs['locator']
    except KeyError:
        return False, '未传需要等待元素的定位参数'
    try:
        s = kwargs['time']
        if s is None:
            s = 30
    except KeyError:
        s = 30
 
    try:
        if type == 'id':
            WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.ID, locator)))
        elif type == 'name':
            WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.NAME, locator)))
        elif type == 'class':
            WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.CLASS_NAME, locator)))
        elif type == 'xpath':
            WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.XPATH, locator)))
        elif type == 'css':
            WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.CSS_SELECTOR, locator)))
        else:
            return False, '不能识别元素类型[' + type + ']'
    except TimeoutException:
        screenshot_path = self.get_screenshot_as_file()
        return False, '元素[' + locator + ']等待出现失败,已截图[' + screenshot_path + '].'
    return True, '元素[' + locator + ']等待出现成功'

from basefactory.browseroperator import BrowserOperator
from basefactory.webdriveroperator import WebdriverOperator
 
bo = BrowserOperator()
isOK, deiver = bo.open_url(locator='https://www.baidu.com')
wb = WebdriverOperator(deiver)
isOK, result = wb.web_element_wait(type='xpath', locator='//*[@id="kw"]', s=0.001)
print(result)

def element_input(self, **kwargs):
    """
 
    :param kwargs:
    :return:
    """
    try:
        type = kwargs['type']
        locator = kwargs['locator']
        text = str(kwargs['input'])
    except KeyError:
        return False, '缺少传参'
    try:
        index = kwargs['index']
    except KeyError:
        index = 0       
    try:
        if type == 'id':
            elem = self.driver.find_elements_by_id(locator)[index]
        elif type == 'name':
            elem = self.driver.find_elements_by_name(locator)[index]
        elif type == 'class':
            elem = self.driver.find_elements_by_class_name(locator)[index]
        elif type == 'xpath':
            elem = self.driver.find_elements_by_xpath(locator)[index]
        elif type == 'css':
            elem = self.driver.find_elements_by_css_selector(locator)[index]
        else:
            return False, '不能识别元素类型:[' + type + ']'
    except Exception as e:
        screenshot_path = self.get_screenshot_as_file()
        return False, '获取[' + type + ']元素[' + locator + ']失败,已截图[' + screenshot_path + '].'
    try:
        elem.send_keys(text)
    except Exception:
        screenshot_path = self.get_screenshot_as_file()
        return False, '元素['+ locator +']输入['+ text +']失败,已截图[' + screenshot_path + '].'
    return True, '元素['+ locator +']输入['+ text +']成功'

type = kwargs['type']
locator = kwargs['locator']
text = str(kwargs['input'])
index = kwargs['index']

try:
    if type == 'id':
        elem = self.driver.find_elements_by_id(locator)[index]
    elif type == 'name':
        elem = self.driver.find_elements_by_name(locator)[index]
    elif type == 'class':
        elem = self.driver.find_elements_by_class_name(locator)[index]
    elif type == 'xpath':
        elem = self.driver.find_elements_by_xpath(locator)[index]
    elif type == 'css':
        elem = self.driver.find_elements_by_css_selector(locator)[index]
    else:
        return False, '不能识别元素类型:[' + type + ']'
except Exception as e:
    screenshot_path = self.get_screenshot_as_file()
    return False, '获取[' + type + ']元素[' + locator + ']失败,已截图[' + screenshot_path + '].'

try:
    elem.send_keys(text)
except Exception:
    screenshot_path = self.get_screenshot_as_file()
    return False, '元素['+ locator +']输入['+ text +']失败,已截图[' + screenshot_path + '].'
return True, '元素['+ locator +']输入['+ text +']成功'

bo = BrowserOperator()
isOK, deiver = bo.open_url(locator='https://www.baidu.com')
wb = WebdriverOperator(deiver)
isOK, result = wb.web_element_wait(type='xpath', locator='//*[@id="kw"]', s=0.001)
print(result)
isOK, result = wb.element_input(type='xpath', locator='//*[@id="kw"]', input='飞人', index=0)    #元素输入方法
print(result)

def find_element(self, type, locator, index=None):
    """
    定位元素
    :param type:
    :param itor:
    :param index:
    :return:
    """
    time.sleep(1)
    #isinstance(self.driver, selenium.webdriver.Chrome.)
    if index is None:
        index = 0
    type = str.lower(type)
    try:
        if type == 'id':
            elem = self.driver.find_elements_by_id(locator)[index]
        elif type == 'name':
            elem = self.driver.find_elements_by_name(locator)[index]
        elif type == 'class':
            elem = self.driver.find_elements_by_class_name(locator)[index]
        elif type == 'xpath':
            elem = self.driver.find_elements_by_xpath(locator)[index]
        elif type == 'css':
            elem = self.driver.find_elements_by_css_selector(locator)[index]
        else:
            return False, '不能识别元素类型:[' + type + ']'
    except Exception as e:
        screenshot_path = self.get_screenshot_as_file()
        return False, '获取[' + type + ']元素[' + locator + ']失败,已截图[' + screenshot_path + '].'
    return True, elem

def element_input(self, **kwargs):
    """
 
    :param kwargs:
    :return:
    """
    try:
        type = kwargs['type']
        locator = kwargs['locator']
        text = str(kwargs['input'])
    except KeyError:
        return False, '缺少传参'
    try:
        index = kwargs['index']
    except KeyError:
        index = 0
    isOK, result = self.find_element(type, locator, index)
    if not isOK:  # 元素没找到，返回失败结果
        return isOK, result
    elem = result
    try:
        elem.send_keys(text)
    except Exception:
        screenshot_path = self.get_screenshot_as_file()
        return False, '元素['+ locator +']输入['+ text +']失败,已截图[' + screenshot_path + '].'
    return True, '元素['+ locator +']输入['+ text +']成功'

def element_click(self, **kwargs):
    """
 
    :param kwargs:
    :return:
    """
    try:
        type = kwargs['type']
        locator = kwargs['locator']
 
    except KeyError:
        return False, '缺少传参'
    try:
        index = kwargs['index']
    except KeyError:
        index = 0
    isOK, result = self.find_element(type, locator, index)
    if not isOK:      #元素没找到，返回失败结果
        return isOK, result
    elem = result
    try:
        elem.click()
    except Exception:
        screenshot_path = self.get_screenshot_as_file()
        return False, '元素['+ locator +']点击失败,已截图[' + screenshot_path + '].'
    return True, '元素['+ locator +']点击成功'

bo = BrowserOperator()
isOK, deiver = bo.open_url(locator='https://www.baidu.com')
wb = WebdriverOperator(deiver)
isOK, result = wb.web_element_wait(type='xpath', locator='//*[@id="kw"]', s=0.001)
print(result)
isOK, result = wb.element_input(type='xpath', locator='//*[@id="kw"]', input='飞人', index=0)
print(result)
isOK, result = wb.element_click(type='xpath', locator='//*[@id="su"]', index=0)    #元素点击方法
print(result)

import os
import time
 
from selenium.common.exceptions import NoSuchElementException, TimeoutException
from selenium.webdriver import Chrome
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.common.by import By
from common.getfiledir import SCREENSHOTDIR
 
 
 
 
class WebdriverOperator(object):
 
    def __init__(self, driver:Chrome):
        self.driver = driver
 
    def get_screenshot_as_file(self):
        """
        截屏保存
        :return:返回路径
        """
        pic_name = str.split(str(time.time()), '.')[0] + str.split(str(time.time()), '.')[1] + '.png'
        screent_path = os.path.join(SCREENSHOTDIR, pic_name)
        self.driver.get_screenshot_as_file(screent_path)
        return screent_path
 
    def gotosleep(self, **kwargs):
        time.sleep(3)
        return True, '等待成功'
 
 
    def web_implicitly_wait(self, **kwargs):
        """
        隐式等待
        :return:
        type  存时间
        """
        try:
            s = kwargs['time']
        except KeyError:
            s = 10
        try:
            self.driver.implicitly_wait(s)
        except NoSuchElementException:
            return False, '隐式等待 页面元素未加载完成'
        return True, '隐式等待 元素加载完成'
 
 
    def web_element_wait(self, **kwargs):
        """
        等待元素可见
        :return:
        """
        try:
            type = kwargs['type']
            locator = kwargs['locator']
        except KeyError:
            return False, '未传需要等待元素的定位参数'
        try:
            s = kwargs['time']
            if s is None:
                s = 30
        except KeyError:
            s = 30
 
        try:
            if type == 'id':
                WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.ID, locator)))
            elif type == 'name':
                WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.NAME, locator)))
            elif type == 'class':
                WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.CLASS_NAME, locator)))
            elif type == 'xpath':
                WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.XPATH, locator)))
            elif type == 'css':
                WebDriverWait(self.driver, s, 0.5).until(EC.visibility_of_element_located((By.CSS_SELECTOR, locator)))
            else:
                return False, '不能识别元素类型[' + type + ']'
        except TimeoutException:
            screenshot_path = self.get_screenshot_as_file()
            return False, '元素[' + locator + ']等待出现失败,已截图[' + screenshot_path + '].'
        return True, '元素[' + locator + ']等待出现成功'
 
 
    def find_element(self, type, locator, index=None):
        """
        定位元素
        :param type:
        :param itor:
        :param index:
        :return:
        """
        time.sleep(1)
        #isinstance(self.driver, selenium.webdriver.Chrome.)
        if index is None:
            index = 0
        type = str.lower(type)
        try:
            if type == 'id':
                elem = self.driver.find_elements_by_id(locator)[index]
            elif type == 'name':
                elem = self.driver.find_elements_by_name(locator)[index]
            elif type == 'class':
                elem = self.driver.find_elements_by_class_name(locator)[index]
            elif type == 'xpath':
                elem = self.driver.find_elements_by_xpath(locator)[index]
            elif type == 'css':
                elem = self.driver.find_elements_by_css_selector(locator)[index]
            else:
                return False, '不能识别元素类型:[' + type + ']'
        except Exception as e:
            screenshot_path = self.get_screenshot_as_file()
            return False, '获取[' + type + ']元素[' + locator + ']失败,已截图[' + screenshot_path + '].'
        return True, elem
 
 
    def element_click(self, **kwargs):
        """
 
        :param kwargs:
        :return:
        """
        try:
            type = kwargs['type']
            locator = kwargs['locator']
 
        except KeyError:
            return False, '缺少传参'
        try:
            index = kwargs['index']
        except KeyError:
            index = 0
        isOK, result = self.find_element(type, locator, index)
        if not isOK:      #元素没找到，返回失败结果
            return isOK, result
        elem = result
        try:
            elem.click()
        except Exception:
            screenshot_path = self.get_screenshot_as_file()
            return False, '元素['+ locator +']点击失败,已截图[' + screenshot_path + '].'
        return True, '元素['+ locator +']点击成功'
 
 
    def element_input(self, **kwargs):
        """
 
        :param kwargs:
        :return:
        """
        try:
            type = kwargs['type']
            locator = kwargs['locator']
            text = str(kwargs['input'])
        except KeyError:
            return False, '缺少传参'
        try:
            index = kwargs['index']
        except KeyError:
            index = 0
        isOK, result = self.find_element(type, locator, index)
        if not isOK:  # 元素没找到，返回失败结果
            return isOK, result
        elem = result
        try:
            elem.send_keys(text)
        except Exception:
            screenshot_path = self.get_screenshot_as_file()
            return False, '元素['+ locator +']输入['+ text +']失败,已截图[' + screenshot_path + '].'
        return True, '元素['+ locator +']输入['+ text +']成功'
 
 
 
 
 

import os
 
dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
DATADIR = os.path.join(dir, 'data')
 
CONFDIR = os.path.join(dir, 'config')
 
BASEFACTORYDIR = os.path.join(dir, 'basefactory')
 
RESULTDIR = os.path.join(dir, 'result')
 
LOGDIR = os.path.join(RESULTDIR, 'log')
 
REPORTDIR = os.path.join(RESULTDIR, 'report')
 
SCREENSHOTDIR = os.path.join(RESULTDIR, 'screenshot')
 
CASEDIR = os.path.join(dir, 'excutetest')
 
#print(SCREENSHOTDIR)
 
 

class ReadCase(object):
    def __init__(self):
        self.sw = openpyxl.load_workbook(file)
        print(self.sw)

xlsx = ReadCase()

def readcase(self, sh):
    """
    组合sheet页的数据
    :param sh:
    :return: list,返回组合数据
    """
    if sh is None:
        return False, '用例页参数未传'
    datas = list(sh.rows)
    if datas == []:
        return False, '用例[' + sh.title + ']里面是空的'
    title = [i.value for i in datas[0]]
    rows = []
    sh_dict = {}
    for i in datas[1:]:
        data = [v.value for v in i]
        row = dict(zip(title, data))
        try:
            if str(row['id'])[0] is not '#':
                row['sheet'] = sh.title
                rows.append(row)
        except KeyError:
            raise e
            rows.append(row)
        sh_dict[sh.title] = rows
    return True, sh_dict

if sh is None:
    return False, '用例页参数未传'

datas = list(sh.rows)
if datas == []:
    return False, '用例[' + sh.title + ']里面是空的'

title = [i.value for i in datas[0]]

for i in datas[1:]:
    data = [v.value for v in i]
    row = dict(zip(title, data))
    try:
        if str(row['id'])[0] is not '#':
            row['sheet'] = sh.title
            rows.append(row)
    except KeyError:
        raise e
        rows.append(row)
    sh_dict[sh.title] = rows
return True, sh_dict

xlsx = ReadCase()
for sh in xlsx.sw:
    isOK, result = xlsx.readcase(sh)
    print(result)

def readallcase(self):
    """
    取所有sheet页
    :return:list,返回sheet页里的数据
    """
    sheet_list = []
    for sh in self.sw:     #遍历sheet，
        if 'common' != sh.title.split('_')[0] and 'common' != sh.title.split('-')[0] and sh.title[0] is not '#' :   #判断是否可用的用例
            isOK, result = self.readcase(sh)     #传给readcase取用例
            if isOK:
                sheet_list.append(result)  #得到结果放到列表，又给用例套了一层sheet页的框
    if sheet_list is None:
        return False, '用例集是空的，请检查用例'
    return True, sheet_list

xlsx = ReadCase()
isOK, result = xlsx.readallcase()
print(result)

def get_common_case(self, case_name):
    """
    得到公共用例
    :param case_name:
    :return:
    """
    try:
        sh = self.sw.get_sheet_by_name(case_name)
    except KeyError:
        return False, '未找到公共用例[' + case_name + '],请检查用例'
    except DeprecationWarning:
        pass
    return self.readcase(sh)

xlsx = ReadCase()
isOK, result = xlsx.get_common_case('baidu')
print(result)

import openpyxl
import os
from common.getfiledir import DATADIR
file = os.path.join(DATADIR, 'case.xlsx')
 
class ReadCase(object):
    def __init__(self):
        self.sw = openpyxl.load_workbook(file)
        print(self.sw)
 
 
    def openxlsx(self, file):
        """
        打开文件
        :param dir:
        :return:
        """
        # self.sw = openpyxl.load_workbook(file)
 
    #[{"a": [{"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}]},{"a": [5, 3, 2]}, {"a": [10, 4, 6]}]
    def readallcase(self):
        """
        取所有sheet页
        :return:list,返回sheet页里的数据
        """
        sheet_list = []
        for sh in self.sw:
            if 'common' != sh.title.split('_')[0] and 'common' != sh.title.split('-')[0] and sh.title[0] is not '#' :
                isOK, result = self.readcase(sh)
                if isOK:
                    sheet_list.append(result)
        if sheet_list is None:
            return False, '用例集是空的，请检查用例'
        return True, sheet_list
 
 
    def readcase(self, sh):
        """
        组合sheet页的数据
        :param sh:
        :return: list,返回组合数据
        """
        if sh is None:
            print('sheet页为空')
        datas = list(sh.rows)
        if datas == []:
            return False, '用例[' + sh.title + ']里面是空的'
        title = [i.value for i in datas[0]]
        rows = []
        sh_dict = {}
        for i in datas[1:]:
            data = [v.value for v in i]
            row = dict(zip(title, data))
            try:
                if str(row['id'])[0] is not '#':
                    row['sheet'] = sh.title
                    rows.append(row)
            except KeyError:
                raise e
                rows.append(row)
            sh_dict[sh.title] = rows
        return True, sh_dict
 
 
    def get_common_case(self, case_name):
        """
        得到公共用例
        :param case_name:
        :return:
        """
        try:
            sh = self.sw.get_sheet_by_name(case_name)
        except KeyError:
            return False, '未找到公共用例[' + case_name + '],请检查用例'
        except DeprecationWarning:
            pass
        return self.readcase(sh)
 
 
 

import os
from configparser import ConfigParser
from common.getfiledir import CONFDIR
 
 
class Config(ConfigParser):
 
    def __init__(self):
        self.conf_name = os.path.join(CONFDIR, 'base.ini')
        super().__init__()
        super().read(self.conf_name, encoding='utf-8')
 
 
    def save_data(self, section, option, value):
        super().set(section=section, option=option, value=value)
        super().write(fp=open(self.conf_name, 'w'))
 

[base]
browser_type = chrome
# browser_type = IE
# browser_type = firefox
 
[LOG]
level = INFO
 

[email]
host = smtp.qq.com
port = 465
user = xxxxx@qq.com      
pwd = *********          
from_addr = xxxxx@qq.com 
to_addr = xxxxx@qq.com 

[Function]               
打开网页 = open_url
关闭浏览器 = close_browser
对话框上传文件 = upload_file
点击 = element_click
输入 = element_input
截图 = get_screenshot_as_file
寻找元素 = find_element
隐式等待 = web_implicitly_wait
等待元素可见 = web_element_wait
等待 = gotosleep
input上传文件 = upload_input_file
模拟按键上传文件 = upload_endkey_file
切换页面 = toggle_page
执行JS = execute_js

from common.getconf import Config
from common.getcase import ReadCase
from basefactory.browseroperator import BrowserOperator
from basefactory.webdriveroperator import WebdriverOperator

class Factory(object):
 
    def __init__(self):
        self.con = Config()
        self.con_fun = dict(self.con.items('Function'))
        """
        浏览器操作对象
        """
        self.browser_opr = BrowserOperator()
        """
        网页操作对象
        """
        self.webdriver_opr = None

self.con = Config()
self.con_fun = dict(self.con.items('Function'))

def init_webdriver_opr(self, driver):
    self.webdriver_opr = WebdriverOperator(driver)

def init_execute_case(self):
    print("----------初始化用例----------")
    xlsx = ReadCase()
    isOK, result = xlsx.readallcase()
    if not isOK:
        print(result)
        print("----------结束执行----------")
        exit()
    all_cases = result
    excu_cases = []
    for cases_dict in all_cases:
        for key, cases in cases_dict.items():
            isOK, result = self.init_common_case(cases)
            if isOK:
                cases_dict[key] = result
            else:
                cases_dict[key] = cases
            excu_cases.append(cases_dict)
            print("----------初始化用例完成----------")
    return excu_cases

def init_common_case(self, cases):
    """
    :param kwargs:
    :return:
    """
    cases_len = len(cases)
    index = 0
    for case in cases:
        if case['keyword'] == '调用用例':
            xlsx = ReadCase()
            try:
                case_name = case['locator']
            except KeyError:
                return False, '调用用例没提供用例名，请检查用例'
            isOK, result = xlsx.get_common_case(case_name)
            if isOK and type([]) == type(result):
                isOK, result_1 = self.init_common_case(result)     #递归检查公共用例里是否存在调用用例
            elif not isOK:
                return isOK, result
            list_rows = result[case_name]
            cases[index: index+1] = list_rows    #将公共用例插入到执行用例中去
        index += 1
    if cases_len == index:
        return False, ''
    return True, cases

fac = Factory()
isOK, result = fac.init_execute_case()
print(result)

def get_base_function(self, function_name):
    try:
        function = getattr(self.browser_opr, function_name)
    except Exception:
        try:
            function = getattr(self.webdriver_opr, function_name)
        except Exception:
            return False, '未找到注册方法[' + function_name + ']所对应的执行函数，请检查配置文件'
    return True, function

def execute_keyword(self, **kwargs):
    """
    工厂函数，用例执行方法的入口
    :param kwargs:
    :return:
    """
    try:
        keyword = kwargs['keyword']
        if keyword is None:
            return False, '没有keyword，请检查用例'
    except KeyError:
        return False, '没有keyword，请检查用例'
 
    _isbrowser = False
 
    try:
        function_name = self.con_fun[keyword]
    except KeyError:
        return False, '方法Key['+ keyword +']未注册，请检查用例'
 
    #获取基础类方法
    isOK, result = self.get_base_function(function_name)
    if isOK:
        function = result
    else:
        return isOK, result
 
    #执行基础方法，如打网点页、点击、定位、隐式等待 等
    isOK, result = function(**kwargs)
 
    #如果是打开网页，是浏览器初始化，需要将返回值传递给另一个基础类
    if '打开网页' == keyword and isOK:
        url = kwargs['locator']
        self.init_webdriver_opr(result)
        return isOK, '网页[' + url + ']打开成功'
    return isOK, result

try:
    keyword = kwargs['keyword']
    if keyword is None:
        return False, '没有keyword，请检查用例'
except KeyError:
    return False, '没有keyword，请检查用例'

try:
    function_name = self.con_fun[keyword]
except KeyError:
    return False, '方法Key['+ keyword +']未注册，请检查用例'

isOK, result = self.get_base_function(function_name)
if isOK:
    function = result
else:
    return isOK, result

#执行基础方法，如打网点页、点击、定位、隐式等待 等
isOK, result = function(**kwargs)

if '打开网页' == keyword and isOK:
    url = kwargs['locator']
    self.init_webdriver_opr(result)
    return isOK, '网页[' + url + ']打开成功'
 
 
最后我们返回执行结果
return isOK, result

from common.factory import Factory
 
 
fac = Factory()
 
isOK, result = fac.execute_keyword(keyword='打开网页', locator='http://www.baidu.com')
print(result)
isOK, result = fac.execute_keyword(keyword='隐式等待', time='30')
print(result)
isOK, result = fac.execute_keyword(keyword='输入', type='xpath', locator='//*[@id="kw"]',input='飞人乔丹')
print(result)
idOK, result = fac.execute_keyword(keyword='点击', type='xpath', locator='//*[@id="su"]')
print(result)

from common.factory import Factory
 
 
fac = Factory()
 
isOK, result = fac.init_execute_case()
 
for acases in result:
    for key, cases in acases.items():
        for case in cases:
            isOK, result = fac.execute_keyword(**case)
            print(result)

from common.getconf import Config
from common.getcase import ReadCase
from basefactory.browseroperator import BrowserOperator
from basefactory.webdriveroperator import WebdriverOperator
 
 
class Factory(object):
 
    def __init__(self):
        self.con = Config()
        self.con_fun = dict(self.con.items('Function'))
 
 
        """
        浏览器操作对象
        """
        self.browser_opr = BrowserOperator()
        """
        网页操作对象
        """
        self.webdriver_opr = None
 
 
    def init_webdriver_opr(self, driver):
        self.webdriver_opr = WebdriverOperator(driver)
 
 
    def get_base_function(self, function_name):
        try:
            function = getattr(self.browser_opr, function_name)
        except Exception:
            try:
                function = getattr(self.webdriver_opr, function_name)
            except Exception:
                return False, '未找到注册方法[' + function_name + ']所对应的执行函数，请检查配置文件'
        return True, function
 
    def execute_keyword(self, **kwargs):
        """
        工厂函数，用例执行方法的入口
        :param kwargs:
        :return:
        """
        try:
            keyword = kwargs['keyword']
            if keyword is None:
                return False, '没有keyword，请检查用例'
        except KeyError:
            return False, '没有keyword，请检查用例'
 
        _isbrowser = False
 
        try:
            function_name = self.con_fun[keyword]
        except KeyError:
            return False, '方法Key['+ keyword +']未注册，请检查用例'
 
        #获取基础类方法
        isOK, result = self.get_base_function(function_name)
        if isOK:
            function = result
        else:
            return isOK, result
 
        #执行基础方法，如打网点页、点击、定位、隐式等待 等
        isOK, result = function(**kwargs)
 
        #如果是打开网页，是浏览器初始化，需要将返回值传递给另一个基础类
        if '打开网页' == keyword and isOK:
            url = kwargs['locator']
            self.init_webdriver_opr(result)
            return isOK, '网页[' + url + ']打开成功'
        return isOK, result
 
 
    def init_common_case(self, cases):
        """
        :param kwargs:
        :return:
        """
        cases_len = len(cases)
        index = 0
        for case in cases:
            if case['keyword'] == '调用用例':
                xlsx = ReadCase()
                try:
                    case_name = case['locator']
                except KeyError:
                    return False, '调用用例没提供用例名，请检查用例'
                isOK, result = xlsx.get_common_case(case_name)
                if isOK and type([]) == type(result):
                    isOK, result_1 = self.init_common_case(result)     #递归检查公共用例里是否存在调用用例
                elif not isOK:
                    return isOK, result
                list_rows = result[case_name]
                cases[index: index+1] = list_rows    #将公共用例插入到执行用例中去
            index += 1
        if cases_len == index:
            return False, ''
        return True, cases
 
    # [{"a": [{"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}, {"A": 2}]},{"a": [5, 3, 2]}, {"a": [10, 4, 6]}]
 
 
    def init_execute_case(self):
        print("----------初始化用例----------")
        xlsx = ReadCase()
        isOK, result = xlsx.readallcase()
        if not isOK:
            print(result)
            print("----------结束执行----------")
            exit()
        all_cases = result
        excu_cases = []
        for cases_dict in all_cases:
            for key, cases in cases_dict.items():
                isOK, result = self.init_common_case(cases)
                if isOK:
                    cases_dict[key] = result
                else:
                    cases_dict[key] = cases
                excu_cases.append(cases_dict)
                print("----------初始化用例完成----------")
        return excu_cases
 
 
 

import unittest
from common.factory import Factory
from common.log import mylog
from library.ddt import ddt, data

@ddt
class Test_caserun(unittest.TestCase):
    fac = Factory()
    isOK, excu_cases = fac.init_execute_case()
 
    @data(*excu_cases)
    def test_run(self, acases):
        for key, cases in acases.items():
            mylog.info('\n----------用例【%s】开始----------' % cases[0].get('sheet'))
            print('\n')
            for case in cases:
                isOK, result = self.fac.execute_keyword(**case)
                if isOK:
                    print(result)
                    mylog.info(result)
                else:
                    mylog.error(result)
                    raise Exception(result)
            mylog.info('\n----------用例【%s】结束----------\n' % cases[0].get('sheet')).

for key, cases in acases.items():
    mylog.info('\n----------用例【%s】开始----------' % cases[0].get('sheet'))
    print('\n')
    for case in cases:
        isOK, result = self.fac.execute_keyword(**case)
        if isOK:
            print(result)
            mylog.info(result)
        else:
            mylog.error(result)
            raise Exception(result)
    mylog.info('\n----------用例【%s】结束----------\n' % cases[0].get('sheet'))

import os
import unittest
from library.HTMLTestRunnerNew import HTMLTestRunner
from common.getfiledir import CASEDIR, REPORTDIR

class Test_run(object):
 
    def __init__(self):
        self.suit = unittest.TestSuite()
        self.load = unittest.TestLoader()
        self.suit.addTest(self.load.discover(CASEDIR))
        self.runner = HTMLTestRunner(
            stream=open(os.path.join(REPORTDIR, 'report.html'), 'wb'),
            title='魂尾自动化工厂',
            description='唯a饭木领',
            tester='HUNWEI'
        )
 
    def excute(self):
        self.runner.run(self.suit)
 
 
 
 
 
if __name__=="__main__":
    test_run = Test_run()
    test_run.excute()

import logging
import os
from logging.handlers import TimedRotatingFileHandler
from common.getconf import Config
from common.getfiledir import LOGDIR
 
class Handlogging():
 
    @staticmethod
    def emplorlog():
        conf = Config()
        # set format
        formatter = logging.Formatter("%(asctime)s - %(name)s-%(levelname)s %(message)s")
 
        # create log set getlog level
        mylog = logging.getLogger('HunWei')
        mylog.setLevel(conf.get('LOG', 'level'))
 
        # create outputsteam set level
        sh = logging.StreamHandler()
        sh.setLevel(conf.get('LOG', 'level'))
        sh.setFormatter(formatter)
        mylog.addHandler(sh)
 
        #create file set level
        #fh = logging.FileHandler(os.path.join(LOGDIR,'test.log'), encoding='utf-8')
 
        log_path = os.path.join(LOGDIR, 'test')
        # interval 滚动周期，
        # when="MIDNIGHT", interval=1 表示每天0点为更新点，每天生成一个文件
        # backupCount  表示日志保存个数
        fh = TimedRotatingFileHandler(
            filename=log_path, when="D", backupCount=15, encoding='utf-8'
        )
        fh.suffix = "%Y-%m-%d.log"
        fh.setLevel(conf.get('LOG', 'level'))
        fh.setFormatter(formatter)
        mylog.addHandler(fh)
        return mylog
 
 
mylog = Handlogging.emplorlog()

import smtplib
import os
from common.getconf import Config
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from common.getfiledir import REPORTDIR
 
 
 
class Opr_email(object):
 
    def __init__(self):
        """
        初始化文件路径与相关配置
        """
        self.conf = Config()
        all_path = []
        for maindir, subdir, file_list in os.walk(REPORTDIR):
            pass
        for filename in file_list:
            all_path.append(os.path.join(REPORTDIR, filename))
        self.filename = all_path[0]
        self.host = self.conf.get('email', 'host')
        self.port = self.conf.get('email', 'port')
        self.user = self.conf.get('email', 'user')
        self.pwd = self.conf.get('email', 'pwd')
        self.from_addr = self.conf.get('email', 'from_addr')
        self.to_addr = self.conf.get('email', 'to_addr')
 
 
 
    def get_email_host_smtp(self):
        """
        连接stmp服务器
        :return:
        """
        self.smtp = smtplib.SMTP_SSL(host=self.host, port=self.port)
        self.smtp.login(user=self.user, password=self.pwd)
 
 
    def made_msg(self):
        """
        构建一封邮件
        :return:
        """
        self.msg = MIMEMultipart()
 
        with open(self.filename, 'rb') as f:
            content = f.read()
        # 创建文本内容
        text_msg = MIMEText(content, _subtype='html', _charset='utf8')
        # 添加到多组件的邮件中
        self.msg.attach(text_msg)
        # 创建邮件的附件
        report_file = MIMEApplication(content)
        report_file.add_header('Content-Disposition', 'attachment', filename=str.split(self.filename, '\\').pop())
 
        self.msg.attach(report_file)
        # 主题
        self.msg['subject'] = '自动化测试报告'
        # 发件人
        self.msg['From'] = self.from_addr
        # 收件人
        self.msg['To'] = self.to_addr
 
 
    def send_email(self):
        """
        发送邮件
        :return:
        """
        self.get_email_host_smtp()
        self.made_msg()
        self.smtp.send_message(self.msg, from_addr=self.from_addr, to_addrs=self.to_addr)