python+selenium日志输出

基本介绍

一、基础介绍

 核心概念：test case, testsuite, TestLoder,TextTestRunner,TextTestResult, test fixture

TestCase（测试用例）: 所有测试用例的基类，它是软件 测试中最基本的组成单元。

 一个test case就是一个测试用例，是一个完整的测试流程，包括测试前环境的搭建setUp，执行测试代码(run)，以及测试后环境的还原(tearDown)。测试用例是一个完整的测试单元，可以对某一问题进行验证。

TestSuite（测试套件）:多个测试用例test case集合就是TestSuite，TestSuite可以嵌套TestSuite

TestLoder：是用来加载 TestCase到TestSuite中，其中有几个loadTestsFrom_()方法，就是从各个地方寻找TestCase，创建他们的实例，然后add到TestSuite中，再返回一个TestSuite实例

TextTestRunner：是来执行测试用例的，其中的run（test）会执行TestSuite/TestCase中的run(result)方法。

 TextTestResult：测试结果会保存到TextTestResult实例中，包括运行了多少用例，成功与失败多少等信息

TestFixture:又叫测试脚手，测试代码的运行环境，指测试准备前和执行后要做的工作，包括setUp和tearDown方法

二、测试流程

1）unittest是Python自带的单元测试框架，我们可以用其来作为我们自动化测试框架的用例组织执行框架。

2）unittest的流程：写好TestCase，然后由TestLoader加载TestCase到TestSuite，然后由 TextTestRunner来运行TestSuite，运行的结果保存在TextTestResult中，我们通过命令行或者unittest.main()执行时，main会调用TextTestRunner中的run来执行，或者我们可以直接通过 TextTestRunner来执行用例。

3）一个class继承unittest.TestCase即是一个TestCase，其中以 test 开头的方法在load时被加载为一个真正的TestCase。

4）verbosity参数可以控制执行结果的输出，0 是简单报告、1 是一般报告、2 是详细报告。

5）可以通过addTest和addTests向suite中添加case或suite，可以用TestLoader的loadTestsFrom__()方法。

6）用 setUp()、tearDown()、setUpClass()以及 tearDownClass()可以在用例执行前布置环境，以及在用例执行后清理环境

7）我们可以通过skip，skipIf，skipUnless装饰器跳过某个case，或者用TestCase.skipTest方法。

8）参数中加stream，可以将报告输出到文件：可以用TextTestRunner输出txt报告，以及可以用HTMLTestRunner输出html报告。

三、unittest模块的各个属性说明

1、unittest的属性如下：

[‘BaseTestSuite’, ‘FunctionTestCase’, ‘SkipTest’, ‘TestCase’, ‘TestLoader’, ‘TestProgram’, ‘TestResult’, ‘TestSuite’, ‘TextTestResult’, ‘TextTestRunner’, ‘_TextTestResult’, ‘all’, ‘builtins’, ‘doc’, ‘file’, ‘name’, ‘package’, ‘path’, ‘__unittest’, ‘case’, ‘defaultTestLoader’, ‘expectedFailure’, ‘findTestCases’, ‘getTestCaseNames’, ‘installHandler’, ‘loader’, ‘main’, ‘makeSuite’, ‘registerResult’, ‘removeHandler’, ‘removeResult’, ‘result’, ‘runner’, ‘signals’, ‘skip’, ‘skipIf’, ‘skipUnless’, ‘suite’, ‘util’]

说明：

unittest.TestCase：TestCase类，所有测试用例类继承的基本类。

class BaiduTest(unittest.TestCase):
unittest.main():使用她可以方便的将一个单元测试模块变为可直接运行的测试脚本，main() 方法使用TestLoader类来搜索所有包含在该模块中以“test”命名开头的测试方法，并自动执行他们。执行方法的默认顺序是：根据ASCII码的 顺序加载测试用例，数字与字母的顺序为：0-9，A-Z，a-z。所以以A开头的测试用例方法会优先执行，以a开头会后执行。

unittest.TestSuite()：unittest框架的TestSuite()类是用来创建测试套件的。

unittest.TextTextRunner():unittest框架的TextTextRunner()类，通过该类下面的run()方法来运行suite所组装的测试用例，入参为suite测试套件。

unittest.defaultTestLoader(): defaultTestLoader()类，通 过该类下面的discover()方法可自动更具测试目录start_dir匹配查找测试用例文件（test*.py），并将查找到的测试用例组装到测试 套件，因此可以直接通过run()方法执行discover。用法如下：

discover=unittest.defaultTestLoader.discover(test_dir, pattern=‘test_*.py’)
unittest.skip():装饰器，当运行用例时，有些用例可能不想执行等，可用装饰器暂时屏蔽该条测试用例。一种常见的用法就是比如说想调试某一个测试用例，想先屏蔽其他用例就可以用装饰器屏蔽。

@unittest.skip(reason): skip(reason)装饰器：无条件跳过装饰的测试，并说明跳过测试的原因。

@unittest.skipIf(reason): skipIf(condition,reason)装饰器：条件为真时，跳过装饰的测试，并说明跳过测试的原因。

@unittest.skipUnless(reason): skipUnless(condition,reason)装饰器：条件为假时，跳过装饰的测试，并说明跳过测试的原因。

@unittest.expectedFailure(): expectedFailure()测试标记为失败。

2、TestCase类的属性如下：

[‘call’, ‘class’, ‘delattr’, ‘dict’, ‘doc’, ‘eq’, ‘format’, ‘getattribute’, ‘hash’, ‘init’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘_addSkip’, ‘_baseAssertEqual’, ‘_classSetupFailed’, ‘_deprecate’, ‘_diffThreshold’, ‘_formatMessage’, ‘_getAssertEqualityFunc’, ‘truncateMessage’, ‘addCleanup’, ‘addTypeEqualityFunc’, ‘assertAlmostEqual’, ‘assertAlmostEquals’, ‘assertDictContainsSubset’, ‘assertDictEqual’, ‘assertEqual’, ‘assertEquals’, ‘assertFalse’, ‘assertGreater’, ‘assertGreaterEqual’, ‘assertIn’, ‘assertIs’, ‘assertIsInstance’, ‘assertIsNone’, ‘assertIsNot’, ‘assertIsNotNone’, ‘assertItemsEqual’, ‘assertLess’, ‘assertLessEqual’, ‘assertListEqual’, ‘assertMultiLineEqual’, ‘assertNotAlmostEqual’, ‘assertNotAlmostEquals’, ‘assertNotEqual’, ‘assertNotEquals’, ‘assertNotIn’, ‘assertNotIsInstance’, ‘assertNotRegexpMatches’, ‘assertRaises’, ‘assertRaisesRegexp’, ‘assertRegexpMatches’, ‘assertSequenceEqual’, ‘assertSetEqual’, ‘assertTrue’, ‘assertTupleEqual’, 'assert’, ‘countTestCases’, ‘debug’, ‘defaultTestResult’, ‘doCleanups’, ‘fail’, ‘failIf’, ‘failIfAlmostEqual’, ‘failIfEqual’, ‘failUnless’, ‘failUnlessAlmostEqual’, ‘failUnlessEqual’, ‘failUnlessRaises’, ‘failureException’, ‘id’, ‘longMessage’, ‘maxDiff’, ‘run’, ‘setUp’, ‘setUpClass’, ‘shortDescription’, ‘skipTest’, ‘tearDown’, ‘tearDownClass’]

说明：

setUp():setUp()方法用于测试用例执行前的初始化工作。如测试用例中需要访问数据库，可以在setUp中建立数据库连接并进行初始化。如测试用例需要登录web，可以先实例化浏览器。

tearDown():tearDown()方法用于测试用例执行之后的善后工作。如关闭数据库连接。关闭浏览器。

assert*():一些断言方法：在执行测试用例的过程中，最终用例是否执行通过，是通过判断测试得到的实际结果和预期结果是否相等决定的。

assertEqual(a,b，[msg='测试失败时打印的信息']):断言a和b是否相等，相等则测试用例通过。

assertNotEqual(a,b，[msg='测试失败时打印的信息']):断言a和b是否相等，不相等则测试用例通过。

assertTrue(x，[msg='测试失败时打印的信息'])：断言x是否True，是True则测试用例通过。

assertFalse(x，[msg='测试失败时打印的信息'])：断言x是否False，是False则测试用例通过。

assertIs(a,b，[msg='测试失败时打印的信息']):断言a是否是b，是则测试用例通过。

assertNotIs(a,b，[msg='测试失败时打印的信息']):断言a是否是b，不是则测试用例通过。

assertIsNone(x，[msg='测试失败时打印的信息'])：断言x是否None，是None则测试用例通过。

assertIsNotNone(x，[msg='测试失败时打印的信息'])：断言x是否None，不是None则测试用例通过。

assertIn(a,b，[msg='测试失败时打印的信息'])：断言a是否在b中，在b中则测试用例通过。

assertNotIn(a,b，[msg='测试失败时打印的信息'])：断言a是否在b中，不在b中则测试用例通过。

assertIsInstance(a,b，[msg='测试失败时打印的信息'])：断言a是是b的一个实例，是则测试用例通过。

assertNotIsInstance(a,b，[msg='测试失败时打印的信息'])：断言a是是b的一个实例，不是则测试用例通过。

3、TestSuite类的属性如下：（组织用例时需要用到）

[‘call’, ‘class’, ‘delattr’, ‘dict’, ‘doc’, ‘eq’, ‘format’, ‘getattribute’, ‘hash’, ‘init’, ‘iter’, ‘module’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘_addClassOrModuleLevelException’, ‘_get_previous_module’, ‘_handleClassSetUp’, ‘_handleModuleFixture’, ‘_handleModuleTearDown’, ‘_tearDownPreviousClass’, ‘_tests’, ‘addTest’, ‘addTests’, ‘countTestCases’, ‘debug’, ‘run’]

说明：

addTest(): addTest()方法是将测试用例添加到测试套件中，如下方，是将test_baidu模块下的BaiduTest类下的test_baidu测试用例添加到测试套件。

suite = unittest.TestSuite()
suite.addTest(test_baidu.BaiduTest(‘test_baidu’))

4、TextTextRunner的属性如下：（组织用例时需要用到）

[‘class’, ‘delattr’, ‘dict’, ‘doc’, ‘format’, ‘getattribute’, ‘hash’, ‘init’, ‘module’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘_makeResult’, ‘buffer’, ‘descriptions’, ‘failfast’, ‘resultclass’, ‘run’, ‘stream’, ‘verbosity’]

说明：

run(): run()方法是运行测试套件的测试用例，入参为suite测试套件。

runner = unittest.TextTestRunner()
runner.run(suite)
四、使用unittest框架编写测试用例思路

设计基本思路如下，新建一个test.py文件（名称自定义），代码如下

 1 import unittest
 2 
 3 
 4 class Test(unittest.TestCase):
 5     # 定义测试类，父类为unittest.TestCase
 6     # 定义setUp()方法用于测试用例执行前的初始化工作。
 7     def setUp(self):
 8         # 注意，所有类中方法的入参为self，定义方法的变量也要“self.变量”
 9         self.number = input('Enter a number:')
10         self.number = int(self.number)  # 注意，输入的值为字符型的需要转为int型
11 
12     # 定义测试用例，以“test_”开头命名的方法,方法的入参为self
13     # 可定义多个测试用例
14     # 最重要的就是该部分
15     def test_case1(self):
16         self.assertEqual(self.number, 10, msg = 'Your input is not 10')
17 
18     def test_case2(self):
19         print(self.number)
20         self.assertEqual(self.number, 20, msg = 'Your input is not 20')
21 
22     @unittest.skip('暂时跳过用例3的测试')
23     def test_case3(self):
24         print(self.number)
25         self.assertEqual(self.number, 30, msg = 'Your input is not 30')
26 
27     # 定义tearDown()方法用于测试用例执行之后的善后工作。
28     # 注意，方法的入参为self
29     def tearDown(self):
30         print('Test over')
31 

32 
33 # 执行测试用例方案一如下：
34 # unittest.main()方法会搜索该模块下所有以test开头的测试用例方法，并自动执行它们。
35 # 执行顺序是命名顺序：先执行test_case1，再执行test_case2
36 if __name__ == '__main__':
37     unittest.main()
38 
39 # 执行测试用例方案二如下(以下整段代码块替换方案一的代码块)：
40 # 1.先构造测试集2.实例化测试套件
41 if __name__ == '__main__':
42     suite = unittest.TestSuite()
43     # 将测试用例加载到测试套件中。
44     # 执行顺序是安装加载顺序：先执行test_case2，再执行test_case1
45     suite.addTest(Test('test_case2'))
46     suite.addTest(Test('test_case1'))
47     # 执行测试用例,实例化TextTestRunner类，verbosity参数可以控制执行结果的输出，0 是简单报告、1 是一般报告、2 是详细报告
48     runner = unittest.TextTestRunner(verbosity = 2)
49     # 使用run()方法运行测试套件（即运行测试套件中的所有用例）
50     runner.run(suite)
51 
52 # 执行测试用例方案三如下(以下整段代码块替换方案一的代码块)：
53 # 构造测试集（简化了方案二中先要创建测试套件然后再依次加载测试用例）
54 # 执行顺序同方案一：执行顺序是命名顺序：先执行test_case1，再执行test_case2
55 if __name__ == '__main__':
56     test_dir = './'
57     # 通过该类下面的discover()方法可自动加载测试目录test_dir匹配查找测试用例文件（test_*.py），并将查找到的测试用例组装到测试套件discover中
58     discover = unittest.defaultTestLoader.discover(test_dir, pattern = 'test_*.py')
59     runner = unittest.TextTestRunner()
60     runner.run(discover)
执行py文件：python test.py

结果：

方案一：因为先执行test_case1,再执行test_case2,所以第一次输入10时，执行通过，返回. 第二次输入10时，执行不通过，返回F，最终一个用例通过，一个用例失败，还有一个用例是直接跳过的（装饰器）

方案二：因为先执行test_case2,再执行test_case1,所以第一次输入10时，执行不通过，返回F , 第二次输入10时，执行通过，返回. ，最终一个用例通过，一个用例失败。

方案三：因为先执行test_case1,再执行test_case2,所以第一次输入10时，执行通过，返回. 第二次输入10时，执行不通过，返回F，最终一个用例通过，一个用例失败，还有一个用例是直接跳过的（装饰器）。

五、测试报告输出：

1. 那如何生成一个测试报告呢，需要加入另外一个模块了，HTMLTestRunner，这个模块需要自己安装，使用执行测试用例就会生成一个html的测试报告

HTMLTestRunner地址：http://tungwaiyip.info/software/HTMLTestRunner.html

注意区分python的版本：2.x与3.x

下载完成后，放到C:\python35\Lib路径里面，然后修改test.py文件

import HTMLTestRunner #导入报告模块

#在if __name__ == '__main__'代码块中，用下面代码块替换runner = unittest.TextTestRunner()
    with open('HTMLReport.html', 'w') as f:
        runner = HTMLTestRunner(stream=f,
                                title='MathFunc Test Report',
                                description='generated by HTMLTestRunner.',
                                verbosity=2
                                )
        runner.run(suite)

再执行test.py文件后，后在test.py所在目录中生成HTMLReport.html；这个路径可以自行指定

六、测试日志输出：

1. 可以在运行的时候输出日志文件，这个不是那么必要

修改test.py

 1 import unittest
 2 import time,os,sys,logging
 3 
 4 sys.path.append(os.path.dirname(os.path.abspath(__file__)) + r'\..')  # 返回脚本的路径
 5 logging.basicConfig(level=logging.DEBUG,
 6                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
 7                     datefmt='%a, %d %b %Y %H:%M:%S',
 8                     filename='log_test.log',
 9                     filemode='w')
10 logger = logging.getLogger()
11 class Test(unittest.TestCase):
12     #代码略

执行test.py文件后，后在test.py所在目录中生产log_test.log

在上面代码块中的第5行：

INFO：处理请求或者状态变化等日常事务（一般详细）
DEBUG：调试过程中使用DEBUG等级，如算法中每个循环的中间状态（较详细）
七、总代码示例：

1. Tset.py文件

-- coding:utf-8 --

import unittest
import time,os,sys,logging
import HTMLTestRunner

sys.path.append(os.path.dirname(os.path.abspath(__file__)) + r'\..')  # 返回脚本的路径
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%a, %d %b %Y %H:%M:%S',
                    filename='log_test.log',
                    filemode='w')
logger = logging.getLogger()
class MyTest(unittest.TestCase):  # 继承unittest.TestCase

    def setUp(self):
        # 每个测试用例执行之前做操作
        print('执行用例开始')

    def tearDown(self):
        # 每个测试用例执行之后做操作
        print('执行用例结束')

    @classmethod
    def tearDownClass(self):
        # 必须使用 @ classmethod装饰器, 所有test运行完后运行一次
        print('--------测试执行结束--------')

    @classmethod
    def setUpClass(self):
        # 必须使用@classmethod 装饰器,所有test运行前运行一次
        print('--------测试执行开始--------')

    def test_1_add(self):
        """添加类别信息"""
        logger.info("Now: %r", '执行添加')
        self.assertEqual(1, 1)

    def test_2_que(self):
        """查询类别信息"""
        logger.info("Now: %r", '执行查询')
        self.assertEqual(2, 2)

if __name__ == '__main__':
    current_time = time.strftime("%Y-%m-%d-%H_%M_%S", time.localtime(time.time()))
    test_suite = unittest.TestSuite()  # 创建一个测试集合
    test_suite.addTest(MyTest('test_1_add'))
    test_suite.addTest(MyTest('test_2_que'))# 测试套件中添加测试用例
    # test_suite.addTest(unittest.makeSuite(MyTest))#使用makeSuite方法添加所有的测试方法
    report_path = current_time + '.html'  # 生成测试报告的路径
    fp = open(report_path, "wb")
    runner = HTMLTestRunner.HTMLTestRunner(stream = fp,
                                           title = '自动化测试报告',
                                           description = '用例执行情况：',
                                           verbosity = 2)
    runner.run(test_suite)
    fp.close()

方法一：

Python+selenium日志输出

此篇笔记用于记录自动化测试执行过后，自动输出日志并指定保存路径，方便测试人员进行查看。
大体的步骤可以分为一下几步
1、创建logger:logger = logging.getLoger()
2、创建handler:handler =logging.FileHandler()(FileHandler()将日志输出到文件中)
3、定义formater(日志格式):formater =logging.Formater()
4、给handler添加formater:handlersetFormater(formater)
5、给logger添加handler:loggeraddHandler(handler)
6、调用对应级别日志方法输出日志;日志的级别:error>warning>info>debug
首先我们创建一个Log类，其中定义构造方法，定义日志输出方法。
import logging
class Log:
#定义构造方法
def init (self.logname);
#组织日志存放路径+名称+格式的一个字符串 self.loqfile=“存放路径”+“文件名称”+".log#创建logger
self.logger= logging-getLogger(logname)
#设置logger日志级别，设置日志级别后，可以输出设计级别以上级别的日志，默认warning级别 self.logger.setLevel(logging.DEBUG)#DEBUG级别以上可以输出

#定义方法，实现日志的输出

def log print to file(self,level,message):#创建handler，将日志输出到文件中
handler = logging.FileHandler(self.logfile,"a")#a表示追加模式#设置日志级别
handler.setLevel(logging.DEBUG)#DEBUG级别以上可以输出#定义formatter
formater=loaging.Formatter(%(asctime)s-%(name)s-%(levelname)s -%(message)s')#asctime为时间，name为aetLogger()中的name,levelname为日志级别，message为日志信息#给handler添加formatter
handlersetFormatterifomatter)#给logger添加handler
self.logaer.addHandler(handler)
#根据传入的level实现不同日志级别的输出
if level == "debug":
self.logger.debug(message) elif level =="info"
self.logger.info(message) elif level ="wamina"
self.logger.warning(message) elif level == "error":
selflogaererrorimessage)#避免日志的重复输出
self.logger.removeHandler(handler) handler.close()#关闭打开的文件
#定义方法调用log print to file实现日志输出
def log_debug(self,message):
self. log print to file("debug", message)
def log info(self,message):
self.log_print to file("info", message)
def log waning(self,message):
self.log_print to file("warning", message)
def log error(selfmessage):
self.log_print_to file("error", message)
附一个定义时间戳的方法，可以加在文件名当中，便干区分日志:
from datetime import datetime

def get shijianchuo():
now time= datetime.now0
#使用datetime模块下的strftime()将取到的时间格式转化为字符串 shijianchuo = datetime.strftime(now time,"%Y%m%d%H%M%S) return shiiianchuo

方法二：

1.log类的写法：
 
import logging
import os.path
import time
 
 
class Logger(object):
 
    def __init__(self, logger):
        """
        指定保存日志的文件路径，日志级别，以及调用文件
            将日志存入到指定的文件中
        :param logger:
        """
        # 拼接日志文件夹，如果不存在则自动创建
        cur_path = os.path.dirname(os.path.realpath(__file__))
        log_path = os.path.join(os.path.dirname(cur_path), 'logs')
        if not os.path.exists(log_path):os.mkdir(log_path)
 
        # 创建一个logger
        self.logger = logging.getLogger(logger)
        self.logger.setLevel(logging.DEBUG)
 
        # 创建一个handler，用于写入日志文件
        rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
        # log_path = os.path.dirname(os.getcwd()) + '/Logs/'
        # log_name = log_path + rq + '.log'
 
        log_name = os.path.join(log_path,'%s.log ' %rq)
        fh = logging.FileHandler(log_name)
        fh.setLevel(logging.INFO)
 
        # 再创建一个handler，用于输出到控制台
        ch = logging.StreamHandler()
        ch.setLevel(logging.INFO)
 
        # 定义handler的输出格式
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        fh.setFormatter(formatter)
        ch.setFormatter(formatter)
 
        # 给logger添加handler
        self.logger.addHandler(fh)
        self.logger.addHandler(ch)
 
    def getlog(self):
        return self.logger
 

调用并测试log

import time
from selenium import webdriver
from autoFramewrok.utils.log import Logger
 
logger  = Logger(logger='TestMylog').getlog()
class TestMylog(object):
    def print_log(self):
        driver = webdriver.Chrome()
        # logger.info("打开浏览器")
        driver.maximize_window()
        logger.info("最大化浏览器窗口。")
        driver.implicitly_wait(8)
 
        driver.get("https://www.baidu.com")
        logger.info("打开百度首页。")
        time.sleep(1)
        logger.info("暂停一秒。")
        driver.quit()
        logger.info("关闭并退出浏览器。")
 
 
testlog = TestMylog()
testlog.print_log()

方法三：

在项目中添加日志模块并创建py文件

我们采用的是在用例中抛异常，打印日志。打印日志使用的是logging

log.py如下：

import logging
from logging import handlers
 
 
class Logger(object):
    level_relations = {
        'debug': logging.DEBUG,
        'info': logging.INFO,
        'warning': logging.WARNING,
        'error': logging.ERROR,
        'crit': logging.CRITICAL
    }  # 日志级别关系映射
 
    def __init__(self, filename, level='info', when='D', backCount=3,
                 fmt='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s'):
        self.logger = logging.getLogger(filename)
        format_str = logging.Formatter(fmt)  # 设置日志格式
        self.logger.setLevel(self.level_relations.get(level))  # 设置日志级别
        sh = logging.StreamHandler()  # 往屏幕上输出
        sh.setFormatter(format_str)  # 设置屏幕上显示的格式
        th = handlers.TimedRotatingFileHandler(filename=filename, when=when, backupCount=backCount,
                                               encoding='utf-8')  # 往文件里写入#指定间隔时间自动生成文件的处理器
        # 实例化TimedRotatingFileHandler
        # interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
        # S 秒
        # M 分
        # H 小时、
        # D 天、
        # W 每星期（interval==0时代表星期一）
        # midnight 每天凌晨
        th.setFormatter(format_str)  # 设置文件里写入的格式
        self.logger.addHandler(sh)  # 把对象加到logger里
        self.logger.addHandler(th)
 
 
if __name__ == '__main__':
    log = Logger('run.log', level='debug')
    log.logger.debug('debug')
    log.logger.info('info')
    log.logger.warning('警告')
    log.logger.error('报错')
    log.logger.critical('严重')
    Logger('error.log', level='error').logger.error('error')
在conftest.py中将其参数化：

from log.log import Logger
 
 
@pytest.fixture(scope="session")
def log():
    log = Logger('F:\\selenium\\IRS\\log\\run.log', level='info')
    return log

在测试用例中调用：

from case.public import Public
import time
import pytest
 
test_login_data = [("admin", "123456"), ("root", "admin")]
 
 
@pytest.mark.parametrize("user,pw", test_login_data)  # 用来传递参数，user，pw参数名称
def test_dengluyz(browser, user, pw, log):
    # dr = webdriver.Chrome()在conftest.py中已经封装了函数为browser，直接在用例中调用该方法
    # 引用封装好的登录模块，注意参数值需要用引号引起来
    public = Public()
    public.login_in(browser, user, pw)
    time.sleep(5)
    now_url = browser.current_url
    # 这就是断言
    try:
        assert now_url == "http://127.0.0.1:8989/index.html"
        log.logger.info("用户名{0}，密码{1}登录成功".format(user, pw))
    except AssertionError:
        msg = "用户名{0}，密码{1}断言失败，返回url{2}".format(user, pw, now_url)
        log.logger.error(msg)
        pytest.fail(msg)
    finally:
        log.logger.info("用户名{0}，密码{1}登录验证完成".format(user, pw))

方法四：

import logging
import time
import os, sys, traceback


def get_log(logger_name, path):
    """
    :param logger_name: 日志对象名称
    :param path 日志存放路径，取配置中心的日志路径值
    :return: logger 日志对象 all_log_name all文件日志路径 error_log_name error文件路径
    :rtype list
    """
    # 创建一个logger
    logger = logging.getLogger(logger_name)
    logger.setLevel(logging.INFO)

    # 设置日志存放路径，日志文件名
    # 获取本地时间，转换为设置的格式
    rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
    # 设置所有日志和错误日志的存放路径
    # path = Primary.readini.getvalue("log", "logFilePath")
    if not os.path.exists(path):
        os.makedirs(path)
    # 通过路径来拼接日志存放路径,创建all日志和error日志
    datelog = time.strftime("%Y-%m-%d", time.localtime())
    all_log_path = os.path.join(path, 'Logs/' + datelog + '/All_Logs/')
    if not os.path.exists(all_log_path):
        os.makedirs(all_log_path)
    error_log_path = os.path.join(path, 'Logs/' + datelog + '/Error_Logs/')
    if not os.path.exists(error_log_path):
        os.makedirs(error_log_path)
    # 设置日志文件名
    all_log_name = all_log_path + rq + '.log'
    error_log_name = error_log_path + rq + '.log'

    # 创建handler
    # 创建一个handler写入所有日志
    fh = logging.FileHandler(all_log_name, encoding='utf-8')
    fh.setLevel(logging.INFO)
    # 创建一个handler写入错误日志
    eh = logging.FileHandler(error_log_name, encoding='utf-8')
    eh.setLevel(logging.ERROR)
    # 创建一个handler输出到控制台
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)

    # 定义日志输出格式
    # 以时间-日志器名称-日志级别-日志内容的形式展示
    all_log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    # 以时间-日志器名称-日志级别-文件名-函数行号-错误内容
    error_log_formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(module)s - %(funcName)s - %(lineno)s - %(message)s')
    # 将定义好的输出形式添加到handler
    fh.setFormatter(all_log_formatter)
    ch.setFormatter(all_log_formatter)
    eh.setFormatter(error_log_formatter)

    # 给logger添加handler
    logger.addHandler(fh)
    logger.addHandler(eh)
    logger.addHandler(ch)
    return logger, all_log_name, error_log_name

方法五：

示例代码如下：

import logging
from logging.handlers import RotatingFileHandler
import time

fmt = " %(asctime)s  %(levelname)s %(filename)s %(funcName)s [ line:%(lineno)d ] %(message)s"
datefmt = '%a, %d %b %Y %H:%M:%S'
curTime = time.strftime("%Y-%m-%d %H%M", time.localtime())
handler_1 = logging.StreamHandler()
handler_2 = RotatingFileHandler(文件存储路径+"文件名_{0}.log".format(curTime),backupCount=20,encoding='utf-8')
#设置日志的输出内容形式，输出渠道
logging.basicConfig(
    format=fmt,
    datefmt=datefmt,
    level=logging.INFO,
    handlers=[handler_1,handler_2]
)

1、导入日志模块
import logging

2、导入文件处理程序
from logging.handlers import RotatingFileHandler

3、导入时间、日期
import time,datetime

4、设置日志输出格式
fmt = " %(asctime)s  %(levelname)s %(filename)s %(funcName)s [ line:%(lineno)d ] %(message)s"
%(asctime)s：打印日志的时间
%(levelname)s：打印日志级别的数值
%(filename)s：打印当前执行程序名
%(funcName)s：打印日志的当前函数
%(lineno)d：打印日志的当前行号
%(message)s：打印日志信息

5、设置时间格式

datefmt = '%a, %d %b %Y %H:%M:%S'      # 星期（简化）、当月的第几天、本地月份、完整年份、时分秒

format格式如下：

格式	含义
%a	本地（locale）简化星期名称
%A	本地完整星期名称
%b	本地简化月份名称
%B	本地完整月份名称
%c	本地相应的日期和时间表示
%d	一个月中的第几天（01 - 31
%H	一天中的第几个小时（24 小时制，00 - 23）
%l	一天中的第几个小时（12 小时制，01 - 12）
%j	一年中的第几天（001 - 366）
%m	月份（01 - 12）
%M	分钟数（00 - 59）
%p	本地 am 或者 pm 的相应符
%S	秒（01 - 61）
%U	一年中的星期数（00 - 53 星期天是一个星期的开始）第一个星期天之前的所有天数都放在第 0 周
%w	一个星期中的第几天（0 - 6，0 是星期天）
%W	和 %U 基本相同，不同的是 %W 以星期一为一个星期的开始
%x	本地相应日期
%X	本地相应时间
%y	去掉世纪的年份（00 - 99）
%Y	完整的年份
%z	用 +HHMM 或 -HHMM 表示距离格林威治的时区偏移（H 代表十进制的小时数，M 代表十进制的分钟数）
%Z	时区的名字（如果不存在为空字符）
%%	%号本身

6、获取当前时间
curTime = time.strftime("%Y-%m-%d %H%M", time.localtime())

7、创建对象（将日志信息输出到某个对象）
handler_1 = logging.StreamHandler()

8、创建对象（日志存储）
handler_2 = RotatingFileHandler(文件存储路径+"文件名_{0}.log".format(curTime),backupCount=20,encoding='utf-8')

9、设置日志的输出内容形式，输出渠道
logging.basicConfig(
    format=fmt,
    datefmt=datefmt,
    level=logging.INFO,
    handlers=[handler_1,handler_2]
)
9.1： logging.basicConfig()的参数：
9.2： level:输出日志的等级，debug<info<warning<critical<error
9.3： format:输出格式
9.4： datemat:时间信息
9.5： filename:日志信息输出到的日志文件名
9.6： filemode:决定使用什么模式来打开日志文件('r'、'w'、'a')，默认为'a'

方法六：（for me）

 1 import unittest
 2 import time,os,sys,logging
 3 
 4 sys.path.append(os.path.dirname(os.path.abspath(__file__)) + r'\..')  # 返回脚本的路径
 5 logging.basicConfig(level=logging.DEBUG,
 6                     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
 7                     datefmt='%Y-%M-%D_%H:%M:%S',
 8                     filename='log_test.txt',
 9                     filemode='w')
10 logger = logging.getLogger()
11 log_dir = r'存放日志路径'
12 log_file_name = datatime.now().strftime(%Y-%M-%D_%H:%M:%S) + '.txt
13 log_file_path = log_dir + '/' + log_file_name
14 file_handle = logging.FileHandle(log_file_path, mode='w', encoding='utf_8')
15 logger.addHandler(file_handle)