Full Workflow

# Search for existing cases by feature keywords
python scripts/qase_client.py search-cases PROJ "login"
python scripts/qase_client.py search-cases PROJ "navigation"
python scripts/qase_client.py search-cases PROJ "homepage"

# List existing suites
python scripts/qase_client.py suites PROJ

# Get details of existing cases if needed
python scripts/qase_client.py get-case PROJ <case_id>

Output:

• List of existing test cases and their coverage
• Gaps that need new test cases
• Existing Qase case IDs to reuse for automation

Decision:

• If comprehensive coverage exists → Skip to Phase 4 (Automate)
• If partial coverage exists → Note existing IDs, create only missing cases
• If no coverage exists → Continue with full workflow

Phase 1: DISCOVER

Goal: Map the website structure

Use: site-discovery + mcp-client skills (Playwright server)

⚠️ CRITICAL: Playwright Session Behavior

Each MCP call = new browser session. Browser CLOSES after each call. Use browser_run_code for any multi-step exploration. If you need to explore multiple pages, each exploration is a FRESH session.

1. Use browser_run_code to:
   - Navigate to homepage
   - Accept cookies
   - Extract all links + snapshot
2. For each subpage, use browser_run_code AGAIN (session closed!):
   - Navigate to URL
   - Accept cookies AGAIN
   - Capture snapshot
3. Classify each page type
4. Document auth requirements

Example for homepage:

python .claude/skills/mcp-client/scripts/mcp_client.py call playwright browser_run_code '{
  "code": "
    await page.goto(\"https://example.com\");

    // Handle cookies (every session needs this!)
    const acceptBtn = page.getByRole(\"button\", { name: /accept/i });
    if (await acceptBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
      await acceptBtn.click();
      await page.waitForTimeout(500);
    }

    // Extract navigation
    const navLinks = await page.locator(\"nav a\").evaluateAll(els =>
      els.map(e => ({ text: e.textContent?.trim(), href: e.href }))
    );

    const snapshot = await page.accessibility.snapshot();
    return JSON.stringify({ navLinks, snapshot }, null, 2);
  "
}'

Output: Site map with classified pages

Phase 1.5: DISCOVER BEHAVIORAL DATA (For Negative Tests)

MANDATORY before designing negative tests! You must discover actual error messages, validation behavior, and UI states.

Goal: Capture real error messages, validation text, and behavioral data

Use: mcp-client skill with browser_run_code

What to discover:

Example - Discover login error:

python .claude/skills/mcp-client/scripts/mcp_client.py call playwright browser_run_code '{
  "code": "
    await page.goto(\"https://example.com/login\");

    // Cookies
    const acceptBtn = page.getByRole(\"button\", { name: /accept/i });
    if (await acceptBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
      await acceptBtn.click();
    }

    // Trigger error
    await page.fill(\"input[type=email]\", \"[email protected]\");
    await page.fill(\"input[type=password]\", \"wrongpass\");
    await page.click(\"button[type=submit]\");
    await page.waitForTimeout(3000);

    // Capture error elements
    const errors = await page.locator(\"[class*=error], [role=alert]\").evaluateAll(els =>
      els.map(e => ({ text: e.textContent?.trim(), role: e.getAttribute(\"role\") }))
    );

    return JSON.stringify({ errors }, null, 2);
  "
}'

Output: Behavioral data to use in test assertions

{
  "errors": [{ "text": "Email sau parolă incorectă", "role": "alert" }]
}

Use discovered values in tests:

// DON'T: await expect(page.locator('.error')).toContainText('Invalid credentials');
// DO: Use the ACTUAL discovered text
await expect(page.getByRole('alert')).toContainText('Email sau parolă incorectă');

Phase 2: DESIGN

Goal: Create test case specifications

Use: automation-tester skill

1. For each page type, apply test patterns
2. Assign priorities (P0/P1/P2)
3. Generate test case specs
4. Group into logical suites

Output: Test case list organized by suite

Phase 3: SYNC TO QASE

Goal: Push test suites and cases to Qase.io

Use: qase-client skill

# Create suites
python qase_client.py create-suite PROJ '{"title": "Authentication"}'
python qase_client.py create-suite PROJ '{"title": "Navigation"}'
python qase_client.py create-suite PROJ '{"title": "Core Features"}'

# Create cases in each suite
python qase_client.py create-case PROJ '{"title": "Valid login redirects", "suite_id": 1, "severity": 1}'
# ... repeat for each case

Output: Qase case IDs mapped to test specs

Phase 4: AUTOMATE

Goal: Generate Playwright test code

Use: test-generation skill

1. Create page objects for each tested page
2. Generate test specs for each suite
3. Link tests to Qase case IDs
4. Create playwright.config.ts if missing

Output:

pages/
├── login.page.ts
├── products.page.ts
tests/
├── auth.spec.ts
├── navigation.spec.ts
├── products.spec.ts
playwright.config.ts

Phase 5: RUN & REPORT

Goal: Execute tests and report to Qase

# Install dependencies
npm install @playwright/test
npx playwright install chromium

# Run tests
npx playwright test

# Report results to Qase
python qase_client.py create-run PROJ '{"title": "Automated Run"}'
python qase_client.py report-result PROJ 1 '{"case_id": 1, "status": "passed"}'
python qase_client.py complete-run PROJ 1

Workflow Summary

┌─────────────────────────────────────────────────────────────┐
│                      USER REQUEST                            │
│              "Test myplatform.com"                          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 0: CHECK EXISTING (MANDATORY)                         │
│ • Search Qase for existing test cases                       │
│ • Identify existing coverage                                │
│ • Note gaps and reusable case IDs                          │
│ Output: Existing coverage + gaps list                       │
└─────────────────────────────────────────────────────────────┘
                              │
                    ┌─────────┴─────────┐
                    │                   │
          (if full coverage)    (if gaps exist)
                    │                   │
                    ▼                   ▼
          Skip to Phase 4      Continue workflow
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 1: DISCOVER                                           │
│ • Navigate site via mcp-client (Playwright)                 │
│ • Map pages and classify types                              │
│ • Identify auth requirements                                │
│ Output: Site map                                            │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 1.5: DISCOVER BEHAVIORAL DATA (MANDATORY for neg)     │
│ • Trigger error states (bad login, validation, etc.)        │
│ • Capture ACTUAL error messages and selectors               │
│ • Document success/failure behaviors                        │
│ Output: Real text/selectors for test assertions             │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 2: DESIGN                                             │
│ • Apply test patterns by page type                          │
│ • Assign P0/P1/P2 priorities                                │
│ • Group into suites (skip existing cases)                   │
│ • Use discovered text for negative test assertions          │
│ Output: Test case specifications (gaps only)                │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 3: SYNC TO QASE                                       │
│ • Create suites via API (only if not exists)                │
│ • Create cases with steps (gaps only)                       │
│ • Record Qase IDs (existing + new)                          │
│ Output: Complete case ID mapping                            │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 4: AUTOMATE                                           │
│ • Generate page objects                                     │
│ • Generate test specs                                       │
│ • Link to Qase IDs (existing + new)                         │
│ Output: Playwright test files                               │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│ PHASE 5: RUN & REPORT                                       │
│ • Execute tests                                             │
│ • Create test run in Qase                                   │
│ • Report results                                            │
│ Output: Test results in Qase                                │
└─────────────────────────────────────────────────────────────┘

Example Conversation

User: Test myplatform.com, we use Qase.io

Claude: I'll help you test myplatform.com with Qase integration.

**Setup Check**
✓ QASE_API_TOKEN detected
✓ QASE_PROJECT_CODE: MYPROJ
✓ Playwright MCP connected

**Phase 0: Checking Existing Cases**
Searching Qase for existing test cases...

Found existing coverage:
- Suite "Authentication" (ID: 1) - 3 cases
  - Login with valid credentials (ID: 1)
  - Login with invalid password (ID: 2)
  - Logout successfully (ID: 3)
- Suite "Navigation" (ID: 2) - 2 cases
  - Main menu links work (ID: 4)
  - Footer links work (ID: 5)

Gaps identified:
- No registration tests
- No product listing tests
- No cart/checkout tests

**Phase 1: Discovery**
Exploring myplatform.com for gaps...

Found 8 key pages:
- / (Homepage)
- /login (Auth - COVERED)
- /register (Auth - GAP)
- /products (Listing - GAP)
- /products/:id (Detail - GAP)
- /cart (Transaction - GAP)
- /checkout (Transaction - GAP)
- /account (Dashboard - requires auth)

**Phase 2: Design**
Designed 12 NEW test cases (reusing 5 existing):
- Authentication: +2 new (registration tests)
- Products: +6 new
- Cart: +4 new

**Phase 3: Creating in Qase (gaps only)**
✓ Using existing suite "Authentication" (ID: 1)
✓ Created suite "Products" (ID: 3)
✓ Created suite "Cart" (ID: 4)
✓ Created 12 new test cases (cases 6-17)

Total coverage: 17 test cases (5 existing + 12 new)

**Phase 4: Generating Tests**
Created files:
- pages/login.page.ts
- pages/products.page.ts
- pages/cart.page.ts
- tests/auth.spec.ts (includes existing case IDs 1-5)
- tests/products.spec.ts (case IDs 6-11)
- tests/cart.spec.ts (case IDs 12-17)

**Phase 5: Ready to Run**
```bash
npm install
npx playwright test

Results will sync to Qase automatically.

## Decision Points

| Situation | Action |
|-----------|--------|
| No auth credentials | Test public pages only |
| Payment required | Test until payment step |
| Auth wall on first page | Ask for credentials |
| >50 pages found | Focus on main nav |
| Site errors | Document and continue |

## References

See the references folder for detailed documentation:

- **[workflow-checklist.md](references/workflow-checklist.md)** - Step-by-step checklist for each phase
- **[decision-tree.md](references/decision-tree.md)** - Visual decision trees for common scenarios
- **[phase-outputs.md](references/phase-outputs.md)** - Expected output format for each phase