蟒单元测试与子功能

Question

如果我有简单的功能，fun1和fun2，这需要一些参数测试：

class TestOne(unittest.TestCase): 
    def test_func1(self): 
     a = 0 
     b = 1 
     c = 2 
     self.assertEquals(c, fun1(a,b)) 

    def test_fun2(self): 
     d = 0 
     e = 1 
     f = 2 
     self.assertEquals(f, fun2(d,e)) 

和用于第三功能的测试，这需要FUN1的输出和FUN2作为输入

class TestTwo(unittest.TestCase): 

    def test_fun3(self): 
     a = 0 
     b = 1 
     d = 0 
     e = 1 
     g = 3 
     self.assertEquals(g, fun3(fun1(a,b), fun2(d,e))) 

什么是避免重写第一个函数参数的最佳方法？

Answer 1

from functools import partial 

f1 = partial(fun1, a, b) 
f2 = partial(fun2, d, e) 

调用（ref）：

f1() 
f2() 

或者你的情况：

f1 = partial(fun1, 0, 1) 
f2 = partial(fun2, 0, 1) 

例子：

In [1]: from functools import partial 

In [2]: def fun1(a, b): 
    ...:  return a + b 
    ...: 

In [3]: f1 = partial(fun1, 0 ,1) 

In [4]: f1() 
Out[4]: 1 

Answer 2

我相信你也可以创建另一个类。我已经看到了这一点，但我以前没有做过。如果人们知道这个作品，请留下评论:)而我测试一下自己：

class Tests(unittest.TestCase): 
    def __init__(self): 
     self.a = 0 
     self.b = 1 
     self.c = 2 

class TestOne(Tests): 
    def test_func1(self): 
     self.a 
     self.b 
     self.c 

class TestTwo(Tests): 
    def test_fun3(self): 
     self.a 
     self.b 
     self.c 

UPDATE：通过改变self.a〜Ç类测试（），test_func1 & test_func3在TestOne & TestTwo打印拿出适当的价值。

Answer 3

class Base(unittest.TestCase): 
    fun1_val = fun1(a=0, b=1) 
    fun2_val = fun2(d=0, e=1) 

class TestOne(Base): 
    def test_func1(self): 
     c = 2 
     self.assertEquals(c, self.fun1_val) 

    def test_fun2(self): 
     f = 2 
     self.assertEquals(f, self.fun2_val) 

class TestTwo(Base): 
    def test_fun3(self): 
     g = 3 
     self.assertEquals(g, fun3(self.fun1_val, self.fun2_val))   

按制造Basefun1_val和​​类属性，他们将在被定义Base的时间来计算只有一次。结果可以在以后访问TestOne和TestTwo。

Answer 4

您有几种选择：

1. 我添加在上面这个是每一个其他的答案似乎想用继承。如果是这样的话，你只希望每个试验段（相对于与setUp每个测试）之前设置的值，使用setUpClass：

   from unittest import TestCase 
   class BaseTest(TestCase): 
       def setUpClass(cls): 
       cls.a = 0 
       cls.b = 1 
       cls.c = 2 
   
   class TestOne(BaseTest): 
       def test_func1(self): 
       self.assertEquals(self.c, func1(self.a, self.b)) 
   

2. 使用setUp。如果你经常改变参数，这可能不是最好的解决方案。但是你也可以在基类中定义设置并使用继承（如其他人所建议的那样）。

   from unittest import TestCase 
   class TestingSomething(TestCase): 
       def setUp(self): 
       self.parameters = [(0, 1), ] 
   
       def test_func1(self): 
       params = self.parameters[0] 
       res = func1(*params) 
       self.assertEquals(2, res) 
   

3. 定义帮助函数。

   from unittest import TestCase 
   class TestingSomething(TestCase): 
   
       def param_set_one(self): 
       return (0, 1), 2 
   
       def test_func1(self): 
       params, expected = self.param_set_one() 
       res = self.obj.func1(*params) 
       self.assertEquals(expected, res) 
   

4. 或许更具体的回答你的问题可能是使用使用一个更具体的辅助功能：

   from unittest import TestCase 
   class TestingSomething(TestCase): 
       def setUp(self): 
       self.obj = TestOne() 
   
       def param_set(self): 
       return (0, 1) 
   
       def get_func1(self): 
       return self.obj.func1(*self.param_set()) 
   
       def get_func2(self): 
       return self.obj.func2(*self.param_set()) 
   
       def test_func1(self): 
       params = self.param_set() 
       res = self.obj.func1(*params) 
       self.assertEquals(2, res) 
       [...] 
       def test_func3(self): 
       retval_func1 = self.get_func1_retval() 
       retval_func2 = self.get_func2_retval() 
       self.assertEqual(3, func3(retval_func1, retval_func2)) 
   

   如果你想你的测试是在单独的类，只是声明之外的辅助函数你的测试用例。