DOCSEARCHbyAlgolia
Submit Docs

Argos Visual Testing

website·Indexed 35 days ago

https://argos-ci.com/docs/

A visual testing platform designed to catch visual regressions before they reach production. Argos provides SDKs for Playwright, Vitest, Storybook, Cypress, WebdriverIO, and Puppeteer, as well as a CLI for any test framework. It features deterministic pixel diffing using the odiff library, baseline build analysis, flaky test detection, and AI-powered agents to summarize visual changes and fix unstable tests.

Tokens
59.5K
Snippets
227
Records
457
Agent score
70%

What's inside Argos

  1. Overview of Argos Media Sharing

    Argos Media Sharing allows developers to upload standalone images or videos (without a build or test run) to get a shareable URL and ready-to-paste Markdown. This is particularly useful for CI jobs or agents that cannot authenticate with GitHub to attach files to pull requests. Media is associated with a project and inherits its access controls. Note that this is not visual testing; it is a file hosting service for documentation and bug reporting.

  2. Overview of migrating to Argos visual testing

    Migrating to Argos typically involves swapping the SDK, the snapshot call, and the CI step without rewriting the existing test suite. Argos supports integration with Playwright, Cypress, Storybook, WebdriverIO, and Puppeteer, or can accept screenshots via its CLI.

    Key architectural differences in Argos:

    • Git-based Baselines: Baselines are selected automatically from Git history; reference images are not committed to the repository.
    • PR-centric Review: Diffs are approved/rejected in the Argos app and reported via commit statuses and PR comments.

  3. Overview of the Argos Review Workflow

    Argos integrates visual regression testing into the development lifecycle by surfacing visual changes across the dashboard, pull requests, and status checks. The workflow consists of several key components: browsing builds, reviewing specific changes, receiving PR comments, monitoring commit status checks, using tags for filtering, leveraging AI agents for triage, and setting up event-based notifications via automations.

  4. Overview of Microsoft Teams integration for Argos

    Argos integrates with Microsoft Teams to send automatic notifications when builds are created, reviewed, approved, or rejected. Notifications are delivered as adaptive cards containing build status, project details, screenshot counts, commit, branch, and a direct link to the build.

    Key constraints:

    • Available only on Pro and Enterprise plans.
    • Configured at the team level.
    • Requires a Microsoft 365 work or school account (personal accounts at teams.live.com are not supported).
    • One webhook is required per channel; there is no URL unfurling for Argos links posted manually in Teams.

  5. Overview of Argos Automations

    Automations are project-specific rules that trigger notifications to external communication channels (Slack, Microsoft Teams, or Discord) when specific build events occur. They follow a 'When-If-Then' logic:

    • When: The trigger event (OR logic: any selected event triggers the rule).
    • If: Optional filtering conditions (AND logic: all conditions must match).
    • Then: The resulting action (notification).

    Automations are configured per project and are available on team projects for users with permission to view project settings.

  6. Overview of Argos Deployments

    Argos Deployments allow you to host static builds (most commonly Storybook) on unique URLs for every pull request. This enables developers to share live previews with stakeholders and browse the history of deployed builds across branches and commits. Each deployment is immutable; re-running the deploy command creates a new URL rather than overwriting the previous one. The process involves three phases: building the site, uploading files (using content hashing to skip unchanged files), and serving the build via a generated URL.

  7. Overview of Storybook story modes in Argos

    Argos 'modes' allow you to capture multiple versions of your Storybook stories by applying different combinations of global settings (e.g., theme, viewport, locale). Each named mode generates a separate visual baseline in Argos, enabling automatic visual regression testing across different configurations (e.g., a 'dark' mode and a 'mobile' mode).

  8. Overview of the Argos MCP server

    The Argos MCP server is a remote server that allows AI assistants (like Claude, Cursor, and VS Code) to interact with Argos projects using the Model Context Protocol (MCP). It uses the streamable HTTP transport, meaning no local installation is required. The server exposes tools generated directly from the Argos REST API, allowing agents to inspect builds, manage visual changes, handle comments, and administer project settings.
    URL: https://mcp.argos-ci.com
Transport: http (or streamable-http)

  9. Overview of Argos Slack integration

    The Argos Slack integration provides automatic build notifications and rich URL unfurling (previews) when Argos build URLs are shared in Slack. This integration is available for users on Pro and Enterprise plans. Key features include notifications for build creation, review, approval, or rejection, and the ability to control these alerts via automation conditions.

  10. Overview of Argos Visual Testing Platform

    Argos is a visual testing platform designed to catch visual regressions before they reach production. It integrates with CI pipelines to capture screenshots, compare them against a baseline, and provide visual diffs for review on pull requests. It supports tools such as Playwright, Storybook, Cypress, and Vitest. Beyond image comparison, Argos can compare non-image files, detect flaky tests, and deploy previews of Storybook or static sites for every pull request.

  11. Monitor project-wide test flakiness

    For a high-level overview of all tests ranked by their flakiness score, use the Tests dashboard. Individual ignored changes and their frequency of occurrence can be tracked on the Ignored changes page to ensure that old ignores do not become permanent blind spots.

  12. Understand how Argos selects a baseline build

    In CI mode, Argos selects a baseline build by finding the most recent build that satisfies both candidate-specific and relative criteria. A baseline build serves as the reference point for detecting visual changes in new builds.

    Candidate Build Criteria:

    • Must be complete (processing finished).
    • Tests must have passed (no failed tests that produced screenshots).
    • Must not be a subset build (must have uploaded the full set of snapshots).
    • Must have no active rejection (rejections must be dismissed).
    • Must be approved (either auto-approved, an orphan build, or a check build with an approved review/merged PR).

    Relative Criteria (compared to the new build):

    • Must have the same build name and build mode.
    • The candidate's commit must be an ancestor of the merge base (the closest common commit between the current branch and the baseline branch).