Testsuite继承BaseTestSuite其实内部的东西不是太多--生成suite集合的逻辑主要如下-我这里没有扒源码-因为他最终生成的TestsSuite关联的模块比较多--如果贴源码出来---我能写出来--但是没法看。。所以就模拟了一下场景--写的不是太好--不过主要内容就这么点东西
<case.testss.A tests=[<testss.test_C testMethod=test_1>, <testss.test_C testMethod=test_2>, <testss.test_C testMethod=test_3>]>
当初我看到这种集合的时候,只知道他是一个列表-但是整个人都是懵逼的---特别是以下一句 位于BaseTestSuite下面的run方法
 def run(self, result):
for index, test in enumerate(self):
if result.shouldStop:
break
test(result) #就这一句----test为什么还可以传值,那时候也很少看源码只知道用。。。最近在写平台--感觉不了解内部原理-有点僵硬-所以决定干unittest源码
if self._cleanup:
self._removeTestAtIndex(index)
return result

 def run(self, result):
for index, test in enumerate(self):
if result.shouldStop:
break
test(result) #就这一句----test为什么还可以传值,那时候也很少看源码只知道用。。。最近在写平台--感觉不了解内部原理-有点僵硬-所以决定干unittest源码
if self._cleanup:
self._removeTestAtIndex(index)
return re在撸它之前得先了解一个内置函数__repr__
首先我们都知道object是一个对象---先明确这点
我的理解它的作用是几乎自定义对象显示名称--具体的解释-百度--一大堆
class C(object):
def test_1(self):
pass
def test_2(self):
pass
def test_3(self):
pass
if __name__ == "__main__":
print(test_C) #<class '__main__.test_C'> class是一个类--以及所在模块和类名
print(test_C()) #<__main__.test_C object at 0x000000000213C7B8> 所在模块.类名 对象 内存地址 class C(object):
def __repr__(self): #加上这么一句
return "<%s at '假装是一个内存地址'>" %("%s.%s"%(self.__class__.__module__,self.__class__.__qualname__))
def test_1(self):
pass
def test_2(self):
pass
def test_3(self):
pass
if __name__ == "__main__":
print(test_C) #<class '__main__.test_C'> class是一个类--以及所在模块和类名
print(test_C()) #<__main__.test_C at '假装是一个内存地址'> 这个对象名称就编程我们自定义的了 #然后看了这个例子我们明白了---__repr__这个方法这里就是修改对象的展示格式的。。。。

然后在看这个

unitest它是怎么找到用例的--然后生成一个TestSuite集合,现在大部分人都是用discover--尽管不是discover几乎也是这条线路

找用例全流程discover会把【目录】放到环境变量-方便后面_get_modul_from_namet通过文件名称找模块--实际上就是之前把目录加入到环境变量了,然后传文件的全路径走_get_name_from_path-执行一个os.path.relpath方法从之前的目录开始找本次传的文件的相对路径 也就是返回一个文件名--然后_get_modul_from_namet __import__(文件名)动态导入之后-然后返回一个 sys.moduls[”文件名“] 一个【文件对象】

然后这里又调用loadTestsfromModul方法--它执行dir(modul) 找到下面所有的属性 -然后判断他是不是一个类并且属于case.TestCase的子类(就是有没有继承unittest.TestCase)-然后遍历通过getattr(modul,className) 返回一个【类对象】---然后继续又找loadTestsFromTestCase--找方法对象--当初我就被这个方法里面的 map--这个map很关键--在这里用 --建议看下源码--返回然后一个suite集合

【目录】找到【文件对象moudel】找到 【类对象】找到【方法对象】 就这么一个玩意
 新建py文件 嗯 --叫什么名字呢。。。。。。就叫unitba.py
class TestCase():
def __init__(self,name="test"):
self.name=name
def __repr__(self):
return "<%s testMethod=%s>" % ("%s,%s"%(self.__class__.__module__, self.__class__.__qualname__), self.name)
def __str__(self):
return "%s (%s)" % (self.name, ("%s.%s"%(self.__class__.__module__, self.__class__.__qualname__)))
class test_C(TestCase):
def test_1(self):
pass
def test_2(self):
pass
def test_3(self):
pass
class BaseTestSuite(object): #假装这是unittest的BaseTestSuite
def __init__(self,tests=()):
# self.b=1
self.tests=[]
self.add(tests)
def __repr__(self):
return "<%s tests=%s>"%(self.__class__,self.tests)
def add(self,tests):
for a in tests:
self.tests.append(a)
class TestSuite(BaseTestSuite): #那么这个就是假装TestSuite
pass
#这个场景贼真实吧-。-
 
建一个文件tests.py--这个就是TestLoader
#第一步模拟场景  加环境变量
import os,sys,django os.environ.setdefault("DJANGO_SETTINGS_MODULE","besettest.settings")
django.setup()#如果不是django就不用管这两句 path=r"E:\PyFiles\Besettest\besettest\apps\case" #unitba.py的目录 我们传的目录
sys.path.insert(0,os.path.abspath(r"E:\PyFiles\DjangoBesettest\apps\case")) #加入变量--这一步其实是在discover中完成的
__import__('unitba')
modul=sys.modules[unitba] #这一步是dicvoer调用——>_find_tests——>_find_tests_path——>_get_modul_from_name
suite=unitba.TestSuite #上面已经动态导入了直接用就好
print(modul) #<module 'unitba' from 'E:\\PyFiles\\Besettest\\besettest\\apps\\case\\unitba.py'>
#那这里已经返回了文件对象
for testClassName in dir(modul): #那遍历出来的就是文件对象下面的 属性了
obj=getattr(modul,testClassName) #从modul中取类对象-
if isinstance(obj, type) : #判断他是否是一个类
def isTestMethod(attrname, testCaseClass=obj,p=testMethodPrefix):
return attrname.startswith(p) and callable(getattr(testCaseClass, attrname)) #callable检查是否可调用 getattr(testCaseClass, attrname)
testClassObjs=list(filter(isTestMethod, dir(obj))) #这个filter应该会用吧。。。
MethodObj= list(map(obj, testCase) ) #将方法名传入类对象---这里下面解释为什么可以这样用---只需要记住-这里的testCase是getattr返回的属性值就是个类名 类名(参数) 就实例化了
print(MethodObj) #[<unitba.test_C at '假装是一个内存地址'>, <unitba.test_C at '假装是一个内存地址'>, <unitba.test_C at '假装是一个内存地址'>] #一直到这里--都只是在单纯的找用例对象-那现在改一下用例类-按照unittest的suite格式改 模块名.类名 testMethod=方法名
# unittest格式<case.testss.A tests=[<testss.test_C testMethod=test_1>, <testss.test_C testMethod=test_2>, <testss.test_C testMethod=test_3>]> class test_C(object):
def __init__(self,name="test"): #手动传一个方法名-这里稍微有点绕--没基础的可能有点难理解-我尽量解释。。。。展示先写死
self.name=name
def __repr__(self):
return "<%s.%s testMethod=%s>" % (self.__class__.__module__, self.__class__.__qualname__, self.name)
def test_1(self):
pass
def test_2(self):
pass
def test_3(self):
pass
###然后在执行tests.py
print(MethodObj) #[<unitba,test_C testMethod=test_1>, <unitba,test_C testMethod=test_2>, <unitba,test_C testMethod=test_3>]是不是和里面的数据一样了 ###然后继续执行---
###suite=unitba.TestSuite 上面有定义一个这个东西 suite()就是一个实例化对象了这个能理解吧
###TestSuite继承BaseTestSuite --所以是可以传值的
###name suite(MethodObj)
#suite name接收的值-就是一个这么东西----实际上unittes不是向我这样处理的--但是原理是一样--他传的是一个map对象--我是在前面一步把map对象转换成列表了--而他是通过list(name)转换的
#注意一点----MethodObj里面的对象都是实例对象-实例化的时候传的参数是下面每个方法的名称--然后一个TestsCase类实例化了很个实例对象 他就是这么一个东西
#得到<<class 'case.unitba.TestSuite'> tests=[<unitba,test_C testMethod=test_1>, <unitba,test_C testMethod=test_2>, <unitba,test_C testMethod=test_3>]>
#对比<case.testss.A tests=[<testss.test_C testMethod=test_1>, <testss.test_C testMethod=test_2>, <testss.test_C testMethod=test_3>]>
是不是一样--你可以继续加东西--我这里不完全一样是因为我没有把参数加到和unittetst加到一样
 MethodObj= list(map(obj, testCase) )
#这里为什么可以这样用,看下面这个方法就可以理解了---因为obj之前是用一个getattr取出来的值obj=getattr(modul,testClassName) 所以他是可以接受参数的-可以当做一个function用-
class   test1():
def add(self,a,b):
return a+b
a=test1()
b=getattr(a,"add") #这个是返回了add的内存地址 加上括号和里面的参数就直接执行了。。
print(b(1,2)) class test2(): #这个也是suite集合生成用的东西
def __call__(self, *args, **kwargs):
return self.add(*args, **kwargs)
def add(self,a,b):
return a+b
a=test2()
print(a(1,2))
 
为什么用iter()
class  test2():
def __init__(self,tests=None):
self._tests=[]
self.run(tests)
def __repr__(self):
return "<%s tests=%s>" % ("%s.%s"%(self.__class__.__module__,self.__class__.__class__.__qualname__), list(self)) #这里用list(self)
def __iter__(self): #让这个类变成一个可迭代的对象,并且让self._tests变成一个迭代器----那他有什么作用---就是这个对象只能用一次如下
return iter(self._tests) #返回该可迭代对象的的实例 def run(self,tests):
for a in tests:
self._tests.append(a) class test1():
def __init__(self,resul):
self.resul=resul
def __repr__(self):
return "<%s testMethod=%s>" %("%s.%s"%(self.__class__.__module__,self.__class__.__class__.__qualname__), self.resul)
# def __str__(self):
# return self.resul
def test_1(self):
return self.resul,1
def test_2(self):
return self.resul
test2=test2
name=["test1","test2","test3"]
MethodsName=list(filter(lambda x:x.startswith("test"),dir(test1)))
print(MethodsName)#这里打印出来是方法的名字
print(test2(map(test1,MethodsName))) #map(test1,MethodsName))--test("参数") 这个得到结果就是相当于传了不同的方法名--定义了多个实例对象-然后传给test2--得到一个test2的实例对象 #['test_1', 'test_2']
#<__main__.type tests=[<__main__.type testMethod=test_1>, <__main__.type testMethod=test_2>]> #比如:
mapG=map(test1,MethodsName)
a=test2(mapG) #<__main__.type tests=[<__main__.type testMethod=test_1>, <__main__.type testMethod=test_2>]>
b=test2(mapG) #<__main__.type tests=[]>

所suite集合 就是在TestLoader找测试用例的时候--通过_find_tests这个方法从目录开始找文件(子目录)-模块-类-方法名

然后将某个模块下的类通过他下面的方法map返回多个对象,也就是说一个testClass下面存在五个test_method,他就会返回五个实例对象-并生成一个suite集合--然后加入到一个列表
如果一个模块下有多个testClasee 同样-实际上是一样的--实际上他是先通过loadTestsFromModule这个方法找到所有的类对象之后在遍历--然后才走上面那一步的,,,多个testClasss就存在多个suite集合--
也就是说 一个modul下面的 suite集合会添加到一个列表--[suite=[A-TestCase实例化对象1,A-TestCase实例化对象2],suite=[B-TestCase实例化对象1,B-TestCase实例化对象2]]---然后在将这个列表当做参数传入TestSuite实例化一个新对象[suite=-[suite=[A-TestCase实例化对象1,A-TestCase实例化对象2],suite=[B-TestCase实例化对象1,B-TestCase实例化对象2]]]----这样就是一个模块下用的结构
但是还没有完--这里只是一个modul下的---还有多个modul--到了大家估计也知道剩下的会干什么了---
没错--当我得到modul的全部suite集合之后---这个集合最终会返回给_find_tests方法--通过生成器返回给discover--也就是将这个suite集合又加入到了一个新的列表--然后discover又将这个list
带入形成了一个-----最终的实例对象,最终返回的格式如下-------
[suite=
[suite1=-[suite=[A-TestCase实例化对象1,A-TestCase实例化对象2],suite=[B-TestCase实例化对象1,B-TestCase实例化对象2]]],
[suite2=-[suite=[A-TestCase实例化对象1,A-TestCase实例化对象2],suite=[B-TestCase实例化对象1,B-TestCase实例化对象2]]]
]
 
--看过源码的都知道---我们run的时候---就这个实例对象是可以接受参数的--而这个参数就是result---因为TestSuite继承的BaseTestsSuite 有一个__call__这个魔术方法:如果在类中实现了 __call__ 方法,那么实例对象也将成为一个可调用对象,具体百度。这里不做过多解释-----所以最终的suite是可以接受参数的test(result)--接受参数之后直接走——call下面的逻辑了

class test2(): def __init__(self,tests=None): self._tests=[] self.run(tests) def __repr__(self): return "<%s tests=%s>" % ("%s.%s"%(self.__class__.__module__,self.__class__.__class__.__qualname__), list(self)) #这里用list(self) def __iter__(self): #让这个类变成一个可迭代的对象,并且让self._tests变成一个迭代器----那他有什么作用---就是这个对象只能用一次如下 return iter(self._tests) #返回该可迭代对象的的实例 def run(self,tests): for a in tests: self._tests.append(a) class test1(): def __init__(self,resul): self.resul=resul def __repr__(self): return "<%s testMethod=%s>" %("%s.%s"%(self.__class__.__module__,self.__class__.__class__.__qualname__), self.resul) # def __str__(self): # return self.resul def test_1(self): return self.resul,1 def test_2(self): return self.resul test2=test2 name=["test1","test2","test3"] MethodsName=list(filter(lambda x:x.startswith("test"),dir(test1))) print(MethodsName)#这里打印出来是方法的名字 print(test2(map(test1,MethodsName))) #map(test1,MethodsName))--test("参数") 这个得到结果就是相当于传了不同的方法名--定义了多个实例对象-然后传给test2--得到一个test2的实例对象 #['test_1', 'test_2'] #<__main__.type tests=[<__main__.type testMethod=test_1>, <__main__.type testMethod=test_2>]> #比如: mapG=map(test1,MethodsName) a=test2(mapG) #<__main__.type tests=[<__main__.type testMethod=test_1>, <__main__.type testMethod=test_2>]> b=test2(mapG) #<__main__.type tests=[]>

什么了解suite集合实现的更多相关文章

  1. 【Selenium】3.介绍Selenium IDE

    本文供学习交流之用,没有商业用途,没有盈利. 完全是我自己为督促自己学习而翻译的.翻译的不好,见谅.来源于:http://www.guru99.com/introduction-selenuim-id ...

  2. 一步一步教你编写与搭建自动化测试框架——python篇

    [本文出自天外归云的博客园] 这两天用python写了一个自动化测试框架,取名为Auty.准备用来做Web方面的接口测试,以下为Auty框架一步一步的搭建过程——

  3. java单元测试(Junit)

    JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架(regression testing framework),供Java开发人员编写单元测试之用. 对不同性质的被 ...

  4. [翻译]NUnit---Action Attributes(八)

    Attributes NUnit 1.0使用传统的基于继承和命名约定来识别测试.从2.0开始NUnit使用自定义特性来实现. 因为NUnit的test fixtures不是从框架类库继承,所以开发人员 ...

  5. python自动化测试框架unittest

    对于刚学习python自动化测试的小伙伴来说,unittest是一个非常适合的框架: 通过unittest,可以管理测试用例的执行,自动生成简单的自动化测试报告: 首先我们尝试编写编写一个最简单的un ...

  6. unittest(1)

    一.unittest核心概念 1.unittest四个核心概念 unittest四个核心概念包括:TestCase.TestSuite.TestRunner.Test Fixture TestCase ...

  7. TestLoader源码解析

    def loadTestsFromTestCase(self, testCaseClass) #看名称分析:从TestCase找测试集--那么就是把我们的def用例加载到testSuit里面 def ...

  8. 微软极品工具箱-Sysinternals Suite

    工具包由来 Sysinternals Suite是微软发布的一套非常强大的免费工具程序集,一共包括74个windows工具.Sysinternals是Winternals公司提供的免费工具,Winte ...

  9. Github优秀java项目集合(中文版) - 涉及java所有的知识体系

    Java资源大全中文版 我想很多程序员应该记得 GitHub 上有一个 Awesome - XXX 系列的资源整理.awesome-java 就是 akullpp 发起维护的 Java 资源列表,内容 ...

随机推荐

  1. [PHP自动化-进阶]003.CURL处理Https请求访问

    引言:继前文<模拟登录并采集数据>,<模拟登录带有验证码的网站>,大家对CURL基本上已经有了认识,这一讲简单的说一下请求Https. 在很多的站点,如TalkingData, ...

  2. Elasticsearch系列---生产集群部署(上)

    概要 本篇开始介绍Elasticsearch生产集群的搭建及相关参数的配置. ES集群的硬件特性 我们从开始编程就接触过各种各样的组件,而每种功能的组件,对硬件要求的特性都不太相同,有的需要很强的CP ...

  3. 伪静态%{REQUEST_FILENAME} !-f 和!-d用法

    %{REQUEST_FILENAME} !-f 和!-d只对下一条RewriteRule起作用.再往下的RewriteRule不管用. -f  表示为文件 -d 表示为目录 ! 表示非,取反的意思 R ...

  4. 02 . Prometheus告警处理

    Prometheus告警简介 告警能力在Prometheus的架构中被划分成两个独立的部分.如下所示,通过在Prometheus中定义AlertRule(告警规则),Prometheus会周期性的对告 ...

  5. win10和centos7双系统双磁盘引导的实现

    win10和centos7双系统双磁盘引导的实现1.背景:dell5460笔记本电脑M2-120G固态盘无法在bios中引导,新装了M360G固态盘后,考虑把120G固态盘安装centos7.5系统做 ...

  6. Rocket - devices - TLDeadlock

    https://mp.weixin.qq.com/s/Zv4HE7zMBzHbsWGg3pa9fg 简单介绍TLDeadlock的实现. 1. TLDeadlock TLDeadlock是抽象类Dev ...

  7. 我眼中的华为公有云AI平台--ModelArts

    前言 AWS Sagemaker has been a great deal for most data scientists who would want to accomplish a truly ...

  8. Linux内核进程调度overview(1)

    一.概述 决定何时.如何选择一个新进程运行的这组规则叫做:调度策略(scheduling policy). Linux的调度是基于分时技术(time sharing):多个进程以“时间多路复用”方式运 ...

  9. Java实现 LeetCode 338 比特位计数

    338. 比特位计数 给定一个非负整数 num.对于 0 ≤ i ≤ num 范围中的每个数字 i ,计算其二进制数中的 1 的数目并将它们作为数组返回. 示例 1: 输入: 2 输出: [0,1,1 ...

  10. Java实现 LeetCode 200 岛屿数量

    200. 岛屿数量 给定一个由 '1'(陆地)和 '0'(水)组成的的二维网格,计算岛屿的数量.一个岛被水包围,并且它是通过水平方向或垂直方向上相邻的陆地连接而成的.你可以假设网格的四个边均被水包围. ...