Python3+selenium2+subline Text3 自动化测试知识点+登录案例

最新推荐文章于 2023-12-11 14:15:00 发布

原创最新推荐文章于 2023-12-11 14:15:00 发布 · 650 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#selenium #python #subline Text3

selenium 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了使用Python3、Selenium和Sublime Text3进行自动化测试的知识点，包括环境搭建、前端技术如HTML、JS、XML和CSS的简介、页面元素定位及操作、鼠标和键盘事件、Alert对象与窗口管理、脚本等待方法、测试用例设计和模块化。特别展示了模拟麦子学院网站登录的完整过程，涉及测试用例数据分离、从文件导入数据、登录错误处理和测试结果分析与报告。最后，分享了如何读取和保存测试结果至TXT或Excel文件。

环境搭建
请参考https://blog.youkuaiyun.com/qq_16980433/article/details/86158381
使用selenium打开浏览器
如图：
前端技术介绍
html：网页的基础，是一种标记语言，显示数据
JS：前端脚本语言，解释型语言，在页面中添加交互行为
xml：扩展标记语言，用来传输和存储数据
css：层叠样式表，用来表现HTML和XML等文件样式

页面元素定位及操作

元素名称	webdriver API	说明
id	`find_element_by_id()`	元素的id值
name	`find_element_by_name()`	元素的名称
class name	`find_element_by_class_name()`	元素的类名
tag name	`find_element_by_tag_name()`	页面html文档下的各种标签
link text	`find_element_by_link_text()`	用来定位文本链接
partial link text	`find_element_by_partial_link_text()`	取文本一部分进行定位
xpath	`find_element_by_xpath()`
css selector	`find_element_by_css_selector()`

操作方法	说明	案例
clear	清除元素内容	`find_element_by_id('kw').clear()`
send_keys	模拟按键输入	`find_element_by_id('kw').send_keys('selenium')`
click	点击	`find_element_by_id('su').click()`
submit	提交表单	`find_element_by_id('su').submit()`

xpath定位
xpath用于在XML文档中通过元素和属性进行导航
xpath节点类型：元素，属性，文本，命名空间，指令处理，注释及文档
特点：笨重，定位元素慢，语法长，不稳定，但可以解决80%的定位问题

表达式	结果
`/xxx`	选取根节点xxx
`/xxx/yyy`	根据绝对路径选取元素
`//xxx`	整个文档扫描，找到所有xxx元素
`//xxx/yyy`	所有父元素为xxx的yyy元素
`.`	选取当前节点的父元素节点
`..`	选取父元素地址
`//xxx[@id]`	选取所有xxx元素中有id属性的元素
`//xxx[@id=yyy]`	选取所有xxx元素中id属性为yyy的元素
`//*[count(xxx)=2]`	统计xxx元素个数=2的节点
`//*[local-name()='xxx']`	找到所有tag为 xxx的元素
`//*[starts-with(local-name(),'xxx')]`	找到所有tag以 xxx开头的元素
`//*[contains(local-name(),'xxx')]`	找到所有tag包含 xxx的元素
`//*[string-length(local-name())=3]`	找到所有tag长度为 3元素
`//xxx\|//yyy`	多个路径查找

css定位
css定位是使用选择器来为页面元素绑定属性。
特点：轻巧，定位速度快，语法简洁，稳准狠。

属性	操作方式	案例
通过class属性定位	.	`find_element_by_css_selector(".u-btn").click()`
通过id属性定位	#	`find_element_by_css_selector(".loginName").click()`
通过其他属性定位	[ ]	`find_element_by_css_selector("[type=submit]").click()`

鼠标和键盘事件
鼠标事件：
from selenium.webdriver.common.action_chains import ActionChains

ActionChains(driver).move_to_element(ele).perform()
# 模拟鼠标行为，将鼠标拖至元素处

表达式	说明
click	左击事件
context_click	右击事件
double_click	双击事件
drag_and_drop	拖动
move_to_element()	鼠标停在一个元素上
click_and_hold	按下鼠标左键在一个元素上

键盘事件：send_keys()
from selenium.webdriver.common.keys import Keys

表达式	说明
send_keys(Keys.BACK_SPACE)	退格键
send_keys(Keys.CONTRL,‘a’)	全选
send_keys(Keys.CONTRL,‘c’)	赋值
send_keys(Keys.CONTRL,‘v’)	粘贴
send_keys(Keys.CONTRL,‘x’)	剪切
send_keys(Keys.ENTER)	回车

Alter对象与多窗口管理
Alter对象

处理方法	说明	案例
switch_to_alert()	切换到Alter，返回一个alter对象	alter = driver.switch_to_alert()
accept	确认，对alter对象进行处理	alter.accept()
dismiss	取消，对alter对象进行处理	alter.dismiss()
send_keys()	有输入框才能使用，否则报错

浏览器多个窗口管理

driver.current_window_handle：显示当前句柄
driver.window_handles：显示所有的句柄
driver.switch_to_window(driver.window_handles[0])：切换句柄

脚本中等待方法
等待是为了使脚本执行更加稳定

等待方式	说明	所属模块
强制等待 `sleep()`	设置固定休眠时间	`import time`
显示等待 `WebDriverWait()`	在设置时间内，默认每隔一段时间检测一次当前页面元素是否存在，如果超过设置时间检测不到则抛出异常。默认检测频率为0.5s，默认抛出异常为：NoSuchElementException	`from selenium.webdriver.support.ui import WebDriverWait`
隐式等待 `implicitly_wait()`	智能等待，隐的等待一个元素被发现，或一个命令完成。如果超出了设置时间的则抛出异常。	`from selenium.webdriver.support.ui import WebDriverWait`

测试用例设计（测试脚本）
优点：独立，可以单独执行
缺点：灵活性差，不具备大规模测试条件，维护成本大
案例：模拟麦子学院网站登录（最原始登录脚本）

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    from selenium import webdriver
    
    def login_test():
        driver = webdriver.Firefox() # 启动浏览器
        driver.get('http://www.maiziedu.com/') # 打开URL地址
        driver.maximize_window() # 窗口最大化
        
        driver.find_element_by_link_text('登录').click() # 点击登录入口
        driver.find_element_by_id('id_account_l').send_keys('17625648494') # 输入用户名
        driver.find_element_by_id('id_password_l').send_keys('cptbtptp123') # 输入密码
        driver.find_element_by_id('login_btn').click() # 点击登录按钮
        
    if __name__ == '__main__':
        login_test()

测试用例模块化
将脚本中每一个功能都封装成一个函数
功能模块
打开浏览器 openBrower
加载网址 loadUrl
查找元素 findElement
输入数据 sendVals
检验结果 checkResult
案例：模拟麦子学院网站登录（测试用例模块化后的脚本）

功能	模块
打开浏览器	`openBrower`
加载网址	`loadUrl`
查找元素	`findElement`
输入数据	`sendVals`
检验结果	`checkResult`

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # 测试用例模块化+增加时间等待
    
    from selenium import webdriver
    import time
    from selenium.webdriver.support.ui import WebDriverWait
    
    url = 'http://www.maiziedu.com/'
    login_text = '登录'
    uname = '17625648494'
    pwd = 'cptbtptp123'

    def get_ele_times(driver, times, func): # 获取元素时间(实例，超时时间，条件)
        return WebDriverWait(driver, times).until(func)
        
    def openBrower():# 定义函数，打开浏览器
        webdriver_handle = webdriver.Firefox() # 启动火狐
        return webdriver_handle # 返回浏览器页面
        
    def openUrl(handle, url): # 定义函数，加载网址(实例，url地址)
        handle.get(url) # 输入URL地址
        handle.maximize_window() # 窗口最大化
        
    def findElement(d, arg): # 定义函数，查找元素(实例，字典参数arg)
        '''
        arg=['text_id':''，'userid':''，'pwdid':''，'loginid':''] 
        
        '''
        if 'text_id' in arg: # 判断页面中是否有登录入口，即字典arg中是否存在text_id键值
            ele_login = get_ele_times(d, 10, lambda d: d.find_element_by_link_text(arg['text_id'])) # 如果有，获取登录入口元素
            ele_login.click() # 点击登录入口
        useEle = d.find_element_by_id(arg['userid']) # 用户名
        pwdEle = d.find_element_by_id(arg['pwdid'])  # 密码
        loginEle = d.find_element_by_id(arg['loginid']) # 登录按钮
        return useEle, pwdEle, loginEle
        
    def sendVals(eletuple, arg): # 定义函数，输入数值(元组eletuple，字典arg)
        '''
        eletuple = (useEle,pwdEle,loginEle) 元组中存放页面中获取的元素
        arg = ['uname':'uname','pwd':'pwd'] 字典中存放需要输入的用户数据
        
        '''
        listkey = ['uname', 'pwd'] # 定义列表，存放uname,pwd对应 arg 中的键
        i = 0
        for key in listkey: # 遍历listkey列表
            eletuple[i].send_keys('') 
            eletuple[i].clear() 
            eletuple[i].send_keys(arg[key]) # 输入用户名 arg['uname'] 和密码 arg['pwd']
            i+=1
        eletuple[2].click() # 最后单击登录按钮
        
    def checkResult(d, text): # 定义函数，验证结果(实例，登录错误信息)
        try:
            d.find_element_by_link_text(text) # 获取错误信息元素
            print ("Uname And Pwd Error!") # 如果获取到错误信息，则登录失败
        except:
            print ("Uname And Pwd Right!") # 登录成功
            
    def login_test():
        d = openBrower() # 打开浏览器，即 实例 d = 实例 webdriver_handle
        openUrl(d, url) # 加载URL
        ele_dict = {'text_id':login_text,'userid':'id_account_l','pwdid':'id_password_l','loginid':'login_btn'}
        # 定义元素字典，包含登录入口，用户名，密码，登录按钮
        ele_tuple = findElement(d, ele_dict)
        # 定义元素元组，通过findElement()函数返回useEle, pwdEle, loginEle三个值放入ele_tuple元组
        account_dict = {'uname':uname,'pwd':pwd} 
        # 定义数据字典，包含用户名和密码具体数值
        sendVals(ele_tuple, account_dict)  
        # 传入元素元组和数据字典
        checkResult(d,'该账号格式不正确') 
        # 检测结果，只验证了一种错误情况，后续添加多种错误
        
    if __name__ == '__main__':
        login_test()

测试用例数据分离
将代码中的数据剥离，设计合理的数据结构
数据剥离

操作数据
openUrl http://www.maiziedu.com/
findElement text_id,userid,pwdid,loginid...
sendVals uname,pwd
数据结构设计：字典形式

key value
url 打开地址
text_id 登录入口元素
userid / pwdid / loginid 输入账号元素，用户名/密码/登录按钮
uname / pwd 输入账号信息，用户名/密码
errorid 检查错误条件
案例：模拟麦子学院网站登录（测试用例数据分离）

操作	数据
openUrl	`http://www.maiziedu.com/`
findElement	`text_id,userid,pwdid,loginid...`
sendVals	`uname,pwd`

key	value
url	打开地址
text_id	登录入口元素
userid / pwdid / loginid	输入账号元素，用户名/密码/登录按钮
uname / pwd	输入账号信息，用户名/密码
errorid	检查错误条件

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # 测试用例数据分离，数据全部放入字典

    from selenium import webdriver
    import time
    from selenium.webdriver.support.ui import WebDriverWait

    def get_ele_times(driver, times, func): 
        return WebDriverWait(driver, times).until(func)
        
    def openBrower(): 
        webdriver_handle = webdriver.Firefox() 
        return webdriver_handle 
        
    def openUrl(handle, url): 
        handle.get(url) 
        handle.maximize_window() 
        
    def findElement(d, arg): 
        if 'text_id' in arg: 
            ele_login = get_ele_times(d, 10, lambda d: d.find_element_by_link_text(arg['text_id'])) 
            ele_login.click()
        useEle = d.find_element_by_id(arg['userid']) # 用户名
        pwdEle = d.find_element_by_id(arg['pwdid'])  # 密码
        loginEle = d.find_element_by_id(arg['loginid']) # 登录按钮
        return useEle, pwdEle, loginEle
        
    def sendVals(eletuple, arg): 
        listkey = ['uname', 'pwd'] 
        i = 0
        for key in listkey:
            eletuple[i].send_keys('')
            eletuple[i].clear()
            eletuple[i].send_keys(arg[key]) 
            i+=1
        eletuple[2].click() 
        
    def checkResult(d, err_text): # 定义函数，验证结果(实例，错误文本信息)
        try:
            d.find_element_by_link_text(err_text) # 根据错误信息文本获取错误元素
            print ("Uname And Pwd Error!")
        except:
            print ("Uname And Pwd Right!")
            
    def login_test(ele_dict,user_list):
        d = openBrower() 
        openUrl(d, ele_dict['url']) # 从元素字典 ele_dict 传入url
        ele_tuple = findElement(d, ele_dict) 
        for arg in user_list: # 增加 user_list 遍历，便于后续测试多个用户登录
            sendVals(ele_tuple, arg) # 元素元组和数据字典
            checkResult(d,ele_dict['errorid']) # 从元素字典 ele_dict 传入出错信息文本

    if __name__ == '__main__':
    
        url = 'http://www.maiziedu.com/'
        login_text = '登录'
        uname = '17625648494'
        pwd = 'cptbtptp123'
        
        ele_dict = {'url':url,'text_id':login_text,'userid':'id_account_l','pwdid':'id_password_l','loginid':'login_btn','uname':uname,'pwd':pwd,'errorid':'该账号格式不正确'}
        # 定义元素字典，将 url和 errorid也加入字典中
        user_list = [{'uname':'uname','pwd':'pwd'}]
        # 定义用户信息列表，列表值是uname和pwd组成，内嵌字典，则可做成多个用户登录
        
        login_test(ele_dict,user_list)
        # 增加了两个参数，用于传入元素信息和用户信息

测试用例从文件导入数据
将测试用例中分离的数据单独放入文件中
新建webinfo.txt文件，放入元素信息数据
新建userinfo.txt文件，放入用户名和密码
设计数据读取模块login_data.py，从文件txt中读取测试数据，多个用户登录系统时，存在不同错误情况，还需要做错误分析，通过id定位错误信息errorid = login-form-tips不再用错误文本信息获取错误元素

案例：模拟麦子学院网站登录（测试用例从文件导入数据+单用户登录+登录错误处理）

webinfo.txt

url=http://www.maiziedu.com/
text_id=登录
userid=id_account_l
pwdid=id_password_l
loginid=login_btn
errorid=login-form-tips

userinfo.txt

uname=17625648494;pwd=cptbtptp

login_data.py

    #!/usr/bin/env python
    # -*- coding: utf-8-sig -*-
    # 用于封装获取 webinfo 和 userinfo 信息的函数

    import codecs

    def get_webinfo(path): # 定义接口，获取 webinfo 信息
        web_info = {} # 定义字典
        config = codecs.open(path, 'r', 'utf-8-sig') # 打开文件(路径，只读模式，编码格式)
        for line in config: # 遍历文件内容
            result = [ele.strip() for ele in line.split('=')] # 通过"="分割，并去除空格
            web_info.update(dict([result])) # 将遍历的数据更新到web_info{}字典中
        return web_info

    def get_userinfo(path): # 定义接口，获取 userinfo 信息
        user_info = [] # 定义列表，放入多个用户
        config = codecs.open(path, 'r', 'utf-8')
        for line in config:
            user_dict = {} # 定义字典，放入 uname 和 pwd
            result = [ele.strip() for ele in line.split(';')] # 通过";"分割，并去除空格
            for r in result: # 遍历文件内容
                account = [ele.strip() for ele in r.split('=')] # 通过"="分割，并去除空格
                user_dict.update(dict([account])) # 将遍历的数据更新到user_dict{}字典中，即 uname 和 pwd
            user_info.append(user_dict) # 将 user_dict 字典中的多个用户更新到 user_info 列表中
        return user_info

    if __name__ == '__main__': # 本地测试
    
        webinfo = get_webinfo(r'D:\Python\Test_Login\webinfo.txt')
        for key in webinfo: # webinfo = {}
            print(key, webinfo[key]) # 打印 键和值
        userinfo = get_userinfo(r'D:\Python\Test_Login\userinfo.txt')
        print(userinfo)
        for l in userinfo: # userinfo = []
            print(l)

login_moudle.py

    #!/usr/bin/env python
    # -*- coding: utf-8-sig -*-
    # 测试用例从文件导入数据+登录错误处理

    from selenium import webdriver
    import time
    from selenium.webdriver.support.ui import WebDriverWait
    from login_data import get_webinfo,get_userinfo # 导入同目录下的模块
    
    def get_ele_times(driver, times, func): 
        return WebDriverWait(driver, times).until(func)
        
    def openBrower(): 
        webdriver_handle = webdriver.Firefox() 
        return webdriver_handle 
        
    def openUrl(handle, url): 
        handle.get(url) 
        handle.maximize_window() 
        
    def findElement(d, arg): 
        if 'text_id' in arg: 
            ele_login = get_ele_times(d, 10, lambda d: d.find_element_by_link_text(arg['text_id'])) 
            ele_login.click()
        useEle = d.find_element_by_id(arg['userid']) # 用户名
        pwdEle = d.find_element_by_id(arg['pwdid'])  # 密码
        loginEle = d.find_element_by_id(arg['loginid']) # 登录按钮
        return useEle, pwdEle, loginEle
        
    def sendVals(eletuple, arg): 
        listkey = ['uname', 'pwd'] 
        i = 0
        for key in listkey:
            eletuple[i].send_keys('')
            eletuple[i].clear()
            eletuple[i].send_keys(arg[key]) 
            i+=1
        eletuple[2].click() 
        
    def checkResult(d, err_id): # 定义函数，验证结果(实例，登录错误id)
        try:
            err = d.find_element_by_id(err_id) # 通过id 获取登录错误元素
            print ("Account And Pwd Error!" + err.text) # 打印出登录错误文本信息
        except:
            print ("Account And Pwd Right!")
            
    def login_test(ele_dict,user_list): # 传入参数元素字典，用户列表
        d = openBrower() 
        openUrl(d, ele_dict['url']) 
        ele_tuple = findElement(d, ele_dict) # 定义元组，传入元素字典
        for arg in user_list: # 遍历用户列表
            sendVals(ele_tuple, arg) # 传入元素元组和数据字典
            checkResult(d,ele_dict['errorid']) # 检测结果，根据id获取错误元素
            
    if __name__ == '__main__':
    
        ele_dict = get_webinfo(r'D:\Python\Test_Login\webinfo.txt')
        print(ele_dict) # 元素字典
        user_list = get_userinfo(r'D:\Python\Test_Login\userinfo.txt')
        print(user_list) # 用户列表
        
        login_test(ele_dict,user_list)

测试结果分析与测试报告
多个用户登录得到不同的登陆结果，将测试结果保存到文件，便于做测试结果分析
设计日志模块log_data.py，增加日志接口 Loginfo
两种方式读取数据和保存测试结果：
（1）使用 txt 读取用户数据，测试结果保存到 txt 文件
（2）使用 Excel 读取用户数据，测试结果保存到 Excel 文件。
用到excel，需要安装 xlrd 和 xlsxwriter 两个模块
xlrd 读取数据 pip3 install xlrd
xlsxwriter 写入数据 pip3 install xlsxwriter

案例：模拟麦子学院网站登录（增加日志接口+多用户登录+退出+从txt读取用户数据+测试结果保存到txt文件+从Excel读取用户数据+测试结果保存到excel文件）

webinfo.txt

url=http://www.maiziedu.com/
text_id=登录
userid=id_account_l
pwdid=id_password_l
loginid=login_btn
errorid=login-form-tips
logout=退出

userinfo.txt

uname=17625648494;pwd=cptbtptp123
uname= ;pwd=cptbtptp123
uname=17625648494;pwd=
uname=176;pwd=cptbtptp123
uname=17625648494;pwd=cpt
uname=176;pwd=298

userinfo.xls
如图：

log_data.py

    #!/usr/bin/env python
    #coding:utf-8
    # 日志模块，增加日志接口，生成两种文档的日志报告，根据实际需要酌情选择
    
    import time
    import xlsxwriter # 导入excel写入数据模块
    
    # 生成txt日志报告
    class Loginfo(object): # 定义日志信息类
        def __init__(self, path = '', mode = 'w'): # 初始化(实例，打开日志文件，只写模式)路径默认为当前目录
            fname = path + time.strftime('%Y-%m-%d', time.gmtime())# 文件名，当前时间转化成年月日格式
            self.log = open(path + fname + '.txt', mode) # 创建txt日志文件
        def log_init(self, sheetname, *title): # 什么也不做，占位用的
            pass
        def log_write(self, msg): # 定义方法，写日志，给用户的接口
            self.log.write(msg)
        def log_close(self): # 定义方法，关闭日志，给用户的接口
            self.log.close()
           
    # 生成xls日志报告
    class Xlloginfo(object):
        def __init__(self, path=''): # 初始化(实例，打开日志文件)
            fname = path + time.strftime('%Y-%m-%d', time.gmtime()) # 文件名
            self.row = 0 # 实例化，默认从0行开始写
            self.xl = xlsxwriter.Workbook(path + fname + '.xls') # 创建xls日志文件
            self.style = self.xl.add_format({'bg_color':'red'}) # 添加背景色
        def xl_write(self, *args): # 定义内部方法，写入数据
            col = 0 # 从0列开始写
            style = '' # 样式为无
            if 'Error' in args: # 判断写入的数据中是否存在'Error'
                style = self.style # 存在的话，设置样式
            for val in args: # 遍历写入的数据
                self.sheet.write_string(self.row, col, val, style)
                col += 1
            self.row += 1
        def log_init(self, sheetname, *title): # 定义外部方法，初始化(实例，表单名，表单标题) 给用户的接口
            self.sheet = self.xl.add_worksheet(sheetname) # 表单名
            self.sheet.set_column('A:E', 30) # 表单格式
            self.xl_write(*title) # 表单标题
        def log_Write(self, *args): # 定义外部方法，写入数据，给用户的接口
            self.xl_write(*args)
        def log_close(self): # 定义外部方法，关闭日志，给用户的接口
            self.xl.close()

    if __name__ == '__main__': #本地测试日志文件是否添加成功 
        log = Loginfo()
        log.log_write('日志测试')
        log.log_close() 
         
        xinfo = Xlloginfo()
        xinfo.log_init('test', 'uname', 'pwd', 'result', 'info') # 初始化表单
        xinfo.log_Write('123', '123', 'Error', 'error') # 写入一行数据
        xinfo.log_close()

login_data.py

    #!/usr/bin/env python
    # -*- coding: utf-8-sig -*-
    # 用于封装获取 webinfo 和 userinfo 信息的函数
    # 增加 excel文件读取

    import codecs
    import xlrd # 导入excel读取数据模块

    def get_webinfo(path): 
        web_info = {} 
        config = codecs.open(path, 'r', 'utf-8-sig') 
        for line in config: 
            result = [ele.strip() for ele in line.split('=')] 
            web_info.update(dict([result])) 
        return web_info
        
    def get_userinfo(path):
        user_info = [] 
        config = codecs.open(path, 'r', 'utf-8')
        for line in config:
            user_dict = {}
            result = [ele.strip() for ele in line.split(';')] 
            for r in result:
                account = [ele.strip() for ele in r.split('=')]
                user_dict.update(dict([account]))
            user_info.append(user_dict)
        return user_info
        
    class XlUserinfo(object): # 定义类
        def __init__(self, path=''): # 初始化(实例，路径)
            self.xl = xlrd.open_workbook(path) # 打开xls文件
        def floattostr(self, val): # 定义方法，xls文件中浮点型数值转化为int型数值
            if isinstance(val, float):
                val = str(int(val))
            return val
        def get_sheet_info(self): # 定义方法，获取数据表中的所有数据
            listkey = ['uname', 'pwd'] # 定义列表
            infolist = [] # 定义列表
            for row in range(1, self.sheet.nrows): # sheet.nrows 行数，从第二行开始遍历用户名和密码
                info = [self.floattostr(val) for val in self.sheet.row_values(row)] # sheet.row_values() 行值
                tmp = zip(listkey, info) # dict(tmp) = {'uname':'','pwd':''}
                infolist.append(dict(tmp))
            return infolist
        def get_sheetinfo_by_name(self, name): # 根据名字获取表格
            self.sheet = self.xl.sheet_by_name(name)
            return self.get_sheet_info()
        def get_sheetinfo_by_index(self, index): # 根据索引获取表格
            self.sheet = self.xl.sheet_by_index(index)
            return self.get_sheet_info()
            
    if __name__ == '__main__': # 此处主函数可用于本地测试
        webinfo = get_webinfo(r'D:\Python\Test_Login\webinfo.txt')
        for key in webinfo:
            print(key, webinfo[key])
        userinfo = get_userinfo(r'D:\Python\Test_Login\userinfo.txt')
        for l in userinfo:
            print(l)
        print(userinfo)
        
        xinfo = XlUserinfo(r'D:\Python\Test_Login\userinfo.xls')
        info = xinfo.get_sheetinfo_by_index(0) # 根据索引获取表格
        print(info)
        info = xinfo.get_sheetinfo_by_name('Sheet1') # 根据名字获取表格
        print(info)

login_module.py

    #!/usr/bin/env python
    # -*- coding: utf-8-sig -*-
    # 测试用例多用户测试+用户退出+读取excel用户数据+生成excel测试日志报告
    
    from selenium import webdriver
    import time
    from selenium.webdriver.support.ui import WebDriverWait
    from login_data import get_webinfo,get_userinfo,XlUserinfo # 导入同目录下的用户数据模块
    from log_data import Loginfo,Xlloginfo # 导入同目录下的日志模块

    def get_ele_times(driver, times, func): 
        return WebDriverWait(driver, times).until(func)
        
    def openBrower(): 
        webdriver_handle = webdriver.Firefox() 
        return webdriver_handle 
        
    def openUrl(handle, url): 
        handle.get(url) 
        handle.maximize_window() 
        
    def findElement(d, arg): 
        if 'text_id' in arg: 
            ele_login = get_ele_times(d, 10, lambda d: d.find_element_by_link_text(arg['text_id'])) # 登录入口
            ele_login.click()
        useEle = d.find_element_by_id(arg['userid']) # 用户名
        pwdEle = d.find_element_by_id(arg['pwdid'])  # 密码
        loginEle = d.find_element_by_id(arg['loginid']) # 登录按钮
        return useEle, pwdEle, loginEle
        
    def sendVals(eletuple, arg): 
        listkey = ['uname', 'pwd'] 
        i = 0
        for key in listkey:
            eletuple[i].send_keys('')
            eletuple[i].clear()
            eletuple[i].send_keys(arg[key]) 
            i+=1
        eletuple[2].click() 
        
    def checkResult(d, err_id, arg, log): # 定义函数，验证结果(实例，错误id，arg,log)err_id表示登录出错信息的id，arg表示用户名和密码，log表示日志信息
        result = False
        try:
            err = d.find_element_by_id(err_id) # 获取错误提示的元素
            print ("Account And Pwd Error!" + err.text)
            # 写入txt日志文件
            # msg = 'uname=%s pwd=%s:error:%s\n'%(arg['uname'], arg['pwd'], err.text) # 获取错误的用户名和密码，以及登录出错后的提示
            # log.log_write(msg) # 写入日志
            # 写入excel日志文件
            log.log_Write(arg['uname'], arg['pwd'], 'Error', err.text) # 写入日志
        except:
            print ("Account And Pwd Right!")
            # 写入txt日志文件
            # msg = 'uname=%s pwd=%s:pass\n'%(arg['uname'],arg['pwd']) # 获取正确的用户名和密码
            # log.log_write(msg) # 写入日志
            # 写入excel日志文件
            log.log_Write(arg['uname'], arg['pwd'], 'Pass') # 写入日志
            result = True # 登录成功，返回True
        return result
        
    def logout(d, ele_dict): # 定义函数，退出元素从ele_dict字典传入
        d.find_element_by_link_text(ele_dict['logout']).click() # 点击退出连接
        
    def login_test(ele_dict,user_list):
        d = openBrower() 
        #log = Loginfo()
        log = Xlloginfo()
        log.log_init('LoginTest', 'uname', 'pwd', 'result', 'info') 
        # 调用Xlloginfo()之后需要做一个初始化，定义出数据表名，用户名，密码，结果，提示信息
        openUrl(d, ele_dict['url']) # 传入URL
        ele_tuple = findElement(d, ele_dict) # 定义元组，传入元素字典
        for arg in user_list:
            sendVals(ele_tuple, arg) # 传入元组和数据
            result = checkResult(d,ele_dict['errorid'],arg,log) 
            # 检测结果
            if result: # 判断登录成功还是失败
                # logout
                logout(d, ele_dict)
                # login
                ele_tuple = findElement(d, ele_dict)
        log.log_close()
        
    if __name__ == '__main__':
    
       ele_dict = get_webinfo(r'D:\Python\Test_Login\webinfo.txt')
       print(ele_dict)
       #user_list = get_userinfo(r'D:\Python\Test_Login\userinfo.txt')
       
       xinfo = XlUserinfo(r'D:\Python\Test_Login\userinfo.xls')
       #user_list = xinfo.get_sheetinfo_by_index(0)
       user_list = xinfo.get_sheetinfo_by_name('Sheet1')
       print(user_list)
       
       login_test(ele_dict,user_list)