home / skills / openclaw / skills / web-qa-bot

web-qa-bot skill

/skills/nextfrontierbuilds/web-qa-bot

This skill automates web QA using accessibility-tree testing to reliably detect issues, generate reports, and accelerate pre-deployment validation.

npx playbooks add skill openclaw/skills --skill web-qa-bot

Review the files below or copy the command above to add this skill to your agents.

Files (20)
SKILL.md
3.6 KB
---
name: web-qa-bot
description: AI-powered web application QA automation using accessibility-tree based testing. Smoke tests, test suites, and PDF reports.
version: 0.1.0
---

# web-qa-bot

AI-powered web application QA automation using accessibility-tree based testing.

## Overview

This skill provides tools for automated QA testing of web applications. It uses browser accessibility trees for reliable element detection instead of fragile CSS selectors.

## Installation

```bash
npm install -g web-qa-bot agent-browser
agent-browser install
```

## Commands

### Quick Smoke Test

```bash
web-qa-bot smoke https://example.com
```

Runs basic health checks:
- Page loads successfully
- No console errors
- Navigation elements present
- Images have alt text

### Run Test Suite

```bash
web-qa-bot run ./tests/suite.yaml --output report.md
```

### Generate PDF Report

```bash
web-qa-bot report ./results.json -o report.pdf -f pdf
```

## Use Cases

### 1. Quick Site Health Check

```bash
# Smoke test a production URL
web-qa-bot smoke https://app.example.com --checks pageLoad,consoleErrors,navigation
```

### 2. Pre-deployment QA

Create a test suite and run before each deployment:

```yaml
# tests/critical-paths.yaml
name: Critical Paths
baseUrl: https://staging.example.com

tests:
  - name: Login flow
    steps:
      - goto: /login
      - type: { ref: Email, text: [email protected] }
      - type: { ref: Password, text: testpass }
      - click: Sign In
      - expectVisible: Dashboard
      - expectNoErrors: true
```

```bash
web-qa-bot run ./tests/critical-paths.yaml --output qa-report.pdf -f pdf
```

### 3. Monitor for Regressions

```bash
# Run tests and fail CI if issues found
web-qa-bot run ./tests/smoke.yaml || exit 1
```

### 4. Programmatic Testing

```typescript
import { QABot } from 'web-qa-bot'

const qa = new QABot({
  baseUrl: 'https://example.com',
  headless: true
})

await qa.goto('/')
await qa.click('Get Started')
await qa.snapshot()
qa.expectVisible('Sign Up')
await qa.close()
```

## Integration with agent-browser

This tool wraps agent-browser CLI for browser automation:

```bash
# Connect to existing browser session
web-qa-bot smoke https://example.com --cdp 18800

# Run headed for debugging
web-qa-bot run ./tests/suite.yaml --no-headless
```

## Test Results Format

Results are returned as structured JSON:

```json
{
  "name": "Smoke Test",
  "url": "https://example.com",
  "summary": {
    "total": 4,
    "passed": 3,
    "failed": 0,
    "warnings": 1
  },
  "tests": [
    {
      "name": "Page Load",
      "status": "pass",
      "duration": 1234
    }
  ]
}
```

## Tips

1. **Use role-based selectors** - More reliable than CSS classes
2. **Check console errors** - Often reveals hidden issues
3. **Test both navigation methods** - Direct URL and in-app routing
4. **Screenshot on failure** - Automatic in test suites
5. **Monitor for modals** - Can block interactions

## Report Formats

- **Markdown** - Default, human-readable
- **PDF** - Professional reports via ai-pdf-builder
- **JSON** - Machine-readable for CI/CD

## Troubleshooting

### "agent-browser not found"
```bash
npm install -g agent-browser
agent-browser install
```

### "Element not found"
Take a snapshot first to see available refs:
```bash
agent-browser snapshot
```

### "Timeout waiting for element"
Increase timeout or check if element is behind a loading state:
```yaml
steps:
  - waitMs: 2000
  - waitFor: "Loading" # Wait for loading to appear
  - waitFor: "Content" # Then wait for content
```

## Links

- [GitHub](https://github.com/NextFrontierBuilds/web-qa-bot)
- [npm](https://www.npmjs.com/package/web-qa-bot)

Overview

This skill delivers AI-powered web application QA automation using accessibility-tree based testing. It focuses on reliable element detection via role-based selectors and accessibility trees to avoid brittle CSS selectors. Outputs include smoke tests, full test suites, structured JSON results, Markdown and PDF reports.

How this skill works

The tool drives a browser (via agent-browser) to navigate pages, interact with elements using accessibility refs, and run assertions such as visibility, console errors, and expected content. Tests can be run as one-off smoke checks, scripted YAML suites, or programmatically via the QABot API. Results are returned as structured JSON and can be exported to Markdown or PDF reports.

When to use it

  • Quickly verify production or staging site health with a smoke test
  • Run pre-deployment critical-path suites to catch regressions
  • Integrate into CI to fail builds when tests detect issues
  • Generate human-friendly PDF reports for stakeholders
  • Programmatic checks during end-to-end automation or debugging

Best practices

  • Use role-based or accessibility refs instead of CSS classes for stable selectors
  • Include console error checks to surface hidden runtime problems
  • Take screenshots or snapshots on failures to accelerate debugging
  • Run suites headless in CI and headed locally when investigating issues
  • Add waits for loading states to avoid flakiness from async content

Example use cases

  • Run web-qa-bot smoke https://app.example.com to validate page load, navigation, images and console
  • Execute a YAML test suite before each deployment to verify login and core flows
  • Hook web-qa-bot run into CI to block merges when tests fail
  • Produce PDF executive reports from test results for release reviews
  • Use the programmatic QABot API to script flows inside a larger test harness

FAQ

What does accessibility-tree based testing mean?

It means the tool finds and interacts with elements using the browser's accessibility tree and role-based refs rather than fragile CSS selectors, improving resilience to UI changes.

How do I get PDF reports?

Run the report command or specify -f pdf when running a suite; the tool uses an ai-pdf-builder to create professional PDF output from results.