Query Count Testing for EF Core APIs

Problem Context

Developers building ASP.NET Core APIs with Entity Framework Core need to test how many SQL queries their endpoints execute. This is critical for performance, debugging, and ensuring efficient database interactions. Without a built-in way to assert query counts, they must manually track and validate queries in tests, which is time-consuming and error-prone.

Pain Points

Developers currently write custom DbCommandInterceptors, wire them into test hosts, and manually collect and assert query counts. This process is repetitive, requires boilerplate code, and is not standardized across teams. Every team reinvents the same solution, leading to inconsistent testing practices and wasted effort. The lack of a built-in tool forces developers to spend extra time on setup instead of focusing on test logic.

Impact

This problem slows down development cycles, increases the risk of performance issues slipping into production, and creates technical debt. Teams waste hours or days per sprint setting up and maintaining query tracking solutions. Poorly optimized queries can lead to higher cloud costs, slower APIs, and frustrated users. Without reliable query count assertions, developers cannot confidently refactor or optimize their code.

Urgency

This is a recurring pain point for teams working with EF Core, especially those practicing test-driven development or integration testing. Every new API endpoint or refactor requires reimplementing the same query tracking logic. The lack of a standardized solution forces developers to choose between inconsistent testing or spending unnecessary time on boilerplate. Teams cannot scale their testing practices without a reliable, reusable tool.

Target Audience

ASP.NET Core developers, backend engineers, and QA teams working with Entity Framework Core. This includes developers at mid-sized to large tech companies, independent software vendors (ISVs), and agencies building data-driven APIs. Teams practicing test-driven development (TDD) or integration testing are particularly affected, as are those migrating from Django or other frameworks with built-in query counting tools.

Solution Approach

A lightweight, open-source-compatible library that integrates seamlessly with ASP.NET Core test hosts. It provides a simple API to track and assert the number of SQL queries executed during tests, eliminating the need for custom interceptors and manual setup. The tool wraps EF Core’s query tracking in a reusable, standardized way, reducing boilerplate and improving test reliability.

Key Features

The library offers a fluent API for tracking queries (e.g., using var guard = QueryGuard<TContext>();), automatic query counting during test execution, and built-in assertions (e.g., guard.AssertCount(exact: 3)). It supports both exact and range-based assertions (e.g., guard.AssertCount(min: 2, max: 4)) and provides detailed query logs for debugging. The tool integrates with popular testing frameworks like xUnit, NUnit, and MSTest and works with any EF Core version.

User Experience

Developers add a single line to their test setup to start tracking queries. During test execution, the library silently counts all SQL queries. After the test, they call AssertCount() to verify the expected number of queries. If the count matches, the test passes; otherwise, it fails with a clear error message. The tool requires no manual query collection or complex interceptors, saving hours of setup time per project.

Differentiation

Unlike manual solutions or copy-pasted interceptors, this tool is battle-tested, standardized, and maintained by a dedicated team. It avoids the pitfalls of custom implementations (e.g., missing edge cases, inconsistent behavior) and provides additional features like query logging and flexible assertions. The library is designed to work out-of-the-box with minimal configuration, unlike generic testing tools that require extensive setup.

Scalability

The tool scales with the user’s testing needs. It supports team-wide adoption through NuGet packages, CI/CD integration, and customizable reporting. Enterprises can extend it with plugins for advanced analytics (e.g., query trend tracking) or integrate it with their existing test suites. The library’s modular design allows users to start with basic query counting and later add features like performance benchmarking or query optimization suggestions.

Expected Impact

Teams reduce test setup time by 80% or more, freeing developers to focus on test logic and API improvements. Standardized query counting improves test reliability and catches performance regressions early. The tool helps teams adopt test-driven development (TDD) more effectively by ensuring consistent, maintainable tests. Over time, it reduces cloud costs and improves API response times by identifying inefficient queries.