{"id":429,"date":"2023-06-11T10:43:29","date_gmt":"2023-06-11T10:43:29","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=429"},"modified":"2023-08-23T16:21:49","modified_gmt":"2023-08-23T16:21:49","slug":"pytest-mock-tdd-best-practices","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/","title":{"rendered":"Testing in Python: PyTest, Mock, and TDD Best Practices"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

Testing in Python, or any other programming language, plays an essential role in the software development life cycle. It enables developers to identify and fix bugs early, validate system functionality, and ensure the reliability and stability of the software application.<\/p>\n\n\n\n

Python, with its vast ecosystem of libraries, offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock (Mock), and the methodology of Test-Driven Development (TDD) stand out as particularly noteworthy. They not only help to detect bugs but also guide the overall design of the software, making it more maintainable and scalable.<\/p>\n\n\n\n

In this article, we will explore these three pillars of Python testing: PyTest, an elegant and feature-rich testing framework; Mock, a powerful tool for simulating system components; and TDD, a development methodology that emphasizes writing tests before writing the actual code. The approach in this article will be hands-on, practical, and filled with code examples to illustrate the concepts. We aim to target developers who are already familiar with Python and are seeking to deepen their understanding of testing practices in Python.<\/p>\n\n\n\n

PyTest: An Overview<\/h2>\n\n\n\n

PyTest is a mature full-featured Python testing tool that provides a simple, yet powerful, way to create and execute tests. It promotes more readable and flexible tests, thanks to its use of plain assert statements, auto-discovery of test modules, detailed error reports, and a wealth of useful features such as fixtures, parametrization, and markers.<\/p>\n\n\n\n

Unlike other testing frameworks that require boilerplate code to set up and run tests, PyTest offers a straightforward and more Pythonic way to write tests. Its rich feature set and the ease with which it allows tests to be written are reasons why PyTest is often the preferred testing tool for many Python developers.<\/p>\n\n\n\n

For instance, to write a basic test case in PyTest, we can simply define a function whose name starts with test_<\/code> and write assertions inside it:<\/p>\n\n\n

def<\/span> test_sum<\/span>()<\/span>:<\/span>\n    assert<\/span> sum([1<\/span>, 2<\/span>, 3<\/span>]) == 6<\/span>, \"Should be 6\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
To run the test, we would execute pytest<\/code> in the terminal, and it automatically discovers and runs the test.<\/p>\n\n\n\n
One of the key strengths of PyTest lies in its advanced features. PyTest fixtures, for example, provide a simple way to set up and tear down test environments, making tests more reliable and easier to understand. A fixture is a function decorated with @pytest.fixture<\/code>:<\/p>\n\n\n
import<\/span> pytest\n\n@pytest.fixture<\/span>\ndef<\/span> sample_list<\/span>()<\/span>:<\/span>\n    return<\/span> [1<\/span>, 2<\/span>, 3<\/span>]\n\ndef<\/span> test_sum<\/span>(sample_list)<\/span>:<\/span>\n    assert<\/span> sum(sample_list) == 6<\/span>, \"Should be 6\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Test parametrization is another powerful PyTest feature. It allows for testing a function with multiple sets of input data, enhancing the efficiency of the tests:<\/p>\n\n\n
@pytest.mark.parametrize(\"test_input,expected\", [(3,5), (2,4), (6,8)])<\/span>\ndef<\/span> test_add_two<\/span>(test_input, expected)<\/span>:<\/span>\n    assert<\/span> add_two(test_input) == expected<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
PyTest markers are used to categorize tests. For example, the @pytest.mark.slow<\/code> marker might be used to tag a test that takes a long time to run:<\/p>\n\n\n
@pytest.mark.slow<\/span>\ndef<\/span> test_large_computation<\/span>()<\/span>:<\/span>\n    ...<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
We can run pytest -m slow<\/code> to only run tests marked as slow, or pytest -m \"not slow\"<\/code> to exclude them.<\/p>\n\n\n\n
These features – fixtures for setup and teardown, parametrization for data-driven tests, and markers for categorizing tests – make PyTest a flexible and powerful tool for testing in Python.<\/p>\n\n\n\n
Mocking in Python with unittest.mock<\/h2>\n\n\n\n
Mocking is a powerful testing technique that simulates behavior of real objects in controlled ways. It is extensively used when we want to mimic the behavior of other parts of a system that are not directly involved in the test. By controlling the outputs of these parts of the system, we can more precisely verify the functionality of the code under test.<\/p>\n\n\n\n
The unittest.mock<\/code> module, built into Python’s standard library, is a versatile tool for creating these mock objects. It allows you to replace parts of your system with mock objects and make assertions about how they have been used.<\/p>\n\n\n\n
At its core, the unittest.mock.Mock<\/code> class creates a new mock object. Here’s a simple example:<\/p>\n\n\n
from<\/span> unittest.mock import<\/span> Mock\n\n# Create a mock object<\/span>\nmock = Mock()\nmock.return_value = 'Hello, World!'<\/span>\n\n# Use the mock object<\/span>\nresult = mock()\n\n# Assert the mock was called<\/span>\nmock.assert_called()\nassert<\/span> result == 'Hello, World!'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we’ve created a mock object mock<\/code> that returns ‘Hello, World!’ when called.<\/p>\n\n\n\n
The unittest.mock<\/code> module also includes MagicMock<\/code>, a subclass of Mock<\/code> with default implementations of most of the magic methods (e.g., __getitem__<\/code>, __iter__<\/code>, __len__<\/code>).<\/p>\n\n\n\n
Patching is another important feature provided by the unittest.mock<\/code> module. The patch()<\/code> function is used to replace the real objects in your code with mocks, and revert this change after the test:<\/p>\n\n\n
from<\/span> unittest.mock import<\/span> patch\n\ndef<\/span> test_function<\/span>()<\/span>:<\/span>\n    with<\/span> patch('module.ClassName'<\/span>) as<\/span> MockClass:\n        instance = MockClass.return_value\n        instance.method.return_value = 'foo'<\/span>\n        \n        from<\/span> module import<\/span> ClassName\n        assert<\/span> ClassName().method() == 'foo'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we have patched a class ClassName<\/code> in module<\/code>, replacing it with a mock. Inside the test function, any code that imports ClassName<\/code> from module<\/code> will get our mocked class instead.<\/p>\n\n\n\n
With patch()<\/code>, we can isolate the code under test, and have full control over the behavior of its dependencies. This makes our tests more predictable and easier to understand, as they aren’t affected by the underlying system state or the behavior of external services.<\/p>\n\n\n\n
Utilizing the Mock and patching features of the unittest.mock<\/code> module allows us to simulate complex scenarios and edge cases that would be hard to recreate with actual objects. In this way, we can write more comprehensive and reliable tests for our Python code.<\/p>\n\n\n\n
Test-Driven Development (TDD) Explained<\/h2>\n\n\n\n
Test-Driven Development (TDD) is a software development approach where tests are written before the actual code. The process consists of short, iterative development cycles, with each one following three simple steps: Red, Green, and Refactor.<\/p>\n\n\n\n
    \n
  • Red<\/strong>: Write a failing test. This test should represent a small piece of functionality that doesn’t exist yet.<\/li>\n\n\n\n
  • Green<\/strong>: Write just enough code to make the test pass. It doesn’t have to be perfect – it just needs to pass the test.<\/li>\n\n\n\n
  • Refactor<\/strong>: Clean up the code while keeping the tests green. Remove duplication, improve readability, and simplify the code.<\/li>\n<\/ul>\n\n\n\n
    TDD provides numerous benefits. By writing tests first, we can clarify our requirements and expectations. It forces us to consider edge cases early in the development process, leading to more robust software. The tests serve as documentation that can help new team members understand the codebase. Finally, TDD also facilitates refactoring, as the extensive test suite provides a safety net that helps prevent regressions.<\/p>\n\n\n\n
    Let’s illustrate the TDD process by implementing a simple feature: a function that reverses a string.<\/p>\n\n\n\n
    First, we write a test for this function:<\/p>\n\n\n
    def<\/span> test_reverse_string<\/span>()<\/span>:<\/span>\n    assert<\/span> reverse_string(\"hello\"<\/span>) == \"olleh\"<\/span>, \"Should be 'olleh'\"<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    If we run this test with PyTest now, it would fail because we haven’t defined reverse_string<\/code> yet. This is the “Red” phase of our TDD cycle.<\/p>\n\n\n\n
    Next, we write just enough code to pass this test:<\/p>\n\n\n
    def<\/span> reverse_string<\/span>(s)<\/span>:<\/span>\n    return<\/span> s[::-1<\/span>]<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Now if we run the test again, it passes – the “Green” phase.<\/p>\n\n\n\n
    Finally, in the “Refactor” phase, we would look for any improvements we could make. In this simple example, there isn’t much to refactor, but in a more complex situation, this might involve removing duplicated code, improving performance, or making the code more readable.<\/p>\n\n\n\n
    This simple example demonstrates the core principles of TDD. By following this cycle – Red, Green, Refactor – we can ensure that our codebase is well-tested and easier to maintain and understand.<\/p>\n\n\n\n
    Integrating PyTest, Mock, and TDD: Best Practices<\/h2>\n\n\n\n
    PyTest, Mock, and Test-Driven Development (TDD) can be combined in a powerful synergy to produce high-quality Python code. Each one addresses a different aspect of testing but they complement each other perfectly, forming a comprehensive and robust testing strategy.<\/p>\n\n\n\n
    At the intersection of these three lies the idea of writing tests first (TDD), implementing features, and using Mock to isolate code dependencies. This process ensures a tight feedback loop, promoting the development of well-tested, decoupled, and maintainable code.<\/p>\n\n\n\n
    Here’s an example. Let’s consider we’re developing a feature for a weather application that retrieves weather data from an external API and processes it:<\/p>\n\n\n\n
    First, we write a test for our new feature:<\/p>\n\n\n
    from<\/span> unittest.mock import<\/span> patch\n\n@patch('weather_app.weather_api.get_weather_data')<\/span>\ndef<\/span> test_process_weather_data<\/span>(mock_get_weather_data)<\/span>:<\/span>\n    mock_get_weather_data.return_value = {'temp'<\/span>: 20<\/span>, 'humidity'<\/span>: 80<\/span>}\n    \n    result = process_weather_data('London'<\/span>)\n    assert<\/span> result == 'The temperature in London is 20\u00b0C with a humidity of 80%.'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    This test checks whether our process_weather_data<\/code> function correctly formats the weather data. We use Mock to replace the actual API call with a mock object, isolating our function from external dependencies.<\/p>\n\n\n\n
    Next, we implement the feature to make the test pass:<\/p>\n\n\n
    from<\/span> weather_app.weather_api import<\/span> get_weather_data\n\ndef<\/span> process_weather_data<\/span>(city)<\/span>:<\/span>\n    data = get_weather_data(city)\n    return<\/span> f'The temperature in {city}<\/span> is {data[\"temp\"<\/span>]}<\/span>\u00b0C with a humidity of {data[\"humidity\"<\/span>]}<\/span>%.'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this manner, we follow TDD principles, while using PyTest for testing and Mock for isolating dependencies.<\/p>\n\n\n\n
    Several best practices should be followed when integrating PyTest, Mock, and TDD.<\/p>\n\n\n\n
      \n
    • Design for testability: Strive to make your functions pure (i.e., same input always produces the same output) and avoid global state. This makes your code easier to test and reason about.<\/li>\n\n\n\n
    • Appropriate use of Mock: While Mock is a powerful tool, it can be overused. Over-mocking can lead to tests that don’t really test the code’s behavior but only its implementation details. Aim to use Mock sparingly and only when necessary to isolate external dependencies or test edge cases.<\/li>\n\n\n\n
    • Understand your tests: Each test should have a clear purpose. If a test fails, it should be immediately clear what part of your application is broken.<\/li>\n\n\n\n
    • Red, Green, Refactor: Follow the TDD mantra. Write a failing test first (Red), make it pass with minimal code (Green), and then improve the code while keeping the tests passing (Refactor).<\/li>\n<\/ul>\n\n\n\n
      Continuous Integration\/Continuous Deployment (CI\/CD) pipelines also play a crucial role in modern software development. Having a robust set of tests is crucial in CI\/CD as it ensures that any new change to the codebase does not break existing functionality. Tests should be run automatically on each commit to provide immediate feedback. Ideally, no code should be merged into the main branch unless all tests pass.<\/p>\n\n\n\n
      Advanced Topics<\/h2>\n\n\n\n
      Once you’ve mastered the fundamentals of testing in Python with PyTest, Mock, and TDD, there are a variety of advanced topics you can explore to further enhance your testing capabilities.<\/p>\n\n\n\n
      One such topic is property-based testing. Instead of specifying the input and output pairs as in traditional testing, property-based testing allows you to describe properties that the output should have for a range of input values. The Hypothesis library is a popular tool for property-based testing in Python and integrates smoothly with PyTest.<\/p>\n\n\n\n
      Testing asynchronous code can present unique challenges, but PyTest has excellent support for asyncio through the pytest-asyncio plugin. It allows you to write tests for your asyncio code much like you would for synchronous code:<\/p>\n\n\n
      import<\/span> pytest\nimport<\/span> asyncio\n\n@pytest.mark.asyncio<\/span>\nasync<\/span> def<\/span> test_some_asyncio_code<\/span>()<\/span>:<\/span>\n    result = await<\/span> some_asyncio_code()\n    assert<\/span> result == 'expected result'<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
      Moreover, the unittest.mock<\/code> module includes advanced features such as sentinels and call objects. Sentinels are unique objects used to signify special meanings in your tests, and call objects help in asserting the calls made to the mock.<\/p>\n\n\n\n
      The depth and breadth of testing in Python are vast, and these advanced topics provide a glimpse into the additional capabilities you can unlock. By continuously learning and applying these techniques, you can become a master of testing in Python.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Introduction Testing in Python, or any other programming language, plays an essential role in the software development life cycle. It enables developers to identify and fix bugs early, validate system functionality, and ensure the reliability and stability of the software application. Python, with its vast ecosystem of libraries, offers a plethora of tools and frameworks […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[4,6],"tags":[],"class_list":["post-429","post","type-post","status-publish","format-standard","category-programming-languages","category-python","entry"],"yoast_head":"\nTesting in Python: PyTest, Mock, and TDD Best Practices<\/title>\n<meta name=\"description\" content=\"Python offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Testing in Python: PyTest, Mock, and TDD Best Practices\" \/>\n<meta property=\"og:description\" content=\"Python offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-06-11T10:43:29+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-08-23T16:21:49+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Testing in Python: PyTest, Mock, and TDD Best Practices\",\"datePublished\":\"2023-06-11T10:43:29+00:00\",\"dateModified\":\"2023-08-23T16:21:49+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/\"},\"wordCount\":1692,\"commentCount\":0,\"articleSection\":[\"Programming Languages\",\"Python\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/\",\"name\":\"Testing in Python: PyTest, Mock, and TDD Best Practices\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-06-11T10:43:29+00:00\",\"dateModified\":\"2023-08-23T16:21:49+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Python offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/pytest-mock-tdd-best-practices\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Testing in Python: PyTest, Mock, and TDD Best Practices\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Testing in Python: PyTest, Mock, and TDD Best Practices","description":"Python offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/","og_locale":"en_US","og_type":"article","og_title":"Testing in Python: PyTest, Mock, and TDD Best Practices","og_description":"Python offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock","og_url":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/","article_published_time":"2023-06-11T10:43:29+00:00","article_modified_time":"2023-08-23T16:21:49+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Testing in Python: PyTest, Mock, and TDD Best Practices","datePublished":"2023-06-11T10:43:29+00:00","dateModified":"2023-08-23T16:21:49+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/"},"wordCount":1692,"commentCount":0,"articleSection":["Programming Languages","Python"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/","url":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/","name":"Testing in Python: PyTest, Mock, and TDD Best Practices","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-06-11T10:43:29+00:00","dateModified":"2023-08-23T16:21:49+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Python offers a plethora of tools and frameworks designed to streamline and optimize the testing process. Among them, PyTest, unittest.mock","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/pytest-mock-tdd-best-practices\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Testing in Python: PyTest, Mock, and TDD Best Practices"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780747165","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/429","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=429"}],"version-history":[{"count":7,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/429\/revisions"}],"predecessor-version":[{"id":436,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/429\/revisions\/436"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=429"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=429"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=429"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}