Testing & Validation

#!/bin/bash
# test-agent-levels.sh
# Tests all 6 agent capability levels (0-5) against a BiModal site
# Usage: bash test-agent-levels.sh https://yoursite.com

URL="${1:-https://yoursite.com}"
PASS=0
FAIL=0

ok() { echo "  PASS  $1"; ((PASS++)); }
fail() { echo "  FAIL  $1"; ((FAIL++)); }
check_count() {
  local desc="$1" cmd="$2"
  local n; n=$(eval "$cmd" 2>/dev/null | tr -d '[:space:]')
  [ "$n" -gt 0 ] 2>/dev/null && ok "$desc ($n found)" || fail "$desc"
}
check_http() {
  local desc="$1" url="$2"
  local code; code=$(curl -s -o /dev/null -w "%{http_code}" "$url")
  [ "$code" = "200" ] && ok "$desc" || fail "$desc (HTTP $code)"
}

echo ""
echo "BiModal Design — Agent Level Test Suite"
echo "Target: $URL"
echo "$(date)"
echo "============================================"

echo ""
echo "LEVEL 0: HTTP / curl access"
check_count "data-agent-* present in HTML"   "curl -s '$URL' | grep -c 'data-'"
check_count "<title> present"   "curl -s '$URL' | grep -c '<title'"
check_count "No empty-root-only SPA"   "curl -s '$URL' | grep -v 'id="root">' | grep -c '<main|<article|<section'"

echo ""
echo "LEVEL 1: Structured data (Schema.org)"
check_count "JSON-LD present"   "curl -s '$URL' | grep -c 'application/ld+json'"
check_count "schema.org reference"   "curl -s '$URL' | grep -c 'schema.org'"

echo ""
echo "LEVEL 2: Browser automation attributes"
check_count "data-agent-page attribute"   "curl -s '$URL' | grep -c 'data-agent-page'"
check_count "data-agent-component attributes"   "curl -s '$URL' | grep -c 'data-agent-component'"
check_count "data-agent-action attributes"   "curl -s '$URL' | grep -c 'data-agent-action'"

echo ""
echo "LEVEL 3: Semantic structure"
check_count "HTML5 <main> element"   "curl -s '$URL' | grep -c '<main'"
check_count "HTML5 <nav> element"   "curl -s '$URL' | grep -c '<nav'"
check_count "Skip-to-content link"   "curl -s '$URL' | grep -c 'skip-to-content|#main-content'"
check_count "Single <h1>"   "curl -s '$URL' | grep -c '<h1'"

echo ""
echo "LEVEL 4: API surface"
check_http "OpenAPI spec accessible" "$URL/api/openapi.json"
check_count "<link rel=api> in head"   "curl -s '$URL' | grep -c 'rel=.api.'"

echo ""
echo "LEVEL 5: Agent protocols"
check_http "Agent Card (/.well-known/agent.json)" "$URL/.well-known/agent.json"
check_http "robots.txt accessible" "$URL/robots.txt"

echo ""
echo "============================================"
echo "Results: $PASS passed, $FAIL failed"
echo ""
if [ $FAIL -eq 0 ]; then
  echo "All agent levels fully supported (Level 5 — Agent Native)"
elif [ $FAIL -le 3 ]; then
  echo "Most levels supported — fix FAIL items above"
else
  echo "Significant gaps — review BiModal implementation guide"
fi

// tests/agent-level-2.spec.ts
import { test, expect } from '@playwright/test';

const BASE_URL = process.env.BASE_URL ?? 'https://yoursite.com';

test.describe('Level 2: Browser Automation (data-agent-* attributes)', () => {
  test('product listing page has required agent attributes', async ({ page }) => {
    await page.goto(`${BASE_URL}/products`);

    // Page-level attributes
    const main = page.locator('[data-agent-page="product-listing"]');
    await expect(main).toBeVisible();

    // Component attributes present
    const productCards = page.locator('[data-agent-component="product-card"]');
    await expect(productCards.first()).toBeVisible();

    // Content fields extractable
    const firstProductName = page
      .locator('[data-agent-component="product-card"]')
      .first()
      .locator('[data-agent-content="product-name"]');
    await expect(firstProductName).toBeVisible();
    const nameText = await firstProductName.textContent();
    expect(nameText?.length).toBeGreaterThan(0);
  });

  test('agent can find and trigger add-to-cart action', async ({ page }) => {
    await page.goto(`${BASE_URL}/products`);

    // Agent locates the first product's add-to-cart action
    const addToCart = page
      .locator('[data-agent-action="add-to-cart"]')
      .first();
    await expect(addToCart).toBeVisible();

    // Action is triggerable
    await addToCart.click();
    // Assert outcome (cart count increments, etc.)
  });

  test('navigation actions are discoverable', async ({ page }) => {
    await page.goto(BASE_URL);

    const nav = page.locator('[data-agent-component="navigation"]');
    await expect(nav).toBeVisible();

    // All expected navigation actions present
    for (const action of ['go-home', 'view-products', 'get-support']) {
      const link = nav.locator(`[data-agent-action="${action}"]`);
      await expect(link).toBeVisible(`action "${action}" not found in nav`);
    }
  });

  test('content visible without JavaScript (Level 0 regression)', async ({ browser }) => {
    const context = await browser.newContext({ javaScriptEnabled: false });
    const page = await context.newPage();
    await page.goto(`${BASE_URL}/products`);

    // Core content must be present even without JS
    await expect(page.locator('h1')).toBeVisible();
    const agentAttrs = await page.locator('[data-agent-component]').count();
    expect(agentAttrs).toBeGreaterThan(0);

    await context.close();
  });

  test('structured data extractable from DOM', async ({ page }) => {
    await page.goto(`${BASE_URL}/products/sample`);

    const jsonLd = await page
      .locator('script[type="application/ld+json"]')
      .first()
      .textContent();
    expect(jsonLd).toBeTruthy();

    const data = JSON.parse(jsonLd!);
    expect(data['@context']).toContain('schema.org');
    expect(data['@type']).toBeTruthy();
  });
});