蟒單元測試與子功能

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)) 
   

   如果你想你的測試是在單獨的類，只是聲明之外的輔助函數你的測試用例。