def test_set_attrs_tags(self):
class Base(TestCase):
tags = "base"
data = [
{
"value": "x",
"__attrs__": {
"tags": "foo"
}
},
{
"value": "x",
"__attrs__": {
"tags": ("fff", "xxx")
}
},
]
@datadrive.DataDrive(data)
class Demo(Base):
owner = "xxx"
timeout = 1
priority = TestCase.EnumPriority.BVT
status = TestCase.EnumStatus.Design
tags = "base2"
def run_test(self):
pass
tests = datadrive.load_datadrive_tests(Demo)
self.assertEqual(len(tests), 2)
self.assertEqual(tests[0].tags, set(["base", "foo"]))
self.assertEqual(tests[1].tags, set(["base", "fff", "xxx"]))
def test_set_attrs_doc(self):
data = [
{
"value": "x",
"__attrs__": {
"__doc__": "doc"
}
},
{
"value": "x",
"__attrs__": {
"xxxx": ("fff", "xxx")
}
},
]
@datadrive.DataDrive(data)
class Demo(TestCase):
"""base"""
owner = "xxx"
timeout = 1
priority = TestCase.EnumPriority.BVT
status = TestCase.EnumStatus.Design
tags = "base2"
def run_test(self):
pass
tests = datadrive.load_datadrive_tests(Demo)
self.assertEqual(len(tests), 2)
self.assertEqual(tests[0].test_doc, "doc")
self.assertEqual(tests[1].test_doc, "base")
def debug_run(self):
'''本地调试测试用例
'''
from testbase.runner import TestRunner
from testbase.loader import TestDataLoader
from testbase.report import EmptyTestReport, StreamTestReport
from testbase.testresult import StreamResult
from testbase import datadrive
if self.casedata is None:
testcls = type(self)
if datadrive.is_datadrive(testcls): #数据驱动用例
runner = TestRunner(
StreamTestReport(output_testresult=True,
output_summary=True))
return runner.run(datadrive.load_datadrive_tests(testcls))
elif settings.DATA_DRIVE: #项目级的数据驱动
testdataset = TestDataLoader().load()
runner = TestRunner(
StreamTestReport(output_testresult=True,
output_summary=True))
return runner.run(
[testcls(testdataset[it], str(it)) for it in testdataset])
runner = TestRunner(EmptyTestReport(lambda tc: StreamResult()))
return runner.run([self])
def debug_run_one(self, name=None):
'''本地调试测试用例，给数据驱动的用例使用，只执行一个用例
:param name: 测试数据名称，如果不指定，执行第一个数据的用例
'''
from testbase.runner import TestRunner
from testbase.loader import TestDataLoader
from testbase.report import EmptyTestReport
from testbase.testresult import StreamResult
from testbase import datadrive
runner = TestRunner(EmptyTestReport(lambda tc: StreamResult()))
if self.casedata is None:
testcls = type(self)
if datadrive.is_datadrive(testcls): #数据驱动用例
tests = datadrive.load_datadrive_tests(testcls, name)
if len(tests) > 1:
tests = [random.choice(tests)]
return runner.run(tests)
elif settings.DATA_DRIVE: #项目级的数据驱动
testdataset = TestDataLoader().load()
for it in testdataset:
if (name is None) or (str(name) == str(it)):
return runner.run([testcls(testdataset[it], str(it))])
else:
raise RuntimeError("找不到指定名字的测试数据")
else:
raise RuntimeError("非数据驱动用例请使用debug_run接口进行调试执行")
else:
runner.run([self])
return self
def _load_from_class(self,
cls,
data_key=None,
exclude_data_key=None,
attrs=None):
'''加载用例类
:param cls: Python类
:type cls: Type
:returns list - 测试用例对象列表
'''
if exclude_data_key is None:
exclude_data_key = []
exclude_data_key = [smart_text(i) for i in exclude_data_key]
tests = []
if datadrive.is_datadrive(cls) or settings.DATA_DRIVE:
tests = datadrive.load_datadrive_tests(cls, data_key, attrs)
else:
tests = [cls(attrs=attrs)]
if self._filter:
final_tests = []
for it in tests:
filter_reason = self._filter(it)
if filter_reason:
self._filtered_tests[it] = filter_reason
else:
final_tests.append(it)
tests = final_tests
return tests
def _load_from_class(self, cls):
'''加载用例类
:param cls: Python类
:type cls: Type
:returns list - 测试用例对象列表
'''
tests = []
if datadrive.is_datadrive(cls):
tests = datadrive.load_datadrive_tests(cls)
elif settings.DATA_DRIVE:
tests = [cls(self._dataset[it], str(it)) for it in self._dataset]
else:
tests = [cls()]
if self._filter:
final_tests = []
for it in tests:
filter_reason = self._filter(it)
if filter_reason:
self._filtered_tests[it] = filter_reason
else:
final_tests.append(it)
tests = final_tests
return tests
def debug_run_one(self, name=None):
'''本地调试测试用例，给数据驱动的用例使用，只执行一个用例
:param name: 测试数据名称，如果不指定，执行第一个数据的用例
'''
from testbase import datadrive
from testbase.runner import TestRunner
from testbase.report import EmptyTestReport
from testbase.testresult import StreamResult
test_cls = type(self)
if not datadrive.is_datadrive(test_cls) and not settings.DATA_DRIVE: # non-datadrive
raise RuntimeError("非数据驱动用例，请使用debug_run进行调试")
if name:
tests = datadrive.load_datadrive_tests(test_cls, name)
else:
tests = datadrive.load_datadrive_tests(test_cls)
tests = tests[:1]
runner = TestRunner(EmptyTestReport(lambda tc: StreamResult()))
return runner.run(tests)
def test_serialize_testsuite(self):
from tests.sampletest.hellotest import HelloTest, TimeoutTest
foo_test = datadrive.load_datadrive_tests(FooTest, 1)[0]
testsuite = SeqTestSuite([HelloTest(), TimeoutTest(), foo_test])
data = serialization.dumps(testsuite)
deserialized_testsuite = serialization.loads(data)
self.assertEqual(len(deserialized_testsuite), len(testsuite))
for deserialized_test, test in zip(deserialized_testsuite, testsuite):
self.assertEqual(type(deserialized_test), type(test))
for attr in ["owner", "timeout", "priority", "status", "tags", "test_doc"]:
self.assertEqual(getattr(deserialized_test, attr), getattr(test, attr))
def test_datadrive_serialization(self):
tests = datadrive.load_datadrive_tests(FooTest, 1)
self.assertEqual(len(tests), 1)
test = tests[0]
deserialized_test = serialization.loads(serialization.dumps(test))
self.assertEqual(deserialized_test.owner, "bar")
self.assertEqual(deserialized_test.timeout, 5)
self.assertEqual(deserialized_test.priority, TestCase.EnumPriority.BVT)
self.assertEqual(deserialized_test.status, TestCase.EnumStatus.Implement)
self.assertEqual(deserialized_test.tags, set(["a", "b", "c"]))
self.assertEqual(deserialized_test.test_doc, "demo")
def debug_run(self):
'''本地调试测试用例
'''
from testbase import datadrive
from testbase.runner import TestRunner
from testbase.report import StreamTestReport, EmptyTestReport
from testbase.testresult import StreamResult
test_cls = type(self)
if datadrive.is_datadrive(test_cls) or settings.DATA_DRIVE: # datadrvie
if self.casedataname is not None:
tests = datadrive.load_datadrive_tests(test_cls, self.casedataname)
report = EmptyTestReport(lambda tc: StreamResult())
else:
tests = datadrive.load_datadrive_tests(test_cls)
report = StreamTestReport(output_testresult=True, output_summary=True)
else:
tests = [self]
report = EmptyTestReport(lambda tc: StreamResult())
runner = TestRunner(report)
return runner.run(tests)
def test_load_list_data(self):
data = ["xxx", 1111]
@datadrive.DataDrive(data)
class Demo(TestCase):
owner = "xxx"
timeout = 1
priority = TestCase.EnumPriority.BVT
status = TestCase.EnumStatus.Design
def run_test(self):
pass
tests = datadrive.load_datadrive_tests(Demo)
self.assertEqual(len(tests), 2)
self.assertEqual(tests[0].casedata, data[0])
self.assertEqual(tests[1].casedata, data[1])
def test_load_dict_data(self):
data = {
"x": {"value":"x", "xxx":{"owner": "eeelin"}},
"y": {"value":2, "xxx":{"priority": TestCase.EnumPriority.Low}}
}
@datadrive.DataDrive(data)
class Demo(TestCase):
owner = "xxx"
timeout = 1
priority = TestCase.EnumPriority.BVT
status = TestCase.EnumStatus.Design
def run_test(self):
pass
tests = datadrive.load_datadrive_tests(Demo)
self.assertEqual(len(tests), 2)
for test in tests:
self.assertEqual(test.casedata, data[test.casedataname])
def test_set_attrs(self):
data = [
{"value":"x", "__attrs__":{"owner": "eeelin"}},
{"value":2, "__attrs__":{"priority": TestCase.EnumPriority.Low}}
]
@datadrive.DataDrive(data)
class Demo(TestCase):
owner = "xxx"
timeout = 1
priority = TestCase.EnumPriority.BVT
status = TestCase.EnumStatus.Design
def run_test(self):
pass
tests = datadrive.load_datadrive_tests(Demo)
self.assertEqual(len(tests), 2)
self.assertEqual(tests[0].owner, "eeelin")
self.assertEqual(tests[0].priority, TestCase.EnumPriority.BVT)
self.assertEqual(tests[1].owner, "xxx")
self.assertEqual(tests[1].priority, TestCase.EnumPriority.Low)
