Unit Testing with pytest

Software Testing is the process of verifying and validating that a software or application is bug free.

🙂Levels of Software Testing

📌Unit Testing →Level of software testing process in which each individual component/unit is tested in an isolated environment.It helps in validating that each unit is performing as per expectations.

📌Integration Testing →In this level individual units are combined and are tested as a group.It helps in finding faults in the interaction between integrated units.

📌System Testing →In this level complete software is tested.It helps in validating system’s compliance with the requirements.

📌Acceptance Testing →System is tested for acceptability in this level.Validates its acceptance for delivery.

🙄Types of Testing

→Manual Testing

→Automated Testing

🔮Three most popular test runners in Python are:

🎶unittest

🎶pytest →Reduces the boilerplate code

🎶nose or nose2

Let’s begin exploring pytest:

🥁Installing pytest

Run the following command in your command line:

pip install -U pytest

Check that you installed the correct version:

$ pytest --version
pytest 7.1.3

🔗Invoking pytest

In general, pytest is invoked with the command pytest.Remember these two things:

→name of the file in which you are writing your test should have test_prefix →functions in which you are writing your test should have test_prefix

otherwise pytest will not be detecting your tests.

test_demo.py -->name of the file

def test_Add(): -->should have test_prefix in name
  assert add(1,2) == 3 -->testing an add function

#If you want to write your test cases inside a class then classname should have prefix Test
class TestDemo: -->Test Prefix should be there
   def test_Add(self):
       assert add(1,2) == 3

👀Asserting Expected Exceptions

import pytest
from demo import validate_demo

#If we want to write a test case for a function which is expected to raise some error.
def test_validate_demo():
    with pytest.raises(ValueError): -->it returns an object of class exception_info
        validate_demo(2) --> If this will not raise an Value error then this test case will fail

#If we want to test if the message printed in this test is correct or not
def test_validate_demo():
    with pytest.raises(ValueError) as exc_info:  
          validate_demo(2)
    assert str(exc_info.value) == "demo is not running"

#In pytest we have a match keyword which does the same thing as above
def test_validate_demo():
    with pytest.raises(ValueError, match="demo is not running"):  
          validate_demo(2)

💥Introduction to Markers

Using pytest.mark helper you can easily set metadata on your test functions and this metadata is going to tell pytest that how to run that test case.

#Suppose I want this test not to be executed when I run pytest then I can use this marker
#Unconditional Marker
@pytest.mark.skip(reason="Please skip it")
def test_demo():
  assert mult(10*2) == 20

#Conditional Marker
@pytest.mark.skipif(syd.version_info > (3.7), reason="Please skip it")
def test_demo():
  assert mult(10*2) == 20

#If I want that do not run this test case if this test case throws some exception while running with pytest
@pytest.mark.xfail(sys.platform == "win32", reason="Do not run on win dows")
def test_demo2():
    assert add("a", "b") == ab
    raise Esception()

🌀Parameterized Unit Test

We can run the same test for different arguments.

@pytest.mark.parametrize("a, b, c", [(1,2,3) ("a", "b", "ab")) -->arguments name should be given as comma separated in a string
#This test will run for these two sets of arguments (1,2,3) and ("a","b","ab") where say a=1, b=2 and c=3 and same for second set of arguments
def test_Add(a, b,c):
  assert add(a,b) == c

#We can also give ids to the arguments like:
@pytest.mark.parametrize("a, b, c", [(1,2,3) ("a", "b", "ab"), ids=["num", "str"])

#Profit of giving ids is that when these test will be executed you will get to see in terminal like:
test_Add[num] passed
test_Add[str] passed

🫧Introduction to Fixtures

In general, a test fixture is a environment used to consistently test some item ,device or piece of software.Software test fixture initializes test functions.They provide a fixed baseline so that tests execute reliably and produce consistent, ,reliable results.

pytest fixtures can be used in the case of like database connection or request sessions.We have a fixture like tmpdir what it does is, that it creates a temporary directory for the duration test case runs.

#Suppose we have a function like
import json
def save_dict(dict, filepath):
    json.dump(dict, open(filepath, 'w'))
    print("done") 

#Writing a unit test case to check if file is getting created
def test_save_dict(tmpdir, capsys) --> name of the fixture has to be passed in argument
  #capsys is a fixture that can read the output from console.
  filepath = os.path.join(tmpdir, "test.json")-->adding file name to temporary directory created by fixture to get full file path
  d={"a":1, "b":2}
  save_dict(d, filepath)
  #testing if this file is created or not
  assert json.load(open(filepath, 'r')) == d

  #testing if done is getting printed to console or not
  assert capsys.readouterr().out == "done\n" -->"\n" used because print statement also prints a new line 

🎒Creating a custom Fixture

#Let's make a fixture so that we get a dummy object of a class and do not need to create again and again for all tests
#Custom fixture should be decorated with this
@pytest.fixture
def dummy_demo():
  return Demo("1" "apple")

#let's use this custom fixture
def test_demo2(dummy_demo):
  assert dummy_demo.get_value() == 9

def test_demo3(dummy_demo):
  assert dummy_demo.get_credits == 0

#But the thing to note here is that dummy_demo fixture will be creating the object of that class as many times as we will be using that.
#To optimise it we will use concept of scopes in fixture so that object gets created only once and all tests can use that 
#By default scope of fixture is function.
#SCopes of fixtures are class, module, package or session
#Class scope means that this fixture will be initialized only once for all the test cases in the class

@pytest.fixture(scope="module")
def dummy_demo():-->Now this fixture will be making the object of Demo class only once for all the functions in the module.
  return Demo(1, "apple")

🌄Creating Fixture Factory

Unit test function will call a function to generate fixture dynamically.It can pass some arguments and fixture will be created as per those.

class Demo:
   def __init__(self, fruit , vitamins)
    self.fruit = fruit
    self.vitamins = vitamins

    def get_vitamins(self)
      return self.vitamins

def get_healthiest(fruits):
   healthyOne = max(fruits, key = lambda fruit:fruit.get_vitamins())

#Now we have to write a unit test for get_healthiest function
#Now we need multiple fruits object to check who is healthiest
@pytest.fixture
def dummy_fruits_factory() --> will return a function to generate new objects of fruit class
    def make_dummy_fruits(fruit, credits):
      return Demo(fruit credits)
    return make_dummy_fruits

def test_get_healthiest(dummy_fruits_factory):
    fruits = [
        dummy_fruits_factory("banana" 21),
        dummy_fruits_factory("mango", 15)
    ]
 healthyOne = get_healthiest(fruits)
assert healthiest == fruits[0]

**All fixtures should be placed in a file named conftest.py in order to have a clean code not mandatory.

🏖️Parameterizing Fixtures

#Parameterized Fixure
@pytest.fixture(params=[7,8], ids=["a", "b"])
def dummy_demo(request): -->request provides access to the current unit test  and the params passed in fixture
  return Demo("abc", 1 ,request.param)

#Now this test will run both the params passed in fixture
def test_dummy(dummy_Demo):
    //body of the test function

class findNum:
    def __init__(self, num):
        self.num = num

    def isEven(self):
        if self.num%2 == 0:
            return True
        else:
            return False

#Now let's write a unit test for isEven
#One way is that I write two functions one asserting value as True and one asserting value as False.
#More Optimized way is that I cover both in single function like this:

@pytest.fixture
def make_dummy_findNum() --> will return a function to generate new objects of fruit class
    def make_dummy_findNum(num):
      return findNum(num)
    return make_dummy_findNum

@pytest.mark.parameterize("num, expected", [(10, True) (61, False)])
def test_isEven(make_dummy_findNum, num, ,expected)-->at first position fixture should be passed
    assert isEven(make_dummy_findNum(num)) is expected

#Now let's learn that how to pass these params to a fixture i.e passing params from unit test to parameterized fixtures
@pytest.fixture
def dummy_find_num(request):
    return findNum(request.param)

@pytest.mark.parameterize("dummy_find_num, expected", [(10, True) (61, False)], indirect=["dummy_find_num"])
def test_isEven(dummy_find_num, expected):
     assert isEven(dummy_find_num) is expected

#This enabled us to use simple fixture instead of a fixture factory

I know it’s quite complicated, go through these codes once again and I’m sure you will get it.Happy Coding!!