Lecture 5

Unit Tests
assert
pytest
Testing Strings
Organizing Tests into Folders
Summing Up

Unit Tests

Up until now, you have been likely testing your own code using print statements.
Alternatively, you may have been relying upon CS50 to test your code for you!
It’s most common in industry to write code to test your own programs.
In your console window, type code calculator.py. Note that you may have previously coded this file in a previous lecture. In the text editor, make sure that your code appears as follows:
```
def main():
    x = int(input("What's x? "))
    print("x squared is", square(x))


def square(n):
    return n * n


if __name__ == "__main__":
    main()
```
Notice that you could plausibly test the above code on your own using some obvious numbers such as 2. However, consider why you might want to create a test that ensures that the above code functions appropriately.
Following convention, let’s create a new test program by typing code test_calculator.py and modify your code in the text editor as follows:
```
from calculator import square


def main():
    test_square()


def test_square():
    if square(2) != 4:
        print("2 squared was not 4")
    if square(3) != 9:
        print("3 squared was not 9")


if __name__ == "__main__":
    main()
```
Notice that we are importing the square function from square.py on the first line of code. By convention, we are creating a function called test_square. Inside that function, we define some conditions to test.
In the console window, type python test_calculator.py. You’ll notice that nothing is being outputted. It could be that everything is running fine! Alternatively, it could be that our test function did not discover one of the “corner cases” that could produce an error.
Right now, our code tests two conditions. If we wanted to test many more conditions, our test code could easily become bloated. How could we expand our test capabilities without expanding our test code?

`assert`

Python’s assert command allows us to tell the compiler that something, some assertion, is true. We can apply this to our test code as follows:
```
from calculator import square


def main():
    test_square()


def test_square():
    assert square(2) == 4
    assert square(3) == 9


if __name__ == "__main__":
    main()
```
Notice that we are definitively asserting what square(2) and square(3) should equal. Our code is reduced from four test lines down to two.

We can purposely break our calculator code by modifying it as follows:

def main():
    x = int(input("What's x? "))
    print("x squared is", square(x))


def square(n):
    return n + n


if __name__ == "__main__":
    main()

Notice that we have changed the * operator to a + in the square function.

Now running python test_square.py in the console window, you will notice that an AssertionError is raised by the compiler. Essentially, this is the compiler telling us that one of our conditions was not met.

One of the challenges that we are now facing is that our code could become even more burdensome if we wanted to provide more descriptive error output to our users. Plausibly, we could code as follows:

from calculator import square


def main():
    test_square()


def test_square():
    try:
        assert square(2) == 4
    except AssertionError:
        print("2 squared is not 4")
    try:
        assert square(3) == 9
    except AssertionError:
        print("3 squared is not 9")
    try:
        assert square(-2) == 4
    except AssertionError:
        print("-2 squared is not 4")
    try:
        assert square(-3) == 9
    except AssertionError:
        print("-3 squared is not 9")
    try:
        assert square(0) == 0
    except AssertionError:
        print("0 squared is not 0")


if __name__ == "__main__":
    main()

Notice that running this code will produce multiple errors. However, it’s not producing all the errors above. This is a good illustration that it’s worth testing multiple cases such that you might catch situations where there are coding mistakes.

The above code illustrates a major challenge: How could we make it easier to test your code without dozens of lines of code like the above?

You can learn more in Python’s documentation of assert.

`pytest`

pytest is a third-party library that allows you to unit test your program. That is, you can test your functions within your program.
To utilize pytest please type pip install pytest into your console window.

Before applying pytest to our own program, modify your test_calculator function as follows:

from calculator import square


def test_assert():
    assert square(2) == 4
    assert square(3) == 9
    assert square(-2) == 4
    assert square(-3) == 9
    assert square(0) == 0

Notice how the above code asserts all the conditions that we want to test.

pytest allows us to run our program directly through it, such that we can more easily view the results of our test conditions.
In the terminal window, type pytest test_calculator.py. You’ll immediately notice that output will be provided. Notice the red F near the top of the output, indicating that something in your code failed. Further, notice that the red E provides some hints about the errors in your calculator.py program. Based upon the output, you can imagine a scenario where 3 * 3 has outputted 6 instead of 9. Based on the results of this test, we can go correct our calculator.py code as follows:
```
def main():
    x = int(input("What's x? "))
    print("x squared is", square(x))


def square(n):
    return n * n


if __name__ == "__main__":
    main()
```
Notice that we have changed the + operator to a * in the square function, returning it to a working state.
Re-running pytest test_calculator.py, notice how no errors are produced. Congratulations!
At the moment, it is not ideal that pytest will stop running after the first failed test. Again, let’s return our calculator.py code back to its broken state:
```
def main():
    x = int(input("What's x? "))
    print("x squared is", square(x))


def square(n):
    return n + n


if __name__ == "__main__":
    main()
```
Notice that we have changed the * operator to a + in the square function, returning it to a broken state.
To improve our test code, let’s modify test_calculator.py to divide the code into different groups of tests:
```
from calculator import square


def test_positive():
    assert square(2) == 4
    assert square(3) == 9


def test_negative():
    assert square(-2) == 4
    assert square(-3) == 9


def test_zero():
    assert square(0) == 0
```
Notice that we have divided the same five tests into three different functions. Testing frameworks like pytest will run each function, even if there was a failure in one of them. Re-running pytest test_calculator.py, you will notice that many more errors are being displayed. More error output allows you to further explore what might be producing the problems within your code.

Having improved our test code, return your calculator.py code to fully working order:

def main():
    x = int(input("What's x? "))
    print("x squared is", square(x))


def square(n):
    return n * n


if __name__ == "__main__":
    main()

Notice that we have changed the + operator to a * in the square function, returning it to a working state.

Re-running pytest test_calculator.py, you will notice that no errors are found.
Finally, we can test that our program handles exceptions. Let’s modify test_calculator.py to do just that.

  import pytest

  from calculator import square


  def test_positive():
      assert square(2) == 4
      assert square(3) == 9


  def test_negative():
      assert square(-2) == 4
      assert square(-3) == 9


  def test_zero():
      assert square(0) == 0


  def test_str():
      with pytest.raises(TypeError):
          square("cat")

Notice that instead of using assert, we are taking advantage of a function within the pytest library itself called raises which allows you to express that you expect an error to be raised. We need to go to the top of our program and add import pytest and then call pytest.raises with the type of error we are expecting.

Again, re-running pytest test_calculator.py, you will notice that no errors are found.
In summary, it’s up to you as a coder to define as many test conditions as you see fit!

You can learn more in Pytest’s documentation of pytest.

Testing Strings

Going back in time, consider the following code hello.py:

def main():
    name = input("What's your name? ")
    hello(name)


def hello(to="world"):
    print("hello,", to)


if __name__ == "__main__":
    main()

Notice that we may wish to test the result of the hello function.

Consider the following code for test_hello.py:
```
from hello import hello


def test_hello():
    assert hello("David") == "hello, David"
    assert hello() == "hello, world"
```
Looking at this code, do you think that this approach to testing will work well? Why might this test not work well? Notice that the hello function in hello.py prints something: That is, it does not return a value!

We can change our hello function within hello.py as follows:

def main():
    name = input("What's your name? ")
    print(hello(name))


def hello(to="world"):
    return f"hello, {to}"


if __name__ == "__main__":
    main()

Notice that we changed our hello function to return a string. This effectively means that we can now use pytest to test the hello function.

Running pytest test_hello.py, our code will pass all tests!
As with our previous test case in this lesson, we can break out our tests separately:
```
from hello import hello


def test_default():
    assert hello() == "hello, world"


def test_argument():
    assert hello("David") == "hello, David"
```
Notice that the above code separates our test into multiple functions such that they will all run, even if an error is produced.

Organizing Tests into Folders

Unit testing code using multiple tests is so common that you have the ability to run a whole folder of tests with a single command.
First, in the terminal window, execute mkdir test to create a folder called test.
Then, to create a test within that folder, type in the terminal window code test/test_hello.py. Notice that test/ instructs the terminal to create test_hello.py in the folder called test.

In the text editor window, modify the file to include the following code:

from hello import hello
  
def test_default():
    assert hello() == "hello, world"
  
def test_argument():
    assert hello("David") == "hello, David"

Notice that we are creating a test just as we did before.

pytest will not allow us to run tests as a folder simply with this file (or a whole set of files) alone without a special __init__ file. In your terminal window, create this file by typing code test/__init__.py. Note the test/ as before, as well as the double underscores on either side of init. Even leaving this __init__.py file empty, pytest is informed that the whole folder containing __init__.py has tests that can be run.
Now, typing pytest test in the terminal, you can run the entire test folder of code.

You can learn more in Pytest’s documentation of import mechanisms.

Summing Up

Testing your code is a natural part of the programming process. Unit tests allow you to test specific aspects of your code. You can create your own programs that test your code. Alternatively, you can utilize frameworks like pytest to run your unit tests for you. In this lecture, you learned about…

Unit tests
assert
pytest