python unittest with sub functions

You have a few of options:

1. I'm adding this one at the top as every other answer seems to want to use inheritance. If this is the case and you only want to set up the values before each test section (versus each test with setUp), use 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. Use setUp. This is probably not the best solution if you're going to be changing the parameters often. But you can also define the setup in a base class and use inheritance (as others have suggested) .

   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. Define helper functions.

   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. Perhaps a more specific answer to your question could be use use a more specific helper function:

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

   If you want your tests to be in separate classes, just declare the helper function outside of your test cases.

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

By making fun1_val and fun2_val class attributes of Base, they will be computed only once at the time Base is defined. The result can later be accessed in TestOne and TestTwo.

I believe you can also create another class. I've seen this done, but I haven't actually done it before. If people know that this works, please leave a comment :) while I test it out myself:

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: By changing self.a~c in class Tests(), test_func1 & test_func3 in TestOne & TestTwo print out appropriate values.

from functools import partial

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

Calling (ref):

f1()
f2()

Or in your case:

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

Example:

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