Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Python Unit Testing with FastAPI and Pytest Tutorial

Added: 2026-08-06

Deep Dive

Fundamental knowledge of Python programming, including decorators, asynchronous programming (async/await), and external package management.

Основы асинхронности в Python #7: Asyncio, async/await

Основы асинхронности в Python #7: Asyncio, async/await

115K

In Python 3.4, coroutines were created using the @coroutine decorator from asyncio. This decorator transforms a generator function into a coroutine. The decorator can be verified using inspect.isgeneratorfunction(), which returns True for coroutines. The decorator handles the conversion of generator functions into coroutine objects that can be scheduled by the event loop.

Click to watch →

Expert Python Tutorial #4 - Decorators

Expert Python Tutorial #4 - Decorators

125.4K

Python's @decorator_name syntax simplifies applying decorators, replacing manual assignment with cleaner code. The decorator function receives the target function, creates a wrapper that executes additional logic before/after calling the target, and returns this wrapper. This allows consistent behavior modification across multiple functions without code duplication.

Click to watch →

19-实操异步编程｜小甲鱼翻译作品——微软官方推出的 Python 进阶教程

19-实操异步编程｜小甲鱼翻译作品——微软官方推出的 Python 进阶教程

104

Async/await in Python enables concurrent execution of multiple I/O-bound operations without blocking the main thread, allowing the program to perform other work while waiting for operations to complete. Unlike synchronous programming where operations execute sequentially (e.g., a 2-second delay followed by a 3-second delay takes 6.3 seconds total), async/await allows multiple operations to run simultaneously, reducing total execution time (e.g., completing the same operations in approximately 3.3 seconds). This is achieved using libraries like aiohttp and requires Python 3.7 or higher.

Click to watch →

Декораторы в Python [GeekBrains]

Декораторы в Python [GeekBrains]

9.7K

A decorator is a wrapper that adds functionality before and after a function executes without modifying the original code. In Python, functions are first-class objects that can be assigned to variables, passed as arguments, and returned from other functions. Functions defined inside other functions have limited scope and are not visible outside the enclosing function. Functions can return other functions as objects, which is fundamental to understanding decorators. When a function returns another function, you must call the returned function to execute it. Decorators allow extending function capabilities, simplifying debugging, and applying the same code to multiple functions without rewriting it each time. A basic decorator is created by defining a function that takes another function as an argument, defines a wrapper function that executes code before and after the original function, and returns the wrapper function. The @decorator syntax is syntactic sugar for this wrapping process. When multiple decorators are applied to a function, they execute from bottom to top (innermost to outermost), and the order of decorator declarations matters because each decorator wraps the result of the previous one.

Click to watch →

Decorators in Python: The Complete Guide

Decorators in Python: The Complete Guide

6.9K

Decorators are functions that modify or enhance other functions without altering their core functionality. The fundamental structure involves creating a decorator function that accepts another function as an argument, defining a wrapper function inside it, and returning the wrapper. To apply a decorator, use the @ symbol followed by the decorator name before the target function. Practical examples demonstrate creating a timer decorator using time module functions to measure execution duration, and implementing *args and **kwargs in wrapper functions to ensure decorators work with any function signature, enabling reuse across different functions.

Click to watch →

Deep Dive

Basic understanding of RESTful API concepts, HTTP methods (GET, POST, PUT, DELETE), and HTTP status codes.

9) Rest API Nedir ? | SPRİNG Dersleri

9) Rest API Nedir ? | SPRİNG Dersleri

11.7K

REST APIs use four primary HTTP methods: GET retrieves data (read), POST creates new data (create), DELETE removes data, and PUT updates existing data. These follow the CRUD pattern. HTTP status codes indicate request outcomes: 200 means success, 400 indicates bad request syntax, 401 shows unauthorized access (expired token), 403 means forbidden access (insufficient permissions), 404 indicates resource not found, and 500 signals server-side errors. Client-side errors (400 series) result from request problems, while server-side errors (500 series) indicate server failures. Understanding these codes helps developers diagnose and resolve communication issues in web applications.

Click to watch →

#15 Spring Web Http methods GET and POST

#15 Spring Web Http methods GET and POST

107.5K

REST (Representational State Transfer) APIs use HTTP protocols to communicate between clients and servers. The core operations include fetching data (GET), storing data (POST), updating data (PUT), and deleting data (DELETE). These correspond to CRUD operations. Status codes indicate request outcomes: 200 series for success, 400 series for client errors (like 404 Not Found), and 500 series for server errors. Tools like Postman allow developers to test these APIs by sending HTTP requests and inspecting responses including bodies, headers, and status codes.

Click to watch →

[ExpressJS] | #3 Cách sử dụng method GET, POST, PUT, DELETE chuẩn Restful API | Nodemy

[ExpressJS] | #3 Cách sử dụng method GET, POST, PUT, DELETE chuẩn Restful API | Nodemy

21.2K

In RESTful API design, four fundamental HTTP methods serve distinct purposes: GET retrieves data (including all items via GET / or specific items via GET /:id), POST creates new resources by sending data in the request body, PUT updates or replaces existing resources, and DELETE removes resources from the server. These methods form the foundation of CRUD (Create, Read, Update, Delete) operations in modern web applications.

Click to watch →

How the Internet Works for Developers - Pt 1 - Overview & Frontend

How the Internet Works for Developers - Pt 1 - Overview & Frontend

575.6K

HTTP defines four primary methods for interacting with web servers. GET requests retrieve resources and are typically used for reading data. POST requests submit data to create new resources, commonly used for logins and form submissions. PUT requests update existing resources by specifying an ID in the path. DELETE requests remove resources identified by their ID. Together, these methods form the foundation of RESTful API design.

Click to watch →

Requisições HTTP: GET, POST, PUT, PATCH DELETE, aprenda de uma vez por todas!

Requisições HTTP: GET, POST, PUT, PATCH DELETE, aprenda de uma vez por todas!

30K

HTTP verbs are standardized methods used to communicate with web services: GET retrieves data from a server, POST creates new resources by sending data in the request body, PUT replaces or updates all data for a resource, PATCH performs partial updates by sending only changed fields, and DELETE removes resources from the server. Each verb corresponds to specific HTTP response codes (200-299 for success, 400-499 for client errors, 500-599 for server errors) that indicate the outcome of the request.

Click to watch →

Deep Dive

Familiarity with the FastAPI framework, including route definition, path/query parameters, and Pydantic schemas for data validation.

Curso de FastAPI - Criando Rotas CRUD | Aula 03

Curso de FastAPI - Criando Rotas CRUD | Aula 03

18.3K

This lesson demonstrates how to implement CRUD (Create, Read, Update, Delete) operations in a FastAPI application using Pydantic schemas for data validation. The instructor shows how to define Pydantic models for user data (username, email, password), create endpoints with proper HTTP methods (POST for create, GET for read, PUT/PATCH for update, DELETE for delete), implement validation that returns 422 errors for invalid data, and use fixtures for testing. Key concepts include using Pydantic's EmailStr for email validation, creating separate schemas for public responses (excluding passwords), and handling 404 errors when resources don't exist.

Click to watch →

Curso de FastAPI - Criando Rotas CRUD 2025 | Aula 03

Curso de FastAPI - Criando Rotas CRUD 2025 | Aula 03

8.2K

This lesson demonstrates how to implement CRUD (Create, Read, Update, Delete) operations in a FastAPI application using Pydantic schemas for data validation. The instructor shows how to define Pydantic models (UserSchema, UserPublic, UserDB) to validate incoming request data and structure response data, create endpoints using @app.post, @app.get, @app.put, and @app.delete decorators, and write automated tests using pytest with fixtures to ensure API reliability. The course emphasizes the relationship between HTTP methods (POST, GET, PUT, DELETE), status codes (201 for created, 200 for success, 404 for not found, 422 for validation errors), and proper error handling using HTTPException.

Click to watch →

FastAPI for Beginners - Python Web Framework

FastAPI for Beginners - Python Web Framework

145.7K

FastAPI routes are created using decorators like `@app.get("/")` specifying HTTP methods and paths. The same endpoint handles multiple operations based on HTTP method: GET retrieves data, POST creates resources, PUT updates existing resources, and DELETE removes resources. Pydantic automatically validates incoming data against predefined models, returning errors for invalid input. This eliminates manual validation code and ensures data integrity before processing.

Click to watch →

Introduction To FastAPI- How To Create API's Using FastAPI- Data Science

Introduction To FastAPI- How To Create API's Using FastAPI- Data Science

112.8K

FastAPI routes are defined using decorators like @app.get() for HTTP GET requests. The decorator takes a path parameter that specifies the URL endpoint. When a user accesses this endpoint, the corresponding function is executed and its return value is automatically converted to JSON and sent as the HTTP response. FastAPI supports path parameters, query parameters, and body parameters for receiving client data. Path parameters are extracted from the URL path and passed as arguments to the route handler function. The framework automatically validates that parameters match the expected type defined in the route path.

Click to watch →

FastAPI полный курс от А до Я | Часть 1 [Junior]

FastAPI полный курс от А до Я | Часть 1 [Junior]

22K

Request body parameters (used with POST/PUT/PATCH) are not visible in URLs and can contain more data than query parameters. For request bodies, FastAPI requires Pydantic models to describe expected data structures. Pydantic models are created by inheriting from BaseModel and defining attributes with their types. These models validate request body data and automatically generate documentation showing expected JSON structure. FastAPI supports receiving multiple parameters in request bodies by declaring multiple models. Lists of objects can be handled by declaring parameters as lists. To make parameters optional, use Optional[T] from typing module or the built-in | operator in Python 3.10+. For list parameters, use Optional[List[User]] = [] with empty list as default. The framework performs automatic validation based on declared types, returning appropriate error messages if validation fails.

Click to watch →

Deep Dive

General concepts of software testing, particularly the distinction between unit tests, integration tests, and the purpose of test assertions.

Software Testing Explained in 100 Seconds

Software Testing Explained in 100 Seconds

468.6K

Automated tests are organized in files ending in 'test' or '.spec'. A test suite describes the feature being tested and contains individual tests. Each test starts with 'it' followed by a description of what is being tested, written in human-readable terms. Inside the test, code executes and expectations/assertions check if results match expectations. If an assertion returns false, the test fails; if true, it passes.

Click to watch →

Aprendiendo testing. No demasiados. Sobretodo unitarios.

Aprendiendo testing. No demasiados. Sobretodo unitarios.

2.3K

Unit tests in Vitest use a specific structure: describe() for test titles, it() for individual test cases, and expect() for assertions. The expected value is what the function should return, and the actual value is what the function actually returns. Tests should verify both expected output and object structure. For functions returning objects, tests should verify specific properties rather than entire object structures. Good test naming follows the pattern: [Function Name] [Input] [Expected Output], making test suites self-documenting.

Click to watch →

Building an Example of a Real-World Apache Camel Application Pt.7 | Testing JMS Route

Building an Example of a Real-World Apache Camel Application Pt.7 | Testing JMS Route

106

Integration tests send messages to the route's starting endpoint with appropriate headers (document ID, owner ID, client ID, database log ID). Use @MockEndpoint to verify that the expected message is received by the mock endpoint. Assert that the message count is correct and the message body matches the expected response. Wait for assertions to be satisfied using a timeout.

Click to watch →

Pruebas Unitarias con JUnit

Pruebas Unitarias con JUnit

1.1K

Assertions are expressions that validate logical conditions in unit tests. For a test to be satisfactory, the assertion must evaluate to true; otherwise, the test fails. Different assertion types exist based on method return types: assertEquals for comparing values (two parameters: expected and actual), assertTrue for boolean true results, assertFalse for boolean false results, and assertNull for verifying null returns. Each assertion type serves a specific validation purpose depending on what the method under test returns.

Click to watch →

Pruebas Unitarias y de Integración en .NET con xUnit

Pruebas Unitarias y de Integración en .NET con xUnit

7.8K

Unit tests should verify that methods return expected results. For example, 'Assert.True(year >= 2021)' verifies that the year is greater than or equal to 2021. Different assertion methods (Assert.Equal, Assert.True, Assert.False) serve different purposes in test verification. Well-designed tests should not require frequent updates. For example, a test that verifies 'year >= 2021' will continue to pass in 2022 without modification. This stability reduces maintenance overhead and ensures tests remain valid over time.

Click to watch →

Test Setup

Test Read

Test Create

Test Update

Test Delete

Test Setup

0:00

Playing Section

1
Create a virtual environment and install FastAPI, uvicorn, Pytest, and httpx.
2
Import TestClient and configure it with the FastAPI app instance.
3
Define a setup function to clear mock data before each test.

Deep Dive

Mastering advanced Pytest features, such as writing custom fixtures, test parametrization, and mocking external services or databases using 'pytest-mock'.

Learn how to use pytest 💪📃

Learn how to use pytest 💪📃

157

Pytest provides fixtures for reusable test setup and teardown, similar to unittest's setup/teardown methods. Fixtures can be defined in test files or in conftest.py which Pytest runs before other tests. Use @pytest.fixture decorator to create fixtures that return test data. Type hints improve fixture clarity. Parameterized tests enable running the same test with multiple inputs using @pytest.mark.parametrize decorator. Create a comma-separated list of parameter names and a list of tuples containing test values. This allows efficient testing of multiple scenarios without duplicating test code.

Click to watch →

Please Learn How To Write Tests in Python… • Pytest Tutorial

Please Learn How To Write Tests in Python… • Pytest Tutorial

150.2K

To use pytest, install it via pip using the command 'pip install pytest' (or 'pip3 install pytest' on Mac/Linux). Additionally, pytest-mock should be installed using 'pip install pytest-mock' or 'pip3 install pytest-mock' to enable mocking capabilities for testing dependencies.

Click to watch →

Python - Тестирование

Python - Тестирование

9.9K

Pytest provides various decorators for test control: @pytest.mark.xfail marks tests expected to fail, @pytest.mark.skip skips tests, and @pytest.mark.parametrize enables parameterized testing. @pytest.mark.parametrize allows running a single test function with multiple input sets, useful for testing functions with various inputs. Test fixtures are functions decorated with @pytest.fixture that run before tests. They handle test setup and teardown, such as creating test data, initializing databases, or setting up test environments. Fixtures can be parameterized to run once per test or once per module. They can be chained, where one fixture calls another, creating a hierarchy of setup operations. This keeps test code clean and reusable while ensuring consistent test environments.

Click to watch →

Продвинутое использование py test, Андрей Светлов, Python Core Developer

Продвинутое использование py test, Андрей Светлов, Python Core Developer

36.2K

Pytest provides powerful advanced features including fixtures for test setup/teardown with dependency management, hooks for customizing test behavior (like adding command-line options and version-specific test skipping), and parameterization for running tests with different configurations, making it more flexible and efficient than standard unittest for complex testing scenarios.

Click to watch →

PyTest - testes profissionais para seus códigos Python

PyTest - testes profissionais para seus códigos Python

1.1K

Pytest enables testing business rules that should prevent invalid inputs. The 'raise' statement creates custom errors with specific messages. The '-v' flag provides verbose output showing each test function and its pass/fail status. The 'pytest.raises' context manager tests that functions raise specific exceptions, essential for testing error handling. The '@pytest.fixture' decorator creates reusable setup mechanisms that execute code before tests, return values for use, and ensure test isolation by recreating setup for each test. The '@pytest.mark.parametrize' decorator runs the same test function with multiple parameter combinations, enabling testing the same logic with different inputs (e.g., different discount percentages) in a single test function, reducing code duplication while thoroughly testing various scenarios.

Click to watch →

Deep Dive

Implementing database testing strategies, including setting up an isolated test database container and utilizing transactional rollbacks for clean state management.

02.02. Test automation (Курс Основы .NET)

02.02. Test automation (Курс Основы .NET)

447

Testing can be categorized by level and purpose: (1) Unit testing - testing individual modules/classes in isolation; (2) Integration testing - testing interactions between multiple modules; (3) System testing - testing the complete application including UI and databases; (4) Functional testing - verifying program behavior matches requirements; (5) Non-functional testing - performance, stress, and security testing. Database testing requires special handling: each test should run on a clean database state achieved through transaction rollback. Tools like SQL Server Data Tools enable modular database testing by creating transactions, executing test operations, verifying results, and rolling back to restore original state.

Click to watch →

테스트에서의 @Transactional 사용에 대해 질문이 있습니다 - Toby vs ChatGPT (2)

테스트에서의 @Transactional 사용에 대해 질문이 있습니다 - Toby vs ChatGPT (2)

7.2K

Database-dependent tests face a critical isolation problem: tests sharing the same database can interfere with each other. Operations in one test (like inserting a user) can affect subsequent tests (like checking user count), violating the principle that tests should produce consistent results regardless of execution order. Spring's @Transactional annotation with rollback behavior provides a solution by wrapping test methods in transactions. If tests complete successfully, changes commit; if they fail, changes rollback. This ensures each test starts with a clean database state. Spring introduced this feature in version 1.1.2 (2004), making database testing significantly more convenient by eliminating manual cleanup code.

Click to watch →

Гурий Самарин — Тестируем код, взаимодействующий с базой данных

Гурий Самарин — Тестируем код, взаимодействующий с базой данных

1.3K

This section addresses test isolation requirements and data cleanup automation strategies. When testing on a shared database instance, developers interfere with each other's tests and corrupt each other's data. Each developer should have their own isolated database instance. The section covers four approaches to return databases to predictable state: restore from backup, transaction rollback, cleanup at end, and cleanup at beginning (recommended). The most efficient cleanup approach is to determine the correct order of table deletion based on foreign key relationships, building a dependency graph to delete tables in the correct order. The section covers the Respawn library for database cleanup automation, which builds a dependency graph based on foreign keys and deletes tables in the correct order, handling cycles by first enabling constraints, clearing tables, and then disabling constraints. This approach is significantly faster than dropping and recreating databases. The section also covers Testcontainers vs in-memory databases like SQLite, explaining that Testcontainers provides production-like testing with real containers while in-memory databases are faster but have limitations including limited data type support and no procedural SQL support.

Click to watch →

The Common Entity Framework Mistake You MUST Fix

The Common Entity Framework Mistake You MUST Fix

54.2K

Testcontainers with Respawn provides a robust solution for integration testing with real databases. You configure a PostgreSQL container that spins up a real database instance specifically for testing. Respawn then handles resetting the database to a clean state before each test. The configuration involves setting up the container connection string, creating the container when tests start, and ensuring proper cleanup. This approach eliminates leftover test data and ensures each test runs against a pristine database state.

Click to watch →

Spring Boot Testcontainers - Integration Testing made easy!

Spring Boot Testcontainers - Integration Testing made easy!

60.4K

Mark integration tests as @Transactional so that any database changes made during the test are rolled back automatically after the test completes. This prevents test data from polluting the database and ensures each test starts with a clean state. The transaction management works seamlessly with Testcontainers-managed databases.

Click to watch →

Deep Dive

Integrating test suites into Continuous Integration (CI) pipelines (e.g., GitHub Actions, GitLab CI/CD) for automated quality assurance checks on pull requests.

CI/CD Tutorial using GitHub Actions - Automated Testing & Automated Deployments

CI/CD Tutorial using GitHub Actions - Automated Testing & Automated Deployments

242.9K

GitHub Actions enables automated CI/CD pipelines by creating YAML workflow files in the .github/workflows directory, where workflows can be triggered by events like pull requests or main branch pushes to automatically test code using actions like npm ci and Jest, and deploy code to production servers using SCP with SSH keys stored as GitHub secrets, thereby eliminating manual deployment errors and accelerating the development cycle.

Click to watch →

CI/CD para QA y Automatización: Comienza con GitHub Actions, Jenkins y Playwright paso a paso

CI/CD para QA y Automatización: Comienza con GitHub Actions, Jenkins y Playwright paso a paso

4.2K

CI/CD (Continuous Integration/Continuous Delivery) is essential for QA automation engineers. Continuous Integration enables developers to frequently deploy code changes to shared environments, triggering automated builds and tests. This allows QA to execute automated tests immediately after new builds, catching defects early. Unit tests verify individual methods, while API tests validate backend services. Continuous Delivery automatically deploys code to testing/staging environments but requires human approval for production. Continuous Deployment takes this further by automatically deploying to production when all tests pass. CI/CD provides significant QA benefits by running tests in consistent, isolated environments, eliminating issues from different operating systems and hardware configurations. Before integrating automation into CI/CD, the test framework must be mature and stable—'flaky tests' undermine credibility. Adequate test coverage following the testing pyramid is essential: many fast unit tests, fewer integration tests, and very few comprehensive end-to-end tests. Tests must be fully autonomous, initializing, executing, generating reports, and cleaning up resources without human intervention. Version control (Git) is required to manage test code and enable collaboration. GitHub Actions integrates directly with GitHub repositories, allowing test execution without cloning elsewhere. The workflow file defines triggers, runner environment, and steps (install dependencies, install browsers, run tests, upload reports). Environment variables and secrets are managed through repository settings, with sensitive data stored as secrets and accessed dynamically in workflows.

Click to watch →

DEVOPS et CI/CD (avec Github Actions)

DEVOPS et CI/CD (avec Github Actions)

18.2K

A complete CI/CD pipeline with GitHub Actions includes: (1) Frontend testing (Node.js) with checkout, Node.js setup, dependency installation, and test execution; (2) Backend testing with MySQL database services spawned via 'services' configuration, environment variables for database connections, and test execution; (3) Integration testing verifying API responses (status codes, JSON format, data validation); (4) Conditional execution (image building only on main branch pushes); (5) Matrix strategies for parallel execution of multiple components; (6) Docker registry authentication using GitHub tokens; (7) Image building and pushing to the repository owner's registry; (8) Secret management for sensitive values like database passwords; (9) Workflow monitoring and re-run capabilities.

Click to watch →

Lint Like a Senior Developer w/ eslint + husky + lint staged + github actions

Lint Like a Senior Developer w/ eslint + husky + lint staged + github actions

34.5K

This extensive section covers integrating ESLint into GitHub Actions for automated code quality enforcement. It details creating workflow YAML files in .github/workflows, configuring actions for code checkout, Node.js environment setup with LTS version selection, and pnpm installation via official GitHub actions. The video explains configuring triggers to run only on pull requests to the main branch, ensuring linting occurs before merges. Practical demonstrations include local testing with the act tool, debugging common issues like missing dependencies, and properly configuring ignore patterns for directories like pnpm store. The result is a robust CI pipeline that enforces code standards automatically for every contribution.

Click to watch →

CS50W - Lecture 7 - Testing and CI/CD

CS50W - Lecture 7 - Testing and CI/CD

169.5K

Continuous Integration (CI) involves frequent merges to a main branch with automatic unit tests on every push, preventing integration conflicts and catching regressions early. Continuous Delivery (CD) enables shorter release cycles, deploying changes incrementally rather than waiting for major releases. GitHub Actions implements CI/CD using YAML configuration files defining workflows triggered by repository events. Workflows run jobs on virtual machines with specified steps (installing dependencies, running tests). Failed commits show red indicators, while passing commits show green checks. This enforces testing requirements automatically, ensuring no untested code reaches production. Teams can add rules requiring tests to pass before merging code into main branches.

Click to watch →

Deep Dive

Measuring and analyzing test suite effectiveness using code coverage tools like 'coverage.py' or 'pytest-cov'.

GTAC 2016: Code Coverage is a Strong Predictor of Test Suite Effectiveness

GTAC 2016: Code Coverage is a Strong Predictor of Test Suite Effectiveness

3.6K

Research on 250 real-world programs demonstrates that code coverage is a strong predictor of test suite effectiveness, with covered statements having an 80% chance of detecting mutants and statement coverage predicting mutation score with 94% certainty; mutation score, while valuable, is expensive, inconsistent across tools, and provides only about 6% additional information beyond coverage, making coverage the best primary measure for evaluating test suite quality.

Click to watch →

what is coverage? (intermediate) anthony explains #480

what is coverage? (intermediate) anthony explains #480

4.7K

Code coverage measures which parts of your code are executed by tests, helping verify that tests actually validate your code; coverage.py implements this in Python by instrumenting the runtime using sys.settrace, allowing you to run tests with coverage run, generate reports with coverage report, and enforce minimum coverage thresholds to ensure comprehensive testing.

Click to watch →

テストでの網羅率を測ろう！！カバレッジ測定ができるpytest-covを解説！〜Python 初心者向け〜

テストでの網羅率を測ろう！！カバレッジ測定ができるpytest-covを解説！〜Python 初心者向け〜

9.5K

Code coverage measures what percentage of production code is executed when running test code, with different coverage standards (C0 for statement coverage, C1 for branch coverage, C2 for condition coverage, and MCC for modified condition/decision coverage) determining how thoroughly tests exercise the codebase. The pytest-cov tool enables developers to measure and report test coverage by specifying source and test directories, with options to measure different coverage types and generate HTML reports for detailed analysis.

Click to watch →

Automated Testing in Python with pytest, tox, and GitHub Actions

Automated Testing in Python with pytest, tox, and GitHub Actions

233.4K

Use --cov option in pytest configuration to measure test coverage. Coverage percentage indicates what proportion of executable code is exercised by tests. 100% coverage means all code lines are touched by tests, though this doesn't guarantee absence of bugs. Lower coverage indicates untested code paths that may contain errors. HTML reports show exact line-by-line coverage details for debugging.

Click to watch →

Gerência e Qualidade de Software - Cobertura de testes - Coverage.py

Gerência e Qualidade de Software - Cobertura de testes - Coverage.py

1.9K

Test coverage analysis is a software testing technique that measures what portions of code have been executed during testing, helping ensure comprehensive test coverage. Coverage.py is a Python tool that analyzes code execution by tracking which statements and branches (decision paths) are covered, generating reports that highlight uncovered code (red), partially covered code (yellow), and fully covered code (green). The tool can measure both statement coverage (individual lines executed) and branch coverage (both true and false paths of conditional statements). Effective coverage analysis requires running a complete test suite rather than individual tests, as each test may only cover a portion of the codebase. This technique helps identify dead code that is never executed and ensures that all possible execution paths are tested.

Click to watch →

Deep Dive

Exploring behavior-driven development (BDD) and performance/load testing tools like Locust to complement functional endpoint tests.

Belajar Load Testing dengan Locust generate 10000 request user per detik

Belajar Load Testing dengan Locust generate 10000 request user per detik

247

Load testing is a performance testing method that simulates user traffic to evaluate system capabilities under specific loads; Locust is an open-source Python-based tool that enables this by allowing users to define test scenarios, configure concurrent users and request rates, and monitor real-time metrics like response time and failure rates through its web interface.

Click to watch →

Locust - Python based Performance Testing Tool (By Naveen Kumar Namachivayam)

Locust - Python based Performance Testing Tool (By Naveen Kumar Namachivayam)

25.3K

Locust is an open-source performance testing tool written in Python that enables users to simulate thousands of concurrent users to test web applications under load. Unlike traditional tools like JMeter or LoadRunner, Locust uses a code-based approach where users write Python scripts defining user behavior, making it highly customizable and developer-friendly. Key features include a built-in Flask web interface for real-time monitoring, support for distributed load testing across multiple machines, and the ability to handle various protocols beyond HTTP by leveraging Python libraries. The tool uses nature-inspired terminology such as 'swarm' (injecting load), 'spawn' (creating users), and 'hatching' (user production rate). While it lacks a graphical recorder like other tools, its Python foundation allows for deep customization and integration with CI/CD pipelines, making it particularly suitable for Python-based projects and development teams.

Click to watch →

BDD Explained (Behaviour Driven Development)

BDD Explained (Behaviour Driven Development)

66.2K

Behavior-Driven Development (BDD) is a software development approach that originated at ThoughtWorks in the early 2000s as a method to teach Test-Driven Development (TDD) more effectively, emphasizing behavioral focus over technical implementation; it utilizes the Given-When-Then structure (setup-action-outcome) to create executable specifications that define what the system should do rather than how it should do it, and incorporates the concept of ubiquitous language from Domain-Driven Design to establish a common vocabulary between business stakeholders and technical teams, making tests more durable and easier to understand across all levels of software development.

Click to watch →

Load testing with Python and Locust by Lars Holmberg

Load testing with Python and Locust by Lars Holmberg

5K

Locust is an open-source performance testing tool written in pure Python that allows users to define load tests using real Python code, enabling complex behaviors like loops, conditional logic, and dynamic test data generation; it features a master-worker architecture for distributed testing, supports various protocols including HTTP, WebSockets, and MQTT through plugins, and provides detailed performance metrics such as requests per second and response time percentiles to identify system bottlenecks during load testing scenarios.

Click to watch →

BDD for Beginners 1 | What is BDD with Examples | How BDD works | What is Cucumber

BDD for Beginners 1 | What is BDD with Examples | How BDD works | What is Cucumber

215K

BDD (Behaviour Driven Development) is a collaborative software development approach that bridges the gap between business and technical teams by building a shared understanding of application behavior through three phases: Discovery (exploring how the system should behave), Formulation (creating concrete examples for automation), and Automation (implementing code based on documented examples); Cucumber is a tool that facilitates BDD by understanding documented examples and converting them into automated tests, serving as living documentation that acts as a single source of truth for all teams.

Click to watch →

Test Setup

Test Read

Test Create

Test Update

Test Delete

Test Setup

0:00

Playing Section

1
Create a virtual environment and install FastAPI, uvicorn, Pytest, and httpx.
2
Import TestClient and configure it with the FastAPI app instance.
3
Define a setup function to clear mock data before each test.

32.8K views5189:04@codingwithrobyOriginal Release: 2023-10-06

This tutorial demonstrates how to implement unit testing for FastAPI applications using Pytest and HTTPX, covering the complete workflow from setting up a virtual environment and installing dependencies (FastAPI, uvicorn, pytest, httpx) to writing test cases for CRUD operations (read, create, update, delete) using the TestClient and assertions to verify response status codes and data integrity.

[00:00:00]Everybody wants maintainable and scalable software but they don't want to put in the extra work to make sure that it's tested so bugs don't get introduced and a fun fact 87 of applications don't have unit tests at all so to separate you from the other 87 which will put you in the top of 13 is to implement unit tests in your application that will allow your application to be secure and allow you to be able to add enhancements quickly and make your application scalable maintainable and have less bugs so in this video I'm going to show you how to implement Pytest and https to be able to test against client requests and unit tests in Python so let's dive into the video alright so in this video we are going to be able to write tests for our FastAPI application so just like we always do the very first thing we're going to do is create a virtual environment by doing python3 Dash MV EnV EnV now this will create a virtual environment for our application where I'm going to say source and V slash bin slash activate and now we need to install our dependency so we can say pip install FastAPI and uvicorn once you do that this will install all the dependencies that we need for our FastAPI application to work correctly so these yellow lines will go away here momentarily but in our main.pi application we have our FastAPI application where we have a to do of name and completed we have a fake mock database that's going to store all of our to-do's and then we can get the list of the to Do's create a new to do get a specific to do based on the ID update a to do and delete a to do so if we went ahead and ran this application enter Swagger documentation we'd be able to run all of these API endpoints but for the Simplicity of this video let's just go right into how we can test and Implement testing for FastAPI now the very first thing that we need to install is HTTP X and this is a way for us to be able to use a client request to be able to test our API endpoints so let's go ahead and import this and now what we need to do is install Pytest and Pytest is unit testing for Apple location so we're going to be able to test in unit test our python code as well as our API endpoints so let's go ahead and say pip install Pytest now that we have all four dependencies which is FastAPI uvicorn Pytest and httpx let's go ahead and say new file and here we want to name this test underscore main.pi and the naming convention is this is it's going to start with tests that's how you know it's a test file and then underscore and then main which is the file that we're testing against dot Pi so when we run our Pytest it's going to look for these test files now the very first thing that we need to do here is just say from fastapi.testclient import our test client and then from our DOT main import our apps and our to-do's now unlike where we do main app equals FastAPI we want to grab the app which is FastAPI from our main and import it into our test client so we can then go ahead and say client equals test client where we pass in our app we then want to set up a function that just deletes all of to-do's so in this case it's going to delete all the to-do's from our application even though it's just a blank list so you probably want to set up some kind of sqlite external database that will be able to run against this but as of right now we'll just say def setup function brackets and then inside here I'm just going to say to Do's dot clear all right so what this does this is before each test we are just going to delete all of the to-do's so they don't touch each other so one test doesn't influence another test all right now the very first thing I'm going to say here is Def test read to Do's response which is our response from our client which is our test client dot get and we're just verifying using assert and assertions are like true and false to see if it's true or not our response code is going to be a 200 when we call just our normal get and then we also are expecting an empty list so if we go back here we look at our git we can see that it's going to return all of the to Do's values and it's going to return a status code of 200 but because to Do's list is empty it should just return an empty list and a status code of 200.

[00:04:50]and we can go ahead and run this just by typing in Pytest and immediately we can see that we had one test that was passed we have two warnings just because it's using some deprecated files but outside of that we have our test passing now if for whatever reason your application is crashing right here because it can't find the main functionality just close vs code and reopen it sometimes it gets lost when you're creating new files all right so now that we've done that let's create another test for creating a to-do where we can just right under here go ahead and just say def test create to do where we're creating our response is equal to client.post so we're checking our post functionality we're making sure our Json has a key of name with a value of buy groceries we're making sure it's completed and false and then we want to verify that we get a 200 response back after passing this in and that the response is just going to be the exact same thing so if we come over here and we look at our post functionality we can see that we just add a new to do to our list and here we are verifying that once we add it we can test against it so let's go ahead and just say Pytest and see that now both of our tests have passed now if we throw another S at the end novel sudden our test does not pass so if we said Pytest we can see that we get a fail and if we scroll up we can see that it's going to throw an assertion error now this is going to be assert completed of groceries equals completed groceries so we can see that it does not equal the groceries and it'll tell you right here so the differing items is named by groceries is not equal to named up by groceries with an extra s so let's go ahead and just change this back to just 1s so our application passes we now want to go ahead and test our read to do of a single ID so we can do this by right under here saying def test read to do with our client dot post of just an empty slash Json equals Name by groceries completed equals false response equals client dot get slash one so we're passing in one as the path parameter and again we're just verifying that this is going to equal this so when we add a new item you know we're going to be adding a primary key of one and we're just verifying that hey that's inside and I don't think we're actually passing in a primary key I think it's going to be the first item in the list so if we say Pytest we can see that now all three of our tests pass let's now go ahead and verify against a post for an update and right here let's go ahead and say test dot update where we're saying client dot put request which we're going to be doing client.post and this just sets up our client call and then we can do client dot put right here where we're updating our buy groceries to buy vegetables after we already added in there so now we go ahead and say Pytest we can see that we have all four tests passed and then lastly we can do the exact same assertions for our delete to do so if we come over here now we say def test delete to do we pass in our client of buy groceries we are then trying to delete that ID or the first element of our list making sure that we get a status code of 200 and then buy groceries is actually gone within the response so now if we go ahead and say Pytest we can see that we get all five tests passing and this is essentially how you can use Pytest and our test client from FastAPI to a be able to use assertions to test the unit tests and test the value of the Python business logic and then also we can use the response in clients to test and validate the API endpoints for our FastAPI application if you're able to find Value go ahead and click like if you found value in this video go ahead and like the video and go ahead and check out one other FastAPI video from my playlist and I will see you in the next

Up Next

Docker Tutorial for Beginners: Introduction to Containerization

@ProgrammingKnowledge

33.9K views•2020-01-15

IFS Therapy Demonstration: Complete Session with Unburdening

@IFSCA

95.9K views•2021-01-13

FastAPI vs Flask vs Django: Choosing the Right Python Web Framework

@TechWithTim

302.5K views•2024-05-26

Game of Thrones Opening Credits: A Cinematic Analysis

@gameofthrones

46.3M views•2011-04-18

Related Study Plans & Knowledge Roadmaps

Structured learning paths in General & Interdisciplinary Studies

Browse General & Interdisciplinary Study Plans

general-studies

Containerization: Evolution, Logistics & Trade

01Ancient Trade & Bulk Cargo: Amphorae to Barrels

02The Industrial Revolution & Cardboard Packaging

03The Containerization Revolution: Malcom McLean

+ 2 more learning modules

Explore Roadmap

general-studies

Textile Tech: Evolution, Labor & Global Impact

01Pre-Industrial Textiles: Handloom & Cottage Industry

02Mechanization: The Spinning Jenny to the Power Loom

03The Factory System & Global Labor Transformation

+ 2 more learning modules

Explore Roadmap

general-studies

Pharmacology: Botany, Patents & Biopiracy

01Foundations of Ethnobotany & Traditional Medicine

02The Birth of Synthetic Chemistry: Aspirin & Penicillin

03The Battle Against Malaria: Quinine to Artemisinin

+ 3 more learning modules

Explore Roadmap

general-studies

Writing Surfaces: Papyrus, Parchment & Paper

01Ancient Foundations: Clay, Stone, and Egyptian Papyrus

02Parchment, Vellum, and the Rise of the Codex

03The Chinese Rag Paper Revolution and the Silk Road

+ 3 more learning modules

Explore Roadmap