Bad Beginnings of Good Things

Let's admit it: tests for developers are neither attractive nor fun. They are usually tedious and time-consuming, yet they are an indispensable part of creating stable software. No one particularly likes them, but no one denies that they provide one essential need: security. As developers, we know all too well what happens when refactoring or making changes to a project without tests. What seems like unnecessary effort often turns out to be crucial support for our code.

It is evident that in textbook examples, we must always write tests. There's even an approach called Test-Driven Development, which enforces starting work with tests. However, as entrepreneurs, we face a problem where every hour spent on something other than creating business value for our clients feels like a misstep. So, we stand at a crossroads: what to choose? Full security with a longer project creation time? Or go with the flow and forget about tests altogether?

As Gandalf said to Frodo: "All we have to decide is what to do with the time that is given to us." So, which approach to choose? It would be good to have some tests but, at the same time, not spend unnecessary time on them that doesn't contribute to business value. And this is where End-to-End (E2E) business tests come into play.

I like order in a project. Business end-to-end tests are specific because they involve each Django application. Therefore, I apply my principle of marking solution elements that engage or are created for the entire solution with: "_ folder_name." This is how I mark all folders in the root of the solution that are intended for the whole, e.g., _ tests, _docker, etc. An additional benefit is their order—all are at the top due to alphabetical sorting.

Pytest at the Service of Business

Regardless of the libraries you use, the principles described here can be implemented in any of them. However, I will use the most popular ones for my favorite language, Python, namely pytest. The specificity of business end-to-end tests requires us to have control over the order, persistent data, and the easiest possible execution of tests.

1. pytest

   The main pytest library allows testing Python code. It is an advanced tool for writing unit and integration tests, offering simple syntax and support for many features such as assertions, parameterizations, and plugins.

2. pytest-dependency

   Enables marking dependencies between tests. This way, you can specify which tests should run only after the successful execution of others. Useful in scenarios where tests have logical connections.

3. pytest-django

   An add-on for pytest dedicated to Django projects. It facilitates testing Django applications, including models, views, and APIs. It includes, among other things, a test client (equivalent to Django Test Client) for testing HTTP requests.

4. pytest-env

   Allows defining and modifying environment variables during test execution. It makes it easy to set environment contexts, which is useful in tests requiring specific settings (e.g., for configuration variables).

5. pytest-mock

   A plugin that integrates pytest with the unittest.mock library. It enables the easy creation of mock objects, patching, and managing them in tests. Useful for testing code dependent on external functions or services.

6. pytest-asyncio

   Allows testing asynchronous functions in Python. With this plugin, you can write tests for code using async and await, which is essential in asyncio-based applications. In my last project, this was a must-have, as everything was written asynchronously.

Summary

I recommend delving into the documentation of the plugins mentioned above as well as pytest itself. It has become an industry standard for a reason. End-to-end tests provide peace of mind and ensure that our business processes work, delivering a reliable version of our project and not cutting off access to business growth. In the next article, I will present the fixtures I use in my end-to-end tests.

Alex

P.S.: In the next post, I invite you to explore my custom fixtures that will streamline your end-to-end tests and help you achieve efficiency using the libraries mentioned above.