1

Testing

ryan edited this page 2026-02-28 00:30:01 -05:00

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

Testing terminology can feel like a word soup, but the differences come down to scope (how much you're testing) and intent (what you're trying to prove). Think of building a house: Integration is checking if the pipes fit the sink, E2E is making sure you can actually take a shower, and Smoke is making sure the house isn't on fire when you turn the power on.

1. Integration Testing Goal: Do two separate parts of the system "shake hands" correctly? In integration testing, you aren't testing the whole app. You are testing the interface between two modules. For example, does your Backend API correctly send data to your Database? Or does your Frontend correctly parse the JSON from your Auth service?

• Scope: Narrow (Module A + Module B).
• When: During development, after unit tests pass.
• Example: Testing if your "Submit Order" button successfully sends a POST request to the payment gateway.

2. End-to-End (E2E) Testing Goal: Does the entire system work for the user from start to finish? E2E testing treats the app like a "black box." You don't care how the code works; you care if a human can achieve a goal. It tests everything: the UI, the backend, the database, the network, and third-party APIs (like Stripe or Google Maps).

• Scope: Broad (The entire stack).
• When: Right before a release or on a staging server.
• Example: A script that opens a browser, goes to the store, adds an item to the cart, enters credit card info, and verifies the "Thank You" page appears.

3. Smoke Testing Goal: Is the build stable enough to bother testing further? Smoke testing isn't a type of test like the others—it’s a subset of your most important E2E or integration tests. If the smoke test fails, you stop everything and fix it immediately because the app is "on fire" (unusable).

• Scope: High-priority "Happy Paths" only.
• When: Immediately after a new build is deployed to an environment.
• Example: Can a user reach the Login page? If the Login page returns a 500 Error, there is no point in testing the "Edit Profile" feature. Comparison Table

  Feature	Integration Testing	E2E Testing	Smoke Testing
  Perspective	Developer (Internal)	User (External)	Reliability (Health Check)
  Complexity	Medium	High (Hard to maintain)	Low
  Execution Time	Fast	Slow	Very Fast
  Failure Meaning	"These two parts don't talk."	"The user journey is broken."	"The system is dead on arrival."
  How they work together
  Typically, you follow the Testing Pyramid:

• Unit Tests: Thousands of tiny tests for small functions.
• Integration Tests: Hundreds of tests for connections.
• E2E Tests: Dozens of tests for full flows.
• Smoke Tests: The 5-10 most critical E2E tests run on every push.

For 2026, the landscape of testing has shifted toward tools that are faster, more reliable, and better at handling asynchronous web apps. Since you’re using coding agents, you want tools that have clear, readable syntax so the agent can generate and debug them effectively.

1. Tools for Integration Testing Integration tests check how different parts of your system (like your API and your database) work together. Vitest (Modern / Recommended) If you are using Vite (React, Vue, Svelte), Vitest is the standard. It is significantly faster than the older industry standard, Jest, and has native support for TypeScript.

• Best for: Testing components, hooks, and internal logic.
• Why Agents love it: It shares the same configuration as your app, so agents don't get confused by conflicting setup files. Supertest (API Testing) If you want to test your Node.js backend routes without actually spinning up a full browser.
• Best for: Verifying that your JWT cookies are being set correctly (as we discussed earlier).
• How it works: It "simulates" HTTP requests to your Express/Fastify server and checks the response. Keploy (AI-Driven Integration) A newer 2026 trend. It records your real traffic (API calls and DB queries) and automatically turns them into integration tests.
• Best for: Large backends where writing manual tests for every edge case is exhausting.

2. Tools for End-to-End (E2E) Testing E2E tests verify the "User Journey" by opening a real browser and clicking buttons. Playwright (The Gold Standard) Developed by Microsoft, Playwright is currently the top-rated E2E tool. It is incredibly fast, rarely "flakes" (meaning tests don't fail for no reason), and supports multiple browser tabs and windows.

• Best for: Complex apps, file uploads, and cross-browser testing (Chrome, Safari, Firefox).
• Pro-Tip: It has a "Codegen" feature where you can click around your site, and it writes the code for you. Cypress (The Developer's Favorite) Cypress is famous for its incredible "Time Travel" debugging UI. You can hover over a test step and see exactly what the app looked like at that millisecond.
• Best for: Frontend-heavy teams who want a visual dashboard while they write tests.
• Constraint: It can be slower than Playwright when running thousands of tests in a row. Which should you use? Most modern developers use a "Stack" that looks like this:

  Level	Tool Recommendation	Why?
  Logic/Hooks	Vitest	Blazing fast, instant feedback.
  API Endpoints	Supertest	Tests your JWT/Cookie logic without a UI.
  User Journey	Playwright	Most reliable way to ensure a user can "Check out" or "Login."
  How to use them with a Coding Agent
  To get an agent to write a perfect test, don't just say "test this." Provide the component code and the expected outcome.
  The "Agent-Friendly" Prompt:

"Here is my AuthService.ts and my LoginView.tsx. Using Playwright, write an E2E test that:

• Logs in with a test user.
• Verifies the auth_token cookie is set with httpOnly.
• Checks that the user is redirected to /dashboard."