Quick .NET SmokeTest Patterns for MicroservicesMicroservices bring agility, scalability, and independent deployment, but they also increase system complexity. Smoke tests—lightweight checks that verify basic application health after a build or deployment—are essential to catch catastrophic failures early without waiting for full test suites. This article presents pragmatic .NET smoke-test patterns for microservices, explains when to use each pattern, and offers code sketches, implementation tips, and pitfalls to avoid.
What is a smoke test and why it matters for microservices
A smoke test is a fast, shallow verification that an application is fundamentally working. For microservices, that means confirming each service can start, respond to its most important endpoints, and access critical dependencies (databases, caches, message brokers). Smoke tests are not integration or end-to-end tests; they prioritize speed and reliability to provide immediate feedback in CI/CD pipelines and during deployments.
Benefits:
- Faster feedback after builds/deployments
- Early detection of catastrophic issues (configuration, startup failures, dependency outages)
- Reduced deployment risk by preventing obviously broken services from promoting across environments
Core principles for .NET smoke tests
- Keep tests fast (ideally < 5–10 seconds per service).
- Test only the most critical functionality.
- Make tests deterministic and reliable; avoid flaky network/time-dependent checks.
- Prefer non-destructive checks (GET/HEAD) where possible.
- Run tests as part of CI pipeline and as a post-deploy gate.
Pattern 1 — Health Endpoint Probe (the simplest and most common)
Description: Expose a lightweight health endpoint in each service (e.g., /health or /health/ready) that returns service status and optionally checks critical dependencies.
Why use it:
- Minimal overhead in code and runtime.
- Fast and easily integrated into load balancers and Kubernetes readiness/liveness probes.
Implementation notes for .NET:
- Use ASP.NET Core’s built-in health checks (Microsoft.Extensions.Diagnostics.HealthChecks).
- Register checks for essential dependencies (DB, cache, external APIs) but keep them lightweight for smoke testing — consider a separate readiness check that is more thorough than liveness.
Example (conceptual):
// Startup.cs / Program.cs services.AddHealthChecks() .AddSqlServer(Configuration.GetConnectionString("PrimaryDb"), name: "db") .AddRedis(Configuration["Redis:Connection"], name: "redis"); app.MapHealthChecks("/health/ready", new HealthCheckOptions { Predicate = (check) => true, ResponseWriter = async (context, report) => { // simple JSON response with overall status context.Response.ContentType = "application/json"; await context.Response.WriteAsync(JsonSerializer.Serialize(new { status = report.Status.ToString() })); } }); When to use:
- Always provide a basic health endpoint. Use as the first-line smoke test in CI/CD and orchestration platforms.
Pitfalls:
- Overly expensive checks slow pipelines; separate fast smoke checks from detailed readiness probes.
- Don’t expose sensitive information in responses.
Pattern 2 — Critical Endpoint Smoke (business-level check)
Description: Hit a small number of critical API endpoints that represent the core business flows (for example, authentication, product lookup, or submitting a small job).
Why use it:
- Verifies more than just service startup — ensures routing, serialization, essential business logic, and some dependencies are working.
Implementation tips:
- Use lightweight requests (GET or POST with minimal payload).
- Validate response status and a minimal portion of the body (e.g., presence of an ID or status field).
- Avoid operations that mutate critical production data; use a test tenant or sandbox account, or mark test requests with an idempotent flag.
Example test (C# using HttpClient and xUnit):
[Fact] public async Task ProductLookupSmokeTest() { using var client = new HttpClient { BaseAddress = new Uri("https://api.example.com/") }; var resp = await client.GetAsync("api/products/health-sample"); resp.EnsureSuccessStatusCode(); var content = await resp.Content.ReadAsStringAsync(); Assert.Contains("sku", content); } When to use:
- After basic health checks, or when business-level verification is important before promotion.
Pitfalls:
- Flaky external dependencies can cause false positives/negatives. Mock or use a stable test instance where possible.
Pattern 3 — Dependency Sanity Check (external systems probe)
Description: Confirm connectivity to essential dependencies (databases, caches, message brokers). This can be part of health endpoint checks or an independent smoke test.
Why use it:
- Many deployments fail due to missing configuration or network issues to dependencies.
Implementation approaches:
- For databases: open a connection and execute a lightweight query (e.g., SELECT 1).
- For caches: perform a GET/SET with a short TTL on a namespaced key.
- For message brokers: confirm ability to publish a small “heartbeat” message to an internal test topic or verify connectivity without processing.
Example (SQL and Redis checks):
// SQL await using var conn = new SqlConnection(connStr); await conn.OpenAsync(); await using var cmd = new SqlCommand("SELECT 1", conn); var result = await cmd.ExecuteScalarAsync(); // Redis (StackExchange.Redis) var db = redis.GetDatabase(); await db.StringSetAsync("smoke:key", "ok", TimeSpan.FromSeconds(5)); var val = await db.StringGetAsync("smoke:key"); When to use:
- For services that depend heavily on stateful dependencies. Run in pre-deploy or post-deploy smoke suites.
Pitfalls:
- Ensure tests use non-destructive operations and respect rate/permission constraints.
Pattern 4 — Message Bus Smoke (async systems)
Description: Verify the ability to publish and consume messages on the service’s message broker (Kafka, RabbitMQ, Azure Service Bus).
Why use it:
- Microservices often depend on event-driven flows; a working HTTP API doesn’t guarantee message infrastructure functioning.
Implementation patterns:
- Loopback test: publish a message to a test topic/queue that the service subscribes to and have the service emit a corresponding health event or write a marker that the smoke test can read.
- Broker-only sanity: validate broker connectivity and ability to publish without requiring the full consumer flow.
Example (pseudo):
- Publish a “smoke-123” event to topic “smoke-tests”.
- Consumer writes a small record to a database or in-memory store.
- Smoke test polls the store for the marker.
When to use:
- For services that both produce and consume messages; run after deployment to ensure messaging works.
Pitfalls:
- Timeouts and retries can slow tests. Use short TTLs and clear test artifacts promptly.
Pattern 5 — Contract & Schema Sanity (API compatibility)
Description: Quickly validate that the service’s API contract or message schema matches expectations used by callers.
Why use it:
- Prevents runtime errors caused by breaking changes in JSON shapes, required fields, or serialization behavior.
Implementation tips:
- Compare service metadata (OpenAPI/Swagger JSON) against a stored expected minimal contract, or perform a shallow schema validation on critical endpoints’ responses.
- For messages, validate schema registry compatibility or run a lightweight Avro/JSON schema check.
Example (OpenAPI quick check):
- Fetch /swagger/v1/swagger.json and verify presence of critical paths and expected response status codes.
When to use:
- Especially useful when multiple teams deploy independent services with strong contract expectations.
Pitfalls:
- Overly strict schema checks can block legitimate non-breaking evolutions; focus on the subset that matters for immediate compatibility.
Pattern 6 — Canary Smoke (deploy-time verification)
Description: Deploy a small percentage of traffic to the new version and run smoke checks only against canary instances before rolling out to the rest.
Why use it:
- Detects issues that only appear under real traffic or with specific infrastructure configuration.
Implementation notes:
- Integrate with feature flags, service mesh routing, or load balancer rules to route a small sample of traffic.
- Combine with circuit-breakers and quick rollback mechanisms.
When to use:
- For high-risk changes, database migrations, or when behavior under load matters.
Pitfalls:
- Canary traffic volume must be enough to exercise code paths; too small gives false confidence.
Running smoke tests: CI/CD integration patterns
- Pre-deploy checks: run health and critical endpoints in CI build to catch regressions early.
- Post-deploy smoke: run against deployed instances (canary or full) before promoting environments.
- Orchestration integration: configure Kubernetes liveness/readiness probes to use health endpoints; ensure CI waits for readiness before running smoke tests.
- Parallelization: run smoke tests for independent services in parallel to reduce total pipeline time.
Example pipeline step (pseudo):
- Deploy service to staging/canary.
- Wait for pods to be ready.
- Run health endpoint probe and critical endpoint smoke tests in parallel for all services.
- If any fail, mark deployment as failed and trigger rollback.
Test tooling & frameworks
- ASP.NET Core Health Checks (built-in)
- xUnit / NUnit / MSTest for test runners
- FluentAssertions for expressive assertions
- Testcontainers-dotnet for ephemeral dependency instances in CI
- Kestrel + TestServer for in-process testing without network overhead
- Custom lightweight runners or scripts (PowerShell/Bash) for simple HTTP checks
Example using TestServer for fast local smoke:
using var host = await new HostBuilder() .ConfigureWebHostDefaults(web => web.UseTestServer().UseStartup<Startup>()) .StartAsync(); var client = host.GetTestClient(); var resp = await client.GetAsync("/health/ready"); resp.EnsureSuccessStatusCode(); Observability and reporting
- Log smoke test results and integrate with monitoring/alerting.
- Expose a summary dashboard showing latest smoke status per service.
- Attach failure context (HTTP status, latency, trace IDs) to CI logs for faster debugging.
Common pitfalls and how to avoid them
- Flaky tests: isolate network variability, set sensible timeouts, retry carefully.
- Overly broad checks: limit checks to critical paths to keep speed and reliability.
- Security leaks: don’t expose secrets in health responses or logs.
- Coupling to production data: use test tenants or non-destructive operations.
Example smoke-test matrix (samples per service)
- Service A (stateless API): Health endpoint, critical GET endpoint, OpenAPI sanity
- Service B (uses DB): Health endpoint, DB connection SELECT 1, product lookup
- Service C (event-driven): Broker publish sanity, consumer loopback verification
Closing notes
Smoke tests are the safety net for microservices: they’re cheap, fast, and highly effective at catching critical failures early. In .NET ecosystems, combining ASP.NET Core health checks, lightweight HTTP checks, dependency probes, and message-bus verifications provides a robust smoke-testing strategy that fits into CI/CD and deployment workflows. Start small with health endpoints, expand to business-critical endpoints and dependency checks, and automate these checks around deployments for immediate, actionable feedback.
Leave a Reply