Smoke Testing

What it is

A smoke test — also called build acceptance or a confidence check — is a shallow, broad check that a build is stable enough to test at all. It does not verify features deeply; it answers one question: is this build sane enough to hand to the testers?

The name comes from hardware: power on the board, and if it does not smoke, keep going.

1
  build ──► SMOKE (a few minutes) ──► full test suite
2
              │ pass                      │
3
              └ fail → stop the line      └ deep verification continues

Smoke tests are wide but not deep: every major area gets touched, nothing gets a deep verification. They run first and fail fast, so an obviously broken build does not burn CI minutes or reach users.

When to use it / when to avoid it

Use it for

After every deployment or CI build, before the wider suite runs
Confirming critical entry points respond (the login page loads, the health endpoint returns 200, the app boots)
A cheap gate that stops a broken build before it wastes time or ships

Avoid it when

You need confidence in one just-changed feature → use a sanity test
You need to prove nothing else broke → use a regression test
The whole suite is already small and fast — a separate smoke set adds nothing

Frameworks & tools

Tool	Ecosystem	Notes
Playwright	Multi	Tag a `@smoke` subset and select it with `--grep`
Cypress	Node	Run only tagged specs with `--env grepTags=@smoke`
pytest	Python	`@pytest.mark.smoke` plus `-m smoke`
Postman / Newman	Multi	Replay a collection as a post-deploy check
Robot Framework	Python	Keyword-driven smoke suite selected by tags
curl / shell	Multi	Minimal HTTP health checks in a pipeline step
Go testing	Go	`go test ./... -run Smoke`
JUnit 5	Java/JVM	`@Tag("smoke")` with Maven Surefire groups
xUnit / NUnit	.NET	`[Trait]` / `[Category]` filtered by `dotnet test`
k6 / Vegeta	Multi	A minute of baseline traffic as a load smoke test

Quick setup

1
npm install -D @playwright/test
2
npx playwright test --grep @smoke

1
pip install pytest httpx
2
pytest -m smoke -q

1
go test ./... -run Smoke -count=1

1
<!-- Maven: run only the smoke group -->
2
<plugin>
3
  <groupId>org.apache.maven.plugins</groupId>
4
  <artifactId>maven-surefire-plugin</artifactId>
5
  <configuration>
6
    <groups>smoke</groups>
7
  </configuration>
8
</plugin>

1
dotnet test --filter "Category=Smoke"

Example

1
import { test, expect } from '@playwright/test';
2

3
test('@smoke home page responds', async ({ page }) => {
4
  const res = await page.goto('/');
5
  expect(res?.status()).toBe(200);
6
  await expect(page.getByRole('heading', { level: 1 })).toBeVisible();
7
});

1
import httpx
2
import pytest
3

4
@pytest.mark.smoke
5
def test_health_endpoint():
6
    response = httpx.get("http://localhost:8000/health")
7
    assert response.status_code == 200
8
    assert response.json()["status"] == "ok"

1
func TestSmokeHealth(t *testing.T) {
2
  resp, err := http.Get(baseURL + "/health")
3
  if err != nil {
4
    t.Fatalf("health request failed: %v", err)
5
  }
6
  defer resp.Body.Close()
7
  if resp.StatusCode != http.StatusOK {
8
    t.Fatalf("want 200, got %d", resp.StatusCode)
9
  }
10
}

1
import static org.junit.jupiter.api.Assertions.assertEquals;
2
import java.net.URI;
3
import java.net.http.*;
4
import org.junit.jupiter.api.Tag;
5
import org.junit.jupiter.api.Test;
6

7
class SmokeTest {
8
  @Test
9
  @Tag("smoke")
10
  void healthEndpointResponds() throws Exception {
11
    var client = HttpClient.newHttpClient();
12
    var req = HttpRequest.newBuilder(URI.create(BASE_URL + "/health")).build();
13
    var res = client.send(req, HttpResponse.BodyHandlers.ofString());
14
    assertEquals(200, res.statusCode());
15
  }
16
}

1
using System.Net;
2
using System.Net.Http;
3
using Xunit;
4

5
public class SmokeTests
6
{
7
    [Fact]
8
    [Trait("Category", "Smoke")]
9
    public async Task HealthEndpointResponds()
10
    {
11
        using var client = new HttpClient();
12
        var res = await client.GetAsync($"{BaseUrl}/health");
13
        Assert.Equal(HttpStatusCode.OK, res.StatusCode);
14
    }
15
}

Anti-patterns & best practices

Keep it short. Aim for minutes, not hours; a smoke suite that is slow stops being run.
Cover breadth, not depth. One happy path per major area, no edge cases.
Run it first. Put smoke in the earliest CI stage so a broken build stops the line.
Assert on real signals. A 200 on the health endpoint, not merely “the process started”.
Do not grow it into a regression suite. When smoke needs edge cases, that is a sanity or regression concern.
Make failures obvious. A red smoke run should name the exact area that is down.