Testing

Showing half your users version A and half version B to see which one performs better. Blue button vs green button? Short headline vs long headline?

AAA stands for Arrange, Act, Assert.

API testing is checking that your backend endpoints work correctly — sending requests with different data and making sure you get the right responses, stat...

API Testing Patterns are strategies for testing your APIs thoroughly: happy path, error responses, validation, auth, pagination, rate limiting.

Acceptance Testing verifies that the software does what the business asked for.

Appium wants to be the Selenium of mobile — one framework to rule iOS, Android, and beyond.

Approval Testing captures the output of your code and compares it to a pre-approved 'golden file.

Arrange Act Assert is just the full name for AAA.

Artillery is like k6's more enterprise-friendly cousin who writes tests in YAML instead of code. Good news: non-engineers can write scenarios.

An assertion is your test saying 'I DEMAND this is true!'. It's you checking that the result is what you expected.

BDD is like writing your tests in plain English so your non-coder boss can also understand them.

Behavior-Driven Development is about describing HOW your app should behave before you build it — using language that makes sense to everybody, not just cod...

Behavioral testing focuses on WHAT the system does, not HOW it does it. You describe scenarios like 'when a user logs in with valid credentials, they shoul

Branch Coverage measures whether your tests cover both the 'if' AND the 'else' of every decision in your code.

Bun test is Bun's built-in test runner — Jest-compatible but fast enough to make you question every life choice that led to Vitest.

CI Testing is running all your tests automatically every time someone pushes code.

Named after canaries in coal mines — you send a small version of your new deployment into production first to see if it dies. Route 5% of traffic to the ne

Cargo cult testing is writing tests that look like real tests but don't actually test anything meaningful — checking that true equals true, mocking everyth...

Chai is an assertion library that makes your test checks read like English. Instead of `assert.equal(x, 5)` you can write `expect(x).to.

Imagine stress-testing a bridge by parking trucks on it before opening day instead of hoping it holds.

Netflix built a program that randomly kills servers in production — on purpose. It's like hiring someone to randomly unplug things in your office to make s

Code coverage is the report card for your tests. It shows you a map of your code and highlights which lines got tested (green) and which didn't (red).

Consumer-Driven Contracts flip API testing upside down.

A contract test checks that two services agree on how they'll talk to each other — what requests look like, what responses look like.

Contract testing verifies that two services agree on their API contract — the request format, response shape, and status codes. It's like checking that the

A corner case is like an edge case but even weirder — it's when MULTIPLE unusual things happen at the same time. An edge case is a weird input.

Coverage tells you what percentage of your code is actually tested. 80% coverage means 80% of your lines are touched by at least one test.

Coverage theater is writing tests that hit every line of code but actually test nothing. Your coverage badge says 98%.

Selenium drives a browser like a confused tourist with a map.

Testing a React Native app is like testing a car — you can't just inspect the engine from outside, you have to actually drive it.

E2E is just shorthand for End-to-End Test.

Edge cases are the weird, extreme, or unexpected inputs that trip up your code. What if someone types 0 for age?

An end-to-end test is like hiring a robot to be a user.

Exploratory Testing is testing without a script — a skilled tester uses the app like a curious (and slightly malicious) user. Click weird things.

A fixture is like pre-built test furniture.

A flaky test is a test that sometimes passes and sometimes fails for no clear reason — even when nothing changed.

Flaky test quarantine automatically isolates unreliable tests so they can't block deploys — timeout corner for misbehaving tests.

Fuzz Testing throws random, weird, broken data at your code to see what breaks.

Fuzzing is throwing completely random, malformed, or garbage inputs at your program to see if it crashes.

A Game Day is when your engineering team deliberately causes a production incident in a controlled setting to practice: Who gets paged? Who's on call?

Gatling writes load tests in Scala DSL that looks almost like English: 'exec(http(get users)) pause 1 second'.

Given When Then is AAA's cousin from the BDD world. Given = the setup situation. When = what the user/system does. Then = what should happen as a result.

Golden files are saved 'known good' outputs that you compare against on each test run. If the output changes unexpectedly, the test fails. It's like snapsh

Golden tests compare output against a saved 'golden' snapshot — when 'it looks right' becomes automated and version-controlled.

Gremlin is the enterprise version of breaking things on purpose. It's a commercial chaos engineering platform with a nice UI where you can inject CPU spike

Happy DOM is a fake browser environment that lives in Node.js. It's like JSDOM but faster and happier (hence the name). When you need to test components th

The happy path is when everything goes perfectly — the user types the right thing, the API responds correctly, nothing breaks.

A headless browser is a real browser — Chrome, Firefox — but without the visible window.

If a unit test checks one LEGO brick, an integration test checks that two bricks actually snap together correctly.

JMeter is the granddaddy of load testing tools — been around since 1998 and can test literally anything. HTTP, JDBC, LDAP, FTP, SOAP, you name it.

JSDOM is the OG fake browser — a JavaScript implementation of web standards that runs in Node.js. Before Happy DOM came along, JSDOM was the only game in t

Jest is the most popular JavaScript testing framework.

Litmus Chaos is like Chaos Monkey but specifically for Kubernetes. It's a chaos engineering platform that can kill pods, stress CPUs, inject network latenc

A load test is when you throw a huge crowd of fake users at your app to see how it handles them.

Load Testing Patterns define HOW to stress your system: ramp up gradually (load test), spike suddenly (spike test), sustain for hours (soak test), push unt...

Locust is the Pythonista's load tester — write user behavior as Python classes, hit start, and watch the real-time web dashboard show your server slowly dy...

Mocha is an older, flexible JavaScript test runner that lets you pick your own assertion library and mocking tools.

A mock is a fake version of something your code talks to.

A Mock Server pretends to be a real API. It returns predefined responses so your tests don't depend on external services. The payment API is down?

Mutation Score tells you how good your tests REALLY are — not just coverage, but whether they actually catch bugs.

Mutation testing is a way to test your tests.

Pact is contract testing for APIs. The consumer (frontend) writes what it expects from the provider (API), and Pact verifies both sides honor the contract.

Performance testing is measuring how FAST your app is under various conditions. Is the homepage loading in under 2 seconds?

Playwright is an end-to-end testing tool that controls real browsers (Chrome, Firefox, Safari) to test your web app the way a user would.

Playwright Test is Microsoft's end-to-end testing framework that controls real browsers like a puppet master. It can test in Chrome, Firefox, and Safari si

Instead of writing specific test cases (add(2,3)=5), property-based testing generates thousands of random inputs automatically and checks that certain prop...

Puppeteer is what Google built when they wanted to automate Chrome without Selenium's drama.

Red-Green-Refactor is the TDD dance: Red means write a test that FAILS (it's red in the output).

A regression test is a test you write AFTER fixing a bug, to make sure that bug never comes back.

The sad path is what happens when things go wrong — invalid input, network failures, permission denied, file not found.

A sanity check is you quickly checking that the most obvious, basic thing works before going deeper.

Selenium is the grandfather of browser testing — invented when Internet Explorer was still a thing worth testing against.

A smoke test is the most basic sanity check: does the app even start? Does it not immediately crash?

A snapshot test takes a photo of your component's output and saves it. Next time you run it, it takes another photo and compares them.

Snapshot testing is taking a picture of your component's output and saving it. Next time tests run, it takes a new picture and compares them.

Snapshot Testing captures your component's rendered output and saves it. Next time tests run, it compares against the saved snapshot. Changed?

A spy is like a double agent — it lets the real function still do its job, but secretly records everything: how many times it was called, with what argumen...

Statement Coverage is the simplest coverage metric: what percentage of your code lines were actually executed during tests?

A stress test pushes your app BEYOND its limits to see when and how it breaks. A load test checks normal traffic.

A stub is like a cardboard cutout of a function. It stands in for the real thing and always gives you the same canned response.

Supertest lets you test your API endpoints without starting a server. It's like being able to taste-test a restaurant's food without the restaurant actuall

TDD means you write the test BEFORE you write the code.

A test case is one specific scenario you want to check. 'Does the login work with a correct password?' — that's a test case.

Testcontainers spins up real Docker containers for your tests. Need a PostgreSQL database for integration tests?

Test coverage metrics tell you how much of your code your tests actually exercise. Line coverage counts lines executed. Branch coverage counts decision pat

A Test Data Factory generates realistic test data on demand.

Test double is the umbrella term for anything that replaces a real dependency in a test. Mocks, stubs, spies, fakes — they're all test doubles.

A test environment is a separate version of your app just for running tests.

Test Isolation means each test is completely independent — it sets up its own data, runs in its own world, and cleans up after itself.

Test Parallelization runs multiple tests at the same time instead of one after another.

The Test Pyramid is a strategy for how many of each test type to have.

Test rot is when your test suite slowly becomes useless. Tests that never fail. Tests that test nothing. Tests that fail for unrelated reasons.

A test runner is the thing that actually runs your tests and tells you which ones passed and which ones failed.

A test suite is just a collection of related tests grouped together.

Test theater is writing tests primarily to make reviewers happy rather than to catch bugs. The tests exist. They pass.

Test-Driven Development is a discipline where you write your tests before your actual code.

TestCafe skips WebDriver entirely and injects test scripts directly into the page, like a particularly bold houseguest who just walks in without knocking.

Instead of mocking your database in tests, Testcontainers spins up a REAL database in a Docker container, runs your tests against it, then throws it away.

Testing Library is a set of utilities that helps you test your UI the way a user would — by finding elements by their text or label, not by CSS class or ID...

Toxiproxy sits between your app and its dependencies and makes the connection terrible on purpose. Add 500ms latency? Done. Drop 50% of packets? Sure. It's

A unit test is like checking that one single LEGO brick isn't broken before you use it in your big castle.

A visual regression test takes a screenshot of your UI, and next time it checks if anything LOOKS different — pixel by pixel.

Vitest is a blazing-fast test runner built on Vite. If Jest is the reliable sedan, Vitest is the electric sports car — same driving experience, 10x faster.

WireMock pretends to be an API so your tests don't need the real thing. Need to test what happens when Stripe returns an error? WireMock fakes it. It's lik

k6 lets you write load tests in JavaScript, which is either convenient or deeply ironic depending on your views on JavaScript performance.