Python's Unit Testing: Writing Unit Tests for Your Code

Bugs and unexpected errors can creep in at any stage of development, and without proper precautions, they can be difficult to detect and fix. This is why unit testing is one of the most important practices in software development. It ensures that your code works as expected and remains reliable even as you make changes or add new features. In this article, you will learn everything you need to know about Python unit testing, from the basics of creating your first test case to best practices and advanced techniques for making your tests more efficient and reliable. Let’s get started!

What is Unit Testing?

Unit testing is a software development practice where you test the smallest parts of your code, known as "units," to ensure they function correctly. A unit can be a single function, method, or class. The main objective is to verify that each unit works as expected on its own, without being affected by other parts of the code.

Here are some of the key benefits of unit testing:

✅ Boosts code quality – Unit testing ensures that each part of your code works correctly, leading to a more reliable and maintainable software application. Effective unit testing can reduce production bugs by up to 60%, enhancing overall software quality.

✅ Catches bugs early – Automated tests quickly identify problems as soon as they occur, making it easier to fix them before they escalate. 

✅ Speeds up development – With bugs caught early, developers spend less time on manual debugging and more time writing code. 

✅ Promotes modular code – Writing unit tests encourages developers to create small, independent code units that are easier to test and maintain.

✅ Makes refactoring safer – Unit tests allow you to update or improve code without accidentally breaking existing functionality.

✅ Acts as documentation – Clear and well-written unit tests describe what each part of the code is supposed to do, making it easier to understand.

✅ Enhances team collaboration – Multiple developers can work on the same codebase with confidence, knowing that automated tests will catch any issues they introduce. Teams using automated testing report 30% higher collaboration satisfaction and fewer integration conflicts due to confidence in automated test coverage.

✅ Maintains code consistency – Automated tests ensure that your code continues to work as expected, even after changes are made.

Getting to Know Python’s unittest

The unittest package is Python’s built-in unit testing framework, inspired by JUnit, a popular testing framework for Java. Because it is part of the standard library, you don’t need to install anything to use it. Simply import it and start writing your tests.

Let’s break down the four main elements of the unittest framework, as it’ll make writing tests much easier later on.

• Test case – A single, focused test that checks how your code behaves with a specific set of inputs. It ensures that your code produces the expected output for those inputs.
• Test suite – A collection of related test cases, or even other test suites, bundled together. It helps you organize and run multiple tests simultaneously, making it easier to verify that your code works as expected in different scenarios.
• Test fixture – A setup process that prepares everything your tests need to run properly. This can involve creating objects, initializing databases, or setting up files. It also includes any cleanup needed after tests complete, ensuring a fresh environment for each test.
• Test runner – A tool or system that automatically runs your tests and provides feedback on their results. This could be a built-in test runner, a custom script, or an automated process in a Continuous Integration (CI) system.

The assert Statement

The assert statement is a built-in feature in Python that is designed for debugging and testing. It allows you to check if a certain condition is true. If the condition is true, the program continues without any interruption. However, if the condition is false, Python raises an AssertionError.

Here is how assert works:

If the condition is true, nothing happens.

If the condition is false, an AssertionError is raised:

By default, an AssertionError does not provide any message. However, you can add a custom message to make debugging easier:

The TestCase class in Python's unittest module comes with various built-in assertion methods. These methods are designed to make it easier to test specific conditions in your code. They help you write clear, readable tests by providing specific checks for different conditions.

Here are some of the most commonly used assertion methods available in the TestCase class of Python's unittest module:

How to Write Python Unit Tests In 6 Steps

Step 1: Define the Behavior You Want to Test

Before writing any tests, try to understand what you are testing. In this example, we create a function that rounds a price to the nearest specified increment, such as 5, 10, 25, 50, or 100 cents. Our function must accept any monetary amount, round it to the nearest multiple of the chosen increment, and reject any unsupported increments, such as 7 or 15.

This function first checks if the chosen increment is an allowed value. If it is not, it raises a ValueError. Then, it calculates the rounded value by converting the amount to cents (an integer) and using a simple mathematical formula to round to the nearest increment. Finally, it converts the rounded value back to dollars.

Step 2: Organize Your Tests

Testing is most effective when tests are organized separately from your main code. We create a new file named test_pricetools.py, containing all the tests for our rounding function. Keeping tests separate makes managing them easier and ensures your code remains clean.

Step 3: Add Edge Cases and Error Conditions

To ensure your function is robust, it is important to test not only the standard behavior but also how it handles edge cases and error conditions. These are situations where the function might fail or produce unexpected results. For our round_price function, we need to account for:

• Edge values – Test how the function handles extreme values, like very small amounts (e.g., 0.01), very large amounts (e.g., 1,000,000.49), or negative amounts (e.g., -12.97).
• Boundary conditions – Focus on values right at the edge of rounding decisions, such as amounts exactly at a rounding point (5.01) or just below it (4.99).
• Error conditions – Ensure the function properly handles invalid inputs, such as unsupported increments (like 7 or 15) or non-numeric values (like "invalid").

Step 4: Use Fixtures (setUp and tearDown)

As your test suite grows, you may find that many tests share common setup steps. To avoid repetition, unittest provides fixtures in the form of setUp and tearDown methods.

The setUp method is called before each test, creating a CurrencyFormatter object that is used in all test methods. The tearDown method ensures the object is deleted after each test, keeping the tests independent.

Step 5: Use SubTests for Multiple Values

It's common to test the same behavior with different values. Instead of creating separate methods for each test case, you can simplify your code using subTest.

Step 6: Automate Test Discovery and Execution

To make running tests even easier, you can turn your test file into an executable script. Adding a standard boilerplate at the end of the file allows you to run it directly from the command line without any additional commands.

This setup allows you to run the tests with a single command:

The verbosity=2 option provides detailed feedback, showing the name of each test and whether it passed, failed, or was skipped. This is a quick and efficient way to see test results.

Unit Testing in Python: Best Practices & Techniques

Now that you have a solid understanding of writing unit tests in Python, let's explore some best practices and techniques to enhance your test suite:

1. Skip Tests Conditionally

Sometimes, not all tests are relevant on every platform. For example, a test that relies on a Linux-specific feature should not run on Windows or macOS. The unittest module makes it easy to skip such tests using decorators. Marking a test with @unittest.skipUnless ensures it only runs on the intended platform.

In this example, the test will only run on Linux. If you try running it on any other platform, it will be marked as "skipped" in the test output, making it clear that it is intentionally not run.

2. Customize the Test Runner

In most cases, the default test runner provided by unittest is sufficient. However, there may be situations where you want more control over how tests are run and how results are displayed. For these cases, you can build a custom test runner. This allows you to customize the test discovery process, control test order, and even add custom reporting.

This custom test runner automatically discovers all test files that match the pattern test_*.py in the current directory and runs them. It also uses high verbosity, making it clear which tests passed or failed. Such a setup is perfect for larger projects, where manually running individual test files becomes inefficient.

💡 Pro Tip

Keeping up with unit tests by hand takes a lot of time and can easily lead to mistakes. With Zencoders Unit Test Agents, you can automatically create realistic, editable unit tests that follow your existing test patterns and coding standards, saving time by generating both test and implementation code.

3. Organize Large Test Suites

As your project grows, so does your test suite and manually listing all test files becomes impractical. To keep your tests organized and manageable, you can use a dynamic test suite. This setup automatically discovers and groups all test files in a specified directory, making it easy to run them together.

4. Mock External Dependencies

Unit tests should be fast, reliable, and independent of external factors. However, some code may rely on external services, such as web APIs, databases, or file systems. To ensure your tests are not affected by these external dependencies, you can use unittest.mock to replace them with fake versions.

In this example, the requests.get method is replaced with a mock object that returns a fake response. This ensures that the test is fast and does not depend on an actual network connection.

How Can Zencode Help You With Unit Testing

Zencoder is an advanced AI-powered coding agent that enhances your software development lifecycle (SDLC) by boosting productivity, accuracy, and innovation. With an AI-powered unit test generator, it automatically creates and runs detailed tests for various scenarios, helping you maintain high-quality, bug-free code. Zencoder integrates with your existing development tools, supporting over 70 programming languages, including Python, Java, JavaScript, and more, and works effortlessly with popular IDEs like Visual Studio Code and JetBrains.

Additionally, with its powerful Repo Grokking™ technology, Zencoder analyzes your entire codebase, identifying structural patterns, architectural logic, and custom implementations. This deep, context-aware understanding allows Zencoder to deliver precise recommendations that significantly enhance code writing, debugging, and optimization.

Here are some of Zencoder's key features:

1️⃣ Integrations – Zencoder seamlessly integrates with over 20 developer environments, simplifying your entire development lifecycle. It is the only AI coding agent offering this extensive level of integration.

2️⃣  Coding Agent – No more endless debugging or time-consuming refactoring. Our intelligent coding assistant streamlines your development process by:

• Quickly identifying and fixing bugs, cleaning up broken code, and seamlessly managing tasks across multiple files.
• Automating repetitive or complex tasks with intelligent workflows, saving you valuable time and effort.
• Accelerating full app development, so you can concentrate on creative, high-impact work that truly makes a difference.

3️⃣ Code Generation – Speed up your development with smart, context-aware code generation. Quickly insert clean, production-ready code into your project, ensuring consistency, improving productivity, and helping you code faster.

4️⃣ Code Completion – Enhance your coding efficiency with intelligent, real-time suggestions. It understands your current context, offering precise and relevant code completions to reduce errors and maintain a smooth workflow.

5️⃣ Zen Agents – Bring the power of Zencoder’s intelligence to your entire organization.

Zen Agents are customizable AI teammates that understand your code, connect with your tools, and are ready to launch in seconds.

Here’s what you can do:

• Build smarter – Create specialized agents for tasks like pull request reviews, testing, or refactoring, customized to fit your architecture and frameworks.
• Integrate quickly – Connect to tools like Jira, GitHub, and Stripe in minutes using our no-code MCP interface, so agents can work seamlessly within your workflows.
• Deploy instantly – Deploy agents across your organization with a single click, with auto-updates and shared access ensuring alignment and scalable expertise.
• Explore the marketplace – Browse a growing library of open-source, pre-built agents ready to plug into your workflow. Discover what others are building, or contribute your own to help the community move faster.

6️⃣ Code Review Agent – Get targeted code reviews for anything from full files to individual lines. Receive clear, actionable feedback to improve code quality, boost security, and ensure best practices are followed.

7️⃣ Custom Agents – Create agents tailored to your team’s unique workflow. Harness advanced code understanding and automation to develop specialized solutions for your most important tasks.

8️⃣ Docstring Generation – Automatically generate clear, detailed documentation and inline comments, perfectly aligned with your existing style guidelines and project standards.

9️⃣ Security treble – Zencoder is the only AI coding agent with SOC 2 Type II, ISO 27001 & ISO 42001 certification.

Sign up today and automate your unit testing with our powerful features!