## Don’t repeat the logic in the unit tests

There are multiple mistakes you can do, as software engineer, when you define and write the unit tests for your software.

One of the most common I saw it was to repeat the logic from the tested function/method in the unit test function

``````### contants.py
HARD_UPPER = 10
SOFT_LOWER = 5
INTERMEDIATE_VALUES = [5, 6, 7, 8, 9, 10]

### functions.py
from constants import HARD_UPPER, SOFT_LOWER, INTERMEDIATE_VALUES

def my_func(x):
if x in INTERMEDIATE_VALUES:
return x + 1

if x > HARD_UPPER:
return x + x

if x < SOFT_LOWER:
return x ** x``````

Let’s imagine we want to test this dummy function, my_func and we would do it in this way:

``````from functions import my_func

def test_myfunc():
test_values = [4, 7, 8, 10]
for x in test_values:
if x in [5, 6, 7, 8, 9, 10]:
expected = x + 1
if x > 10:
expected = x + x
if x < 5:
expected = x ** x

assert expected == my_func(x)``````

It looks nice. It tests the boundaries, it seems to test all the intervals. But, let’s imagine someone is going into constans.py and does this change, increases the SOFT_LOWER with 1 and removes 5 from INTERMEDIATE_VALUES.

``````SOFT_LOWER = 6
INTERMEDIATE_VALUES = [6, 7, 8, 9, 10]``````

If we run our tests, everything is green, but some results are not the expected ones, for example, my_func(5), before 5 was in INTERMEDIATE_VALUES and the result was 6. Now, 5 is under the condition `if x < 5` so, the result is 5 ^ 5 = 3125.

Ofcourse, abose it is just a silly example where I tried to copy/paste the logic from the target function to the test and the easier fix would be just to try to hardcode the boundaries and some itermediate values, like:

``````def test_myfunc():
assert my_func(4) == 256
assert my_func(5) == 6
assert my_func(10) == 11
assert my_func(11) == 22
assert my_func(8) == 9``````

Now, we can see the test is failing for `x=5`

``````>       assert my_func(5) == 6
E       assert 3125 == 6
E        +  where 3125 = my_func(5)
``````

This is the case when the border values really matters and we want to be sure the developer is councious of this change (they will see the tests failing). This such case can be for example the tax applied (we don’t want to change the VAT value for a country too often, right?) or the maximum number of connected devices (eg: Netflix).

If we can argue the values are not so sensitive we could import directly the constants and use them instead of hardcoding in the test (eg: the time when the weekely report email is sent to the team’s PM and someone change it by mistake from 5PM to 5AM).