2020/11: improvements (#8)

* docs: add missing comments on Makefile

* docs: fix diagram of setup/teardown flow for class tests

* Improve examples A, B

* Improve examples C (remove pymongo)

* Improve examples D (remove pymongo)

* Remove pymongo dependency references

* Final global corrections, amends, improvements

* Freeze versions in requirements.txt

Author: David-Lor

Makefile

@@ -5,19 +5,20 @@ test-sequential: ## run sequential tests, ignoring on-purpose failing and parall
 	pytest -s -v examples/ \
 	  --ignore=examples/A_helloworld/test_A2_failing.py \
 	  --ignore=examples/F_parametrize/test_F2_parametrize_failing.py \
-	  --ignore=examples/H_parallelization
+	  --ignore=examples/H_parallelization \
+	  -k "not random_number_fixture_fails and not expect_zerodivisionerror_not_raised and not expect_zerodivisionerror_raised_other"
 
 test-parallel: ## run parallel tests
 	pytest -s -v -n auto examples/H_parallelization
 
-test-all:
+test-all: ## run all tests
 	make test-sequential
 	make test-parallel
 
-install-requirements:
+install-requirements: ## pip install requirements
 	pip install -r requirements.txt
 
-run-jupyter:
+run-jupyter: ## run the jupyter notebook server
 	jupyter notebook
 
 help: ## show this help.

README.md

@@ -4,20 +4,23 @@
 
 ## Requirements
 
-- Python >= 3.6
+- Python >= 3.6 (virtual env recommended)
 - requirements listed in [requirements.txt](requirements.txt)
-- Tests C_fixtures, D_class_inherit require a running MongoDB server on localhost
 
 ## Running tests
 
 Run ALL tests with:
 
 ```bash
-pytest -s -v
+pytest -sv
 ```
 
-Run individual tests with:
+Run individual tests with (example):
 
 ```bash
-pytest -s -v examples/1_before_after
+# Only A1
+pytest -sv examples/A_helloworld/test_A1_helloworld.py
+
+# All modules in B_before_after package
+pytest -sv examples/B_before_after
 ```

examples/A_helloworld/test_A1_helloworld.py

@@ -1,5 +1,4 @@
-"""A1 - TEST with functions in module level, and testing exceptions
-"""
+"""A1 - TEST with functions in module level, and testing exceptions"""
 
 import pytest
 
@@ -12,21 +11,12 @@ def test_divide():
     assert 4 / 2 == 2
 
 
-def test_divide_zero():
-    """This test will fail if the code inside "with pytest.raises(...)" does not raise the given exception
-    """
-    with pytest.raises(ZeroDivisionError):
-        assert 2 / 0 == 0
-
-
 @pytest.mark.skip("Don't want to run this right now!")
 def test_skip():
-    """This test is marked as "skip" and will not run (but shown on results)
-    """
+    """This test is marked as "skip" and will not run (but shown on results)"""
     assert 2 / 0 == 0
 
 
 def this_test_will_not_run():
-    """All test modules (filenames) and methods (function names) must start with "test_"
-    """
+    """All test modules (filenames) and methods (function names) must start with 'test_'"""
     assert True is False

examples/A_helloworld/test_A2_failing.py

@@ -1,15 +1,19 @@
-"""A2 - TEST with functions in module level, with a failing test
-"""
+"""A2 - TEST with functions in module level, with failing tests"""
 
-import pytest
 
+def test_failing_zerodivisionerror():
+    2 / 0
 
-def test_failing():
+
+def test_failing_compare_true_is_false():
+    assert True == False
+
+
+def test_failing_compare_numbers_equality():
     assert 2 == 3
 
 
-def test_failing_not_raising():
-    """We expect this test to raise ZeroDivisionError, but will fail because it does not raise it (and the assert passes)
-    """
-    with pytest.raises(ZeroDivisionError):
-        assert 2 / 2 == 1
+def test_failing_compare_lists():
+    l1 = ["A", "B", "C"]
+    l2 = ["A", "C", "B"]
+    assert l1 == l2

examples/A_helloworld/test_A3_expect_raises.py

@@ -0,0 +1,23 @@
+"""A3 - TEST functions using pytest.raises"""
+
+import pytest
+
+
+def test_expect_zerodivisionerror_raised():  # passes
+    with pytest.raises(ZeroDivisionError):
+        2 / 0
+
+
+def test_expect_zerodivisionerror_not_raised():  # fails
+    with pytest.raises(ZeroDivisionError):
+        2 / 1
+
+
+def test_expect_zerodivisionerror_raised_other():  # fails
+    with pytest.raises(ZeroDivisionError):
+        2 / "not a number"
+
+
+def test_expect_typeerror_raised():  # passes
+    with pytest.raises(TypeError):
+        2 / "not a number"

examples/A_helloworld/this_test_wont_run.py

@@ -0,0 +1,5 @@
+"""TEST that will not run, because the filename does not start with 'test_'"""
+
+
+def test_what_will_not_run():
+    assert True is False

examples/A_helloworld/this_test_wont_run_A3.py

@@ -1,26 +1,25 @@
 """B1 - Test Before & After at Module level
 Functions that run before & after all tests on the module, and before & after each test on the module.
-Run with: "pytest -v -s ..." to show print output
-"""
+Run with: "pytest -v -s ..." to show print output"""
 
 my_variable = None
 
 
-def setup_module(module):
+def setup_module():
     global my_variable
     print("A) Setup module. Should run BEFORE any test")
     my_variable = True
 
 
-def teardown_module(module):
+def teardown_module():
     print("D) Teardown module. Should run AFTER all tests")
 
 
-def setup_function(function):
+def setup_function():
     print("B) Setup function. Should run BEFORE each test")
 
 
-def teardown_function(function):
+def teardown_function():
     print("C) Teardown function. Should run AFTER each test")
 
 

examples/B_before_after/test_B1_before_after_module.py

@@ -1,35 +1,33 @@
 """B2 - Test Before & After at Class level
 Functions that run before & after all tests on the class, and before & after each test on the class.
-Run with: "pytest -v -s ..." to show print output
-"""
+Run with: "pytest -v -s ..." to show print output"""
 
 
-def setup_module(module):
+def setup_module():
     print("A) Setup module. Should run BEFORE any test")
 
 
-def teardown_module(module):
+def teardown_module():
     print("F) Teardown module. Should run AFTER all tests")
 
 
-# noinspection PyMethodMayBeStatic,PyMethodParameters
 class TestBeforeAfterClass:
     my_variable: str
 
     @classmethod
     def setup_class(cls):
-        print("B) Setup module. Should run BEFORE any test of this class")
+        print("B) Setup class. Should run BEFORE any of the tests in this class")
         cls.my_variable = "OK!"
 
     @classmethod
     def teardown_class(cls):
-        print("E) Teardown module. Should run AFTER all tests of this class")
+        print("E) Teardown class. Should run AFTER all tests of this class")
 
-    def setup_method(method):
-        print("C) Setup method. Should run BEFORE each test")
+    def setup_method(self):
+        print("C) Setup method. Should run BEFORE each test in this class")
 
-    def teardown_method(method):
-        print("D) Teardown method. Should run AFTER each test")
+    def teardown_method(self):
+        print("D) Teardown method. Should run AFTER each test of this class")
 
     def test_my_variable_value(self):
         assert self.my_variable == "OK!"

examples/B_before_after/test_B2_before_after_class.py

@@ -1,27 +1,20 @@
 """C1 - Test with Fixtures
-Fixtures are functions that run before the test where used, and return something
-https://docs.pytest.org/en/latest/fixture.html
-"""
+Fixtures are functions that run before the test where used, and can return something,
+injected on the test as a function parameter.
+https://docs.pytest.org/en/latest/fixture.html"""
 
 import random
 import pytest
-from pymongo import MongoClient
-from pymongo.collection import Collection
 
 
 @pytest.fixture
-def mongo_collection():
-    """This fixture will create a MongoClient instance and return a collection where we can write/read documents
-    """
-    client = MongoClient("mongodb://127.0.0.1:27017")
-    return client["test_database"]["test_collection"]
+def random_number():
+    """This fixture will return a random number"""
+    print("A) Fixture runs")
+    return random.randint(0, 1000)
 
 
-def test_insert_read_delete(mongo_collection: Collection):
-    number = random.randint(0, 1000000)
-    data = {"random_number": number}
-
-    result = mongo_collection.insert_one(data)
-
-    read = mongo_collection.find_one({"_id": result.inserted_id})
-    assert read["random_number"] == number
+def test_random_number_fixture(random_number):
+    print("B) Test starts")
+    assert type(random_number) == int
+    print("C) Test ends with number", random_number)

examples/C_fixtures/test_C1_fixtures.py

@@ -1,59 +1,30 @@
 """C2 - Test with Yield Fixtures
 Yield fixtures use the "yield" statement to return something to the test function,
 but they keep running after the test (similarly to context managers).
-We run 2 identical tests to verify that the data inserted by previous tests is deleted on the fixture.
 https://pytest.readthedocs.io/en/2.9.1/yieldfixture.html
-https://docs.pytest.org/en/latest/yieldfixture.html
-"""
+https://docs.pytest.org/en/latest/yieldfixture.html"""
 
 import random
 import pytest
-from pymongo import MongoClient
-from pymongo.collection import Collection
 
 
 @pytest.fixture
-def mongo_collection():
-    """This fixture will create a MongoClient instance and return a collection where we can write and read data.
-    The collection is returned with yield statement to the test.
-    After test run, all documents from the collection are deleted.
-    """
-    client = MongoClient("mongodb://127.0.0.1:27017")
-    collection = client["test_database"]["test_collection"]
+def random_number():
+    """This fixture will return a random number"""
+    print("A) Fixture starts")
+    number = random.randint(0, 1000)
+    yield number
+    print("D) Fixture ends")
 
-    # Delete all documents on collections before test run
-    # (to clean possible documents from previous tests)
-    collection.delete_many({})
-    print("Deleted all documents in Mongo test collection!")
 
-    print("Returning collection to the test")
-    yield collection
+def test_random_number_fixture_yield(random_number):
+    print("B) Test starts")
+    assert type(random_number) == int
+    print("C) Test ends with number", random_number)
 
-    # Delete all documents on collection after test run
-    # (to keep it clean for next tests)
-    collection.delete_many({})
 
-
-@pytest.fixture
-def sample_data():
-    return {"random_number": random.randint(0, 100000)}
-
-
-def test_insert_read_delete_1(mongo_collection: Collection, sample_data):
-    read = mongo_collection.find({})
-    assert list(read) == []
-
-    result = mongo_collection.insert_one(sample_data)
-
-    read = mongo_collection.find_one({"_id": result.inserted_id})
-    assert read["random_number"] == sample_data["random_number"]
-
-
-def test_insert_read_delete_2(mongo_collection: Collection, sample_data):
-    read = mongo_collection.find({})
-    assert list(read) == []
-
-    result = mongo_collection.insert_one(sample_data)
-
-    read = mongo_collection.find_one({"_id": result.inserted_id})
-    assert read["random_number"] == sample_data["random_number"]
+def test_random_number_fixture_fails(random_number):
+    """Even if a test fails, the fixture runs the code after the yield statement"""
+    print("B) Test starts")
+    assert type(random_number) == str
+    print("C) Test ends (it should not reach this point!)")

examples/C_fixtures/test_C2_yield_fixture.py

@@ -1,28 +1,28 @@
 """C3 - tmp_path built-in fixture
 Usage of the built-in tmp_path fixture, which provides a temp path to save/read files into/from
-https://docs.pytest.org/en/latest/tmpdir.html
-"""
+https://docs.pytest.org/en/latest/tmpdir.html"""
 
 from pathlib import Path
 
 
 def test_write_read_file(tmp_path: Path):
-    directory = tmp_path / "subdirectory"
-    directory.mkdir()
-    file_name = directory / "hello.txt"
+    """Create a file 'hello.txt' within the tmp_path, and write lines into it.
+    Then, read the file lines and verify that written lines are on the read file."""
+    file_path = tmp_path / "hello.txt"
+    file_path = file_path.as_posix()
     lines = [
         "Hello there!",
         "General Kenobi!"
     ]
 
-    print("The filename is", file_name.as_posix())
+    print("The file path is", file_path)
 
     # Write
-    with open(file_name.as_posix(), "w") as file:
+    with open(file_path, "w") as file:
         file.writelines("\n".join(lines))
 
     # Read
-    with open(file_name.as_posix(), "r") as file:
+    with open(file_path, "r") as file:
         file_content = file.read()
         for line in lines:
             assert line in file_content

examples/C_fixtures/test_C3_tmp_path.py

@@ -1,2 +1 @@
-"""Init is required to do relative import of BaseTest from test modules
-"""
+"""Init is required to do relative import of BaseTest from test modules"""