Guide 40
Your date picker is a day off. Test the time zone.
Catch wrong-day defaults and date-only values that shift after saving, with a fixed browser clock, a small time-zone matrix, and explicit calendar expectations.
GuideYour CSV downloaded. Did it export the right rows?
Test a CSV export from click to parsed contents: capture the download, verify filters and exact rows, and catch the cases a filename assertion misses.
GuideYour test passes in the suite. Run it alone.
Find hidden setup dependencies, give each scenario its own starting state, and make a single-test rerun mean something in TestVibe.
GuideCreate, verify, delete: testing features that write data
Give create, update, and delete scenarios their own records, assert persisted outcomes, and clean up data so repeat and parallel runs remain useful.
GuideEnd-to-end testing Blazor apps, Server and WASM
The Blazor behaviors that break naive E2E tests — SignalR round trips, WASM boot, Virtualize, circuit-drop banners — and the Playwright patterns that hold.
GuideEnd-to-end testing Wisej.NET applications
Why generic selector-based tools choke on Wisej.NET apps — and how a framework-aware plugin, built by the makers of Wisej.NET, tests them for real.
GuideTesting jQuery-era apps like they still matter
The 2009-2016 jQuery + Bootstrap app still runs the business. Here's why it was miserable to test end-to-end, and the patterns that finally make it tractable.
GuideTesting legacy .NET web apps without a rewrite
Browser-level patterns for WebForms postbacks, designer-named controls, masked inputs, and conditional dialogs, with compatibility and test-data limits to check.
GuideTesting web components and shadow DOM without the mystery timeouts
Shadow roots are where naive selectors die. How open vs closed shadow DOM changes what's testable, and the boundary-safe locators that survive it.
GuideWire TestVibe into your coding agent
Give Claude Code or Cursor a test suite it can run in the cloud after every change — via the TestVibe MCP server — and read back real pass/fail.
GuideA failure triage loop that takes minutes, not mornings
Read a red run, re-run just the failed tests from the composer, and decide when to re-run, regenerate, or fix the app.
GuideBring your own model: custom LLM endpoints in self-hosted TestVibe
Point self-hosted TestVibe generation at your own OpenAI-compatible endpoint, keep prompts inside your network, and configure it right.
GuideDebugging failures with Playwright traces
How to read Playwright traces in TestVibe (timeline, DOM snapshots, console, network) to find why a test failed, plus the Debug with AI shortcut.
GuideDo you know what your tests actually cover?
How TestVibe maps AI-derived app areas against your existing tests so untested parts of your app surface first.
GuideExtending generated tests with plugins
What TestVibe plugins are, the built-in catalog, how to enable them per project, and when a plugin beats a workaround.
GuideFrom one sentence of intent to a drafted test suite
Give the TestVibe Assistant an intent, and it explores your app, drafts feature suggestions you review before generating and running tests.
GuideGenerating tests against the app on your machine.
Point TestVibe at your local dev build, capture flows in your own browser, and generate tests that run before you deploy.
GuideGetting started with TestVibe: from sign-up to your first passing test
A hands-on walkthrough: sign up, create a project, describe a flow in plain English, let AI generate a Playwright test, run it in the cloud, read the trace.
GuideHow TestVibe credits work
What consumes TestVibe credits, how monthly and purchased credits are applied, where to check usage, and what happens when you run out.
GuideKeep your tests in your repo: two-way Git sync with TestVibe
Mirror your TestVibe test files to GitHub, GitLab, or Azure DevOps — edits flow both ways, conflicts stay explicit, and your tests live next to your code.
GuideOne suite, three environments
Point the same TestVibe features at dev, staging, and prod using a project URL strategy, shared variables, and the right run scope per environment.
GuideOrganizing a growing test suite with features and groups
How to structure a TestVibe suite with atomic features and readable groups, plus naming conventions that stay navigable past 100 features.
GuidePut your test suite on autopilot with TestVibe Automations
Schedule test suites, chain runs on events, and get AI root-cause triage on failures — a practical guide to TestVibe Automations.
GuideReading a run: how results are organized
How a TestVibe run detail is structured — run vs scenario status, per-configuration rows, and the artifacts attached to each scenario.
GuideRecording flows in your own browser
Use the TestVibe recorder browser extension to capture a real browser journey and turn it into reviewable Gherkin and a runnable test.
GuideRepeatable test data with the unique token
Why fixed test data breaks on repeat and parallel runs, and how the {{unique}} token gives every run its own fresh values.
GuideRunning one suite across browsers and viewports
How Playwright run configurations work in TestVibe, when a run fans out per config, and how to read the per-config results.
GuideSelf-hosting TestVibe on your own infrastructure
What the self-hosted edition runs, how the offline license works, and when on-prem beats the cloud.
GuideTelemetry: watch your app between test runs
Stream server CPU, memory, sessions, and errors from your real app next to your tests, then turn a telemetry signal into a covering test.
GuideTest notifications your team will not mute
How per-user channels, failure-only filtering, and per-category controls keep TestVibe alerts signal instead of noise.
GuideTesting apps that are not on the public internet
How to run cloud browser tests against private, staging, and localhost apps using a tunnel, without opening inbound firewall ports.
GuideTestVibe from the terminal: the CLI, REST API, and MCP server
Drive TestVibe without the UI — create an API key, script the testvibe CLI and REST API, and let AI agents run your tests over MCP.
GuideTestVibe inside Visual Studio
The TestVibe extension for Visual Studio 2022 puts coverage, runs, features, and automations in tool windows next to your code.
GuideThe TestVibe assistant: ask your test suite questions
A practical guide to the in-app assistant, explaining failures, running ops actions, and suggesting the next tests to write.
GuideVariables and secrets: keeping credentials out of your specs
How to store login credentials, API tokens, and config in TestVibe, reference them from Gherkin, and rotate them without leaking values.
GuideWhere Gherkin fits in TestVibe
How the Gherkin spec works as the readable contract between what you describe and the Playwright code TestVibe generates.
GuideWhere your screenshots, videos, and traces live
How TestVibe captures run artifacts per scenario, where to find and download them, and how the workspace storage quota and retention work.
GuideWiring TestVibe into your CI pipeline
Trigger TestVibe runs from CI with the CLI or REST API, wait for the result, and fail the build when a test fails.
GuideWorkspaces, members, and roles
How personal and team workspaces work in TestVibe, how to invite members, what each role controls, and how teams organize projects.
GuideWriting clear test descriptions for generation
Describe the starting state, actions and observable outcomes clearly, then review generated code and completed verification.
Walkthrough 2
Load testing your web app with TestVibe
A practical walkthrough of TestVibe load tests: configure users and duration, run against your app, and read the live latency and error-rate charts.
WalkthroughTesting email OTP and magic links with TestVibe Mailbox
Use TestVibe Mailbox email support to test one-time codes and magic links; check provider configuration and completed run evidence.
Deep dive 10
What a million tokens of context actually buys you in testing
Large context windows can preserve more working state. They do not guarantee useful recall, correct assertions or a passing test.
Deep diveAn undersized email field: catch responsive CSS regressions
An illustrative undersized mobile input shows why responsive layouts need explicit size checks and reviewed visual baselines.
Deep diveDesign system drift: the regression suite for your visual language
Production quietly diverges from your documented design system. Here's which surfaces to pin with visual baselines, and which ones will just drown you in noise.
Deep diveYour SPA's vitals were invisible. Soft navigations change that.
Measure SPA route transitions with Chrome soft-navigation APIs, and distinguish local measurement from CrUX reporting.
Deep diveTesting across iframes: payments, editors, and embedded everything
Why cross-origin iframes break naive selectors, and how frame-scoped locators drive Stripe fields, embedded editors, and nested frames deterministically.
Deep diveTesting virtualized data grids when the DOM is lying to you
A virtualized grid renders a viewport-dependent subset of its dataset. Row-scraping tests silently miss the rest. How to test a Wisej.NET DataGridView by reading its model.
Deep diveBrowser VUs vs protocol VUs: choosing the right load test
When to reach for protocol virtual users, when to spin up real browsers, and how to design k6 scenarios that answer the question you actually have.
Deep diveFrom failing trace to a reviewable fix proposal
Use Debug with AI to investigate a failing test and review a proposed correction; repository writes require a capable integration and authorization.
Deep diveFrom plain English to Playwright: generation and verification in TestVibe
How TestVibe turns a plain-English description into verified Playwright code: Gherkin drafting, live exploration, web-first assertions, and regeneration.
Deep diveWeb-first assertions: the end of sleep(5000).
How Playwright's auto-retrying expect() matchers replace fixed waits, with before/after code and the misuse patterns that reintroduce flake.
Best practices 22
Hide the Edit button. Test the permission.
A hidden button can leave invoice data exposed. Pair role and ownership checks with positive controls, direct links, and server-response assertions.
Best practicesYour first tests shouldn't write anything
The instinct is to automate checkout first. Start with the read-only spine instead, while checking credentials, network reachability and test expectations.
Best practicesRegression testing that follows the diff
Run the regression tests a change actually touches, then route failures into GitHub and Jira so every red run has an owner.
Best practicesHow to end-to-end test the AI features in your own app
Your chatbot, summarizer, and "ask AI" box produce nondeterministic output. Here's how to e2e test them anyway — structure, invariants, and a hard boundary.
Best practicesINP is a Core Web Vital — test the interactions your users depend on
Measure real-user interaction latency and test important journeys to find responsiveness regressions before they ship.
Best practicesRedesign season: reskin the app without rebreaking the suite
A redesign is a mass edit of exactly the layer UI tests touch. Here's why suites die during a reskin, and how to survive one without a red-bar week.
Best practicesTest dark mode alongside the light theme
If your users choose dark mode, it needs its own visual coverage and fails in ways light-mode testing can't see. Here's the playbook to actually cover both themes.
Best practicesThe on-sale is a load test — you only choose whether to run it first
A ticket on-sale or launch can create a sharp demand spike. Here's how to model the surge, gate on the tail, and test the degraded path first.
Best practicesIs it down, or is it you?
Compare user-journey checks with service telemetry to distinguish an application failure from a provider incident and choose the next investigation step.
Best practicesLoad test before the spike, not during it
Model expected launch traffic ahead of time, then measure backend capacity and browser experience under representative load.
Best practicesReviewing AI-authored code without losing the behavior
Pair code review with checks of the user journeys a change touches. A practical workflow for reviewing AI-authored changes without relying on a green check alone.
Best practicesTurn a production incident into a regression check
Capture the available error evidence, confirm a reproduction, describe the expected behavior, and schedule a reviewed regression check.
Best practicesUpgrade the framework, keep the tests
Use browser-level behavior checks alongside unit and component tests to compare an app before and after a framework upgrade.
Best practicesE2E testing React SPAs without losing your mind
SPA-specific E2E pitfalls — hydration, client routing, virtualized lists, optimistic UI, portals — and Playwright patterns for each.
Best practicesForm testing beyond the happy path
Validation states, error recovery, keyboard-only completion, file uploads, and autofill quirks — with Playwright sketches and a checklist.
Best practicesLocators that survive a redesign
A resilience hierarchy for Playwright locators, with code for each rung and the honest case for when data-testid is the right call.
Best practicesResponsive testing: when mobile emulation lies
What browser viewport emulation actually reproduces, what only breaks on real touch devices, and how to pick a viewport matrix you can afford to run.
Best practicesStrategies for testing 2FA and OTP
Three ways to automate login flows that send a one-time code, and the security trade-offs of each.
Best practicesTest data management for E2E suites
Seeding, per-run isolation, unique values, and cleanup strategies that keep end-to-end suites from flaking on shared data.
Best practicesTesting login, sessions, and everything auth
Patterns for testing authentication reliably — dedicated identities, session reuse, expiry, OAuth, and the lockout traps that flake suites.
Best practicesThe nightly regression playbook
A concrete nightly setup — what to schedule, failure-only alerts, a morning triage ritual, and how to keep the night green.
Best practicesWhy your tests flake (and what actually fixes it)
Five common causes of flaky end-to-end tests, with concrete fixes and a clear line on what auto-waiting does and doesn't solve.
Concepts 25
Claude Opus 5 and what a better model actually changes in test generation
Anthropic shipped Claude Opus 5 with configurable effort and much stronger self-verification. Here's what a frontier model upgrade really changes for generated Playwright tests — and what it can't.
ConceptsPlaywright AI: generate, verify, and maintain browser tests
AI can turn plain-English intent into Playwright tests that you review and regenerate. How AI test generation actually works — live exploration, web-first assertions, and regeneration.
ConceptsKimi K3 and the open-weight moment for test generation
Kimi K3 illustrates a private model-hosting option. Check its license, hardware needs and endpoint compatibility before using it for generation.
ConceptsThe model is swappable. The verification isn't.
Model choice affects test drafts, speed, and cost. Compare those trade-offs while retaining execution checks and human review of the generated expectations.
ConceptsWhere does your app go when AI tests it?
AI test generation ships your DOM, screenshots, and staging URLs to a model somewhere. For regulated buyers, where that model runs is a procurement gate.
ConceptsYour tests shouldn't change when the model does
If an LLM re-interprets your test at run time, every model swap is a silent suite change. Here's why a test must be a durable artifact, not a prompt.
ConceptsAccessible semantics deserve regression tests
Test accessible names, roles and keyboard journeys continuously, while keeping regression checks distinct from a full accessibility audit.
ConceptsAI generates your UI. What guards the behavior?
AI writes the interface now, and every regeneration can quietly break the form, the modal, the cart total. The guardrail that survives regenerated markup.
ConceptsYour app is fast until it's busy
Combine field monitoring, protocol load, and browser journeys to investigate whether checkout and other important interactions remain usable during a traffic spike.
ConceptsDon't let the agent grade its own homework
A coding agent's own tests inherit its own blind spots. Why reviewed expectations and behavior-level verification matter when an agent writes both code and tests.
ConceptsEnd-to-end tests are agent infrastructure now
Give coding agents repeatable behavior checks, record expectations beyond the current implementation, and keep automated results alongside human review.
ConceptsHelp the whole team describe useful test cases
Plain-language scenarios let product experts contribute test intent while QA and developers still review coverage, data setup, and executable assertions.
ConceptsHow framework plugins work under the hood
The three layers a TestVibe framework plugin ships — an init script, page-bound helpers, and generation guidance — and why they raise the ceiling on hard UIs.
ConceptsTesting server-driven UIs: a different mental model
Server-driven UIs treat the DOM as a projection of server state. Three testing rules change — here's the mental model for Wisej.NET, Blazor and Vaadin apps.
ConceptsTesting when CI is down
When your CI runner fleet stalls, your test signal shouldn't stall with it. Why CI is a trigger, not a test runner — and how to decouple the two.
ConceptsVibe coding won. Now it needs a safety net.
AI-assisted code still needs review and behavioral checks. Build a feedback loop around explicit requirements and observed test outcomes.
ConceptsBudgeting for test maintenance as your app changes
Authoring a test is a one-time cost. Keeping it green as the app changes is the recurring one, and how to include upkeep in the budget.
ConceptsDo you actually need Gherkin?
An honest look at when Given/When/Then earns its place and when it is just ceremony, with alternatives.
ConceptsHow much end-to-end testing do you actually need?
Choose end-to-end tests for important journeys, use unit and integration tests for focused rules, and budget for authoring, execution, and maintenance.
ConceptsMonitoring and testing are the same loop.
Prod telemetry finds what your tests missed; tests stop what telemetry found. How to close the loop so each one feeds the other, release after release.
ConceptsPlaywright, Cypress, Selenium in 2026: an honest comparison
A fair look at the three major browser-automation tools — architecture, waiting model, browser coverage, parallelism, and when each is the right choice.
ConceptsReading p95, p99, and errors in a load test
Read request-latency percentiles alongside throughput and errors, distinguish warm-up from saturation, and set load-test thresholds you can explain.
ConceptsShift-left without the slogans.
What actually changes when developers own end-to-end tests — PR-time suites that block the merge, feedback budgets, and who fixes the red test.
ConceptsShould you trust a test an AI wrote?
The honest answer is no, at least not on faith alone. A generated test earns trust by running against your real app, and by a human reading its spec.
ConceptsVisual regression vs functional testing: not either/or
What functional tests catch that pixel diffs miss, where visual regression earns its keep, and how to run both without drowning in noise.
No articles match “”.