CODEWITHSUNDEEP
pythonunit-testingpytest
Ania
Ania

Reputation: 11

Python unit testing on class methods with no input arguments

Given a class with class methods that contain only self input:

class ABC():
    def __init__(self, input_dict)
        self.variable_0 = input_dict['variable_0']
        self.variable_1 = input_dict['variable_1']
        self.variable_2 = input_dict['variable_2']
        self.variable_3 = input_dict['variable_3']

    def some_operation_0(self):
        return self.variable_0 + self.variable_1

    def some_operation_1(self):
        return self.variable_2 + self.variable_3

First question: Is this very bad practice? Should I just refactor some_operation_0(self) to explicitly take the necessary inputs, some_operation_0(self, variable_0, variable_1)? If so, the testing is very straightforward.

Second question: What is the correct way to setup my unit test on the method some_operation_0(self)? Should I setup a fixture in which I initialize input_dict, and then instantiate the class with a mock object?

@pytest.fixture
def generator_inputs():
    f = open('inputs.txt', 'r')
    input_dict = eval(f.read())
    f.close()
    mock_obj = ABC(input_dict)

def test_some_operation_0():
    assert mock_obj.some_operation_0() == some_value

(I am new to both python and general unit testing...)

Upvotes: 1

Views: 1321

Answers (1)

NicholasM
NicholasM

Reputation: 4673

Those methods do take an argument: self. There is no need to mock anything. Instead, you can simply create an instance, and verify that the methods return the expected value when invoked.

For your example:

def test_abc():    
    a = ABC({'variable_0':0, 'variable_1':1, 'variable_2':2, 'variable_3':3))
    assert a.some_operation_0() == 1
    assert a.some_operation_1() == 5

If constructing an instance is very difficult, you might want to change your code so that the class can be instantiated from standard in-memory data structures (e.g. a dictionary). In that case, you could create a separate function that reads/parses data from a file and uses the "data-structure-based" __init__ method, e.g. make_abc() or a class method.

If this approach does not generalize to your real problem, you could imagine providing programmatic access to the key names or other metadata that ABC recognizes or cares about. Then, you could programmatically construct a "defaulted" instance, e.g. an instance where every value in the input dict is a default-constructed value (such as 0 for int):

class ABC():
    PROPERTY_NAMES = ['variable_0', 'variable_1', 'variable_2', 'variable_3']

    def __init__(self, input_dict):
        # implementation omitted for brevity
        pass

    def some_operation_0(self):
        return self.variable_0 + self.variable_1

    def some_operation_1(self):
        return self.variable_2 + self.variable_3

def test_abc():
    a = ABC({name: 0 for name in ABC.PROPERTY_NAMES})
    assert a.some_operation_0() == 0
    assert a.some_operation_1() == 0

Upvotes: 2

Related Questions