Summary of "Esta IA hace Testing de TODO tu código (en local y produccion)"

What TestSprite is

TestSprite is an AI-driven end-to-end testing platform (MCP-style tool) that auto-generates, runs, and records tests for web apps locally and in production. It integrates as an “MCP” into code editors and AI agents so the editor/agent can call TestSprite tooling directly.

Key capabilities / product features

Auto-generates tests from a short product specification (PRD) or by scanning the project.
Saves generated tests into your repo (creates a test-sprite-test folder); tests can be tracked with Git.
Executes tests step-by-step by controlling a browser (Playwright/Selenium style) and supports parallel runs.
Records detailed step logs and a video of each test run for playback and debugging.
Visual test-step editor: modify inputs or steps in a recorded run and re-run only that step or subsequent steps.
Produces machine- and human-readable reports (Markdown/raw report + HTML previews).
Supports writing tests in a different language than the app (e.g., TypeScript app with tests emitted in Python).
Continuous integration:
- GitHub App integration runs tests on PRs, can block merges if tests fail, and re-runs tests on deployment.
Cloud-run support for testing deployed branches (hosts include Vercel, Netlify, Render, Fly.io).
Free trial/tier: example mention of 150 credits/month for trying the service.
API keys authenticate MCP connections from editors and CI.

Tutorial / demo — practical workflow

Prepare your app and a dedicated test account (recommend creating an AI/test-only user for login credentials).
Create a TestSprite account and generate a named API key.
Add TestSprite as an MCP in your editor/agent:
- Cursor: “Add to Cursor”, paste API key, install; open chat and ask “Help me test this project using TestSprite”.
- Cloud Code: run the quick install script/CLI, paste API key into the install command, confirm MCP listed.
- VS Code: use the MCP/add server flow (stdin/stdout server), add TestSprite command in workspace config, paste API key into config, restart workspace; open chat and request tests.
- Antigravity/other editors: paste the MCP config JSON and API key into the editor’s MCP server management.
(Optional) Generate a PRD via AI and upload it to the project (e.g., into a docs folder) so TestSprite knows expected behavior.
Run TestSprite from the editor/agent chat or cloud command. It scans the project, generates tests, writes files, and executes them.
Inspect results in the dashboard: list of tests, pass/fail status, detailed step logs, and a recorded video per test. Use the UI to edit input values and re-run specific steps.
GitHub integration: install the GitHub App, link repo(s), and configure toggles for PR/draft/auto-run/block merging on failures.
Deploy branches to supported hosts (Render, Vercel, Netlify, Fly.io) to allow TestSprite to run tests against live environments.
Iterate: fix issues, re-run tests locally or via CI; TestSprite will reuse the previously generated test folder.

Examples and findings from the demo app

Demo app: plant image upload + analysis (uses GPT-4/Gemini models for image interpretation).
Auto-detected tests included:
- Landing page load
- Registration/email validation
- Login/dashboard
- Report generation
- Analysis flow
Example failures observed:
- Dashboard rendered charts immediately with no loading placeholder (AI flagged missing skeleton/loader).
- An analysis/report flow did not reach the final report step (test failed and video showed the failure).
The presenter used the UI to change an email field value in a registration test and re-ran only that step to validate behavior quickly.

Artifacts produced by TestSprite

Test folder in repo (test code files).
Markdown/raw test report (readable in editor preview).
Per-test step logs and replayable video recordings.
CI status checks on PRs (pass/fail visible in GitHub).

Notes, recommendations, and constraints

Create a dedicated AI/test account so credentials can be deleted after testing.
Restart the editor after MCP install if the MCP doesn’t appear connected right away.
Tests are generated by scanning the project and the PRD — ensure the PRD accurately describes desired behavior.
You must deploy the project (to supported hosts) for TestSprite to run GitHub/PR production checks.
API keys are scoped per environment; you can reuse the same key across editors or create separate keys per tool.

Quick checklist for getting started

Create a TestSprite account (get free credits).
Create an API key (name it per-editor if desired).
Install the TestSprite MCP in your editor/agent (Cursor, Cloud Code, VS Code, Antigravity, etc.).
Start your app locally (note port + route) and provide a test account to the tool.
Provide or generate a short PRD/spec and upload it to TestSprite.
Run tests, review videos/reports, edit steps as needed, fix issues, and re-run.
(Optional) Install the GitHub App, enable PR checks, and connect to a deployment host for production checks.

Main speakers / sources

Presenter / video author: owner/creator referenced by fast.dev (presenter signs off mentioning fast.dev and social links).
Product / primary source: TestSprite.
Tools and integrations referenced: Cursor, Cloud Code, VS Code, Antigravity, Trie (editor/agent MCP hosts); GitHub (PR integration); deployment hosts: Render, Vercel, Netlify, Fly.io.