test-site

Plugin check: Run node "${PLUGIN_ROOT}/scripts/check-version.js" — if it outputs a message, show it to the user before proceeding.

Test Power Pages Site

Test a deployed, activated Power Pages site at runtime. Navigate the site in a browser, crawl all discoverable links, verify pages load correctly, capture network traffic to test API requests, and generate a comprehensive test report.

Prerequisite: This skill expects a deployed and activated Power Pages site. Run /deploy-site and /activate-site first if the site is not yet live.

Core Principles

• Non-destructive: This skill is read-only — it does not create, modify, or delete any files or data. It only observes the site via the browser.
• API-first testing: The primary goal beyond page loads is verifying that all /_api/ (Web API / OData) requests return successful responses.
• Response-shape discovery: For /_api/serverlogics/ endpoints the test run must also capture and report the actual response body shape so frontend integrations can be written against the real response, not a guessed one. If frontend parsing or field access does not match the observed shape, report the mismatch and describe the parsing or field-access changes needed — this skill does not modify any code.
• User-controlled authentication: Never attempt to log in automatically. Always ask the user to log in via the browser window when authentication is required.
• Bounded crawling: Cap page crawling at 25 pages to prevent infinite loops on sites with dynamic or paginated URLs.

Validation Test Categories

Every run produces a categorized test report (docs/alm/last-test-site.json — see Phase 6.7a). Stable category IDs and the source phase that produces each:

Category id	Display Name	Source phase	What it covers
site-load	Site Load	Phase 2	Homepage HTTP status, redirect handling, initial render. One card for the homepage; failures are critical.
authentication	Authentication	Phase 3	Anonymous-to-Entra redirect, private-site gate detection, login flow integrity. Critical for private sites.
page-crawl	Page Crawl	Phase 4	One card per page tested (up to 25). Each card carries the page URL, HTTP status, and any console errors. Severity scales with HTTP class (5xx → critical, 4xx on public → high).
web-api	Web API	Phase 5	One card per /_api/ endpoint observed during the run. Captures status code, response shape, and remediation hints (table-permissions / site-settings / inner-error settings).
auth-pages	Authenticated Pages	Phase 5.6	Pages that only became reachable after login. Skipped when the user opts out of authenticated testing.
auth-api	Authenticated API	Phase 5.6	API endpoints that only became callable after login. Skipped when authenticated testing is skipped.
console	Console Health	Aggregated	Rolled-up count of console errors observed across all phases. Severity is medium by default.

plan-alm's Validation tab consumes this shape directly — each category becomes a collapsible group in the per-stage sub-tab, and the rolled-up runOutcome (passed / passed-with-warnings / failed) drives the green / yellow / red Outcome badge in both the Validation tab and the Execution checklist substep.

Initial request: $ARGUMENTS

---

Phase 1: Resolve Site URL

Goal: Determine the live URL of the Power Pages site to test.

Actions

1.1 Create Task List

Create the full task list with all 6 phases before starting any work (see Progress Tracking table).

1.2 Check User Input

If the user provided a URL in $ARGUMENTS:

1. Validate it starts with https://.
2. Store it as SITE_URL and skip to Phase 2.

1.3 Auto-Detect from Activation Status

If no URL was provided, attempt auto-detection:

1. Locate the project root by searching for powerpages.config.json:

   **/powerpages.config.json
   

2. Run the activation status check script:

   node "${PLUGIN_ROOT}/scripts/check-activation-status.js" --projectRoot "<PROJECT_ROOT>"
   

3. Evaluate the JSON result:

   • If activated is true and websiteUrl is present: Use websiteUrl as SITE_URL. Inform the user: "Detected your site URL: "
   • If activated is false: Inform the user: "Your site is not yet activated. Please run /activate-site first, then re-run this skill." Stop the skill.
   • If error is present: Fall through to step 1.4.

1.4 Ask the User

If auto-detection failed or was inconclusive, use AskUserQuestion:

Question	Header	Options
What is the URL of the deployed Power Pages site you want to test? (e.g., https://contoso.powerappsportals.com)	Site URL	I'll paste the URL (description: Select "Other" below and paste your site URL), I don't know my URL (description: Run /activate-site to get your site URL, or check the Power Platform admin center)

Store the user-provided URL as SITE_URL.

Output

• SITE_URL resolved and ready for testing

---

Phase 2: Launch Browser & Initial Load

Goal: Open the site in a browser, verify the homepage loads, and capture baseline errors.

Actions

2.1 Resize Browser

Set the browser to a standard desktop viewport:

• Use browser_resize with width: 1280, height: 720.

2.2 Navigate to Site

• Use browser_navigate to open SITE_URL.

2.3 Wait for Page Load

• Use browser_wait_for with time: 5 seconds to allow the page to fully render (SPAs may need time for client-side routing and API calls).

2.4 Verify Homepage

• Use browser_snapshot to take an accessibility snapshot.
• Check the snapshot for signs of a working page:
  • Page has meaningful content (not blank, not a generic error page).
  • Look for common error indicators: "404", "Page not found", "500", "Internal Server Error", "This site can't be reached".
• If the page shows an error, report it to the user and ask whether to continue or stop.

2.5 Capture Console Errors

• Use browser_console_messages with level: "error" to check for JavaScript errors on initial load.
• Record any errors found — these will be included in the final report.

2.6 Capture Initial Network Requests

• Use browser_network_requests with includeStatic: false to capture the initial page load API calls.
• Record any /_api/ or OData requests and their status codes for Phase 5 analysis.

Output

• Browser launched at correct viewport size
• Homepage loaded and verified via snapshot
• Initial console errors and network requests recorded
• If the homepage shows a login screen, noted for Phase 3

---

Phase 3: Authentication Check

Goal: Detect if the site requires authentication and handle login if needed. Power Pages sites can have two layers of authentication:

1. Private site gate — The entire site is private. Navigating to the site redirects to an identity provider (Azure AD B2C, etc.) before any site content is visible. The browser URL will typically change to a different domain (e.g., login.microsoftonline.com, *.b2clogin.com).
2. Site-level authentication — The site is publicly accessible (homepage loads), but certain pages or features require a logged-in user with a specific web role. Indicated by "Sign in" / "Log in" links in the navigation, or pages that show restricted-access messages.

Actions

3.1 Analyze Homepage Snapshot for Private Site Gate

Review the browser snapshot from Phase 2.4 and the current browser URL for signs of a private site redirect:

• The page content shows an identity provider login form (Azure AD B2C, Azure AD, etc.)
• The browser URL has changed to a different domain than SITE_URL (e.g., login.microsoftonline.com, *.b2clogin.com, or a custom identity provider domain)
• A 401/403 response was returned before any site content loaded
• The page is blank or shows "Access denied" / "You do not have access" with no site navigation visible

3.2 Handle Private Site Gate

🚦 Gate (pause · test-site:3.2.private-gate-login): External wait — site redirected to identity provider; skill pauses until user completes login or cancels.

If a private site gate is detected, use AskUserQuestion:

Question	Header	Options
This site is private — it redirected to an identity provider login page before any content could load. A browser window should be open showing the login page. Please log in there using credentials that have access to this site. Once you have successfully logged in and can see the site homepage, select "I have logged in" below.	Private Site Login	I have logged in (Recommended) — I've completed the login and can see the site, Cancel testing — Stop the test

If "I have logged in":

1. Use browser_snapshot to verify the user is now on the actual site (site content visible, navigation present, URL is back on the SITE_URL domain).

2. If still on the identity provider login page:

   🚦 Gate (pause · test-site:3.2.login-retry): Login not yet complete — re-prompt or cancel.

   • Use AskUserQuestion again: "It looks like the login hasn't completed yet. The browser should still be open — please complete the login and try again."
   • Repeat until login is confirmed or user cancels.

3. Once confirmed, re-run Phase 2.5 and 2.6 (capture console errors and network requests on the now-loaded homepage).

4. Continue to step 3.3 to check for site-level authentication.

If "Cancel testing":

• Stop the skill and inform the user they can re-run it after resolving access.

3.3 Analyze for Site-Level Authentication

After the homepage is loaded (either directly for public sites, or after passing the private site gate), review the snapshot for signs of site-level authentication:

• "Sign in" / "Log in" / "Register" links or buttons in the site navigation
• Pages that show "You must be signed in to view this page" or similar messages
• Content that indicates some areas are restricted to authenticated users

3.4 Handle Public Site (No Authentication Needed)

If neither a private site gate nor site-level authentication indicators are found:

• Inform the user: "Site is publicly accessible. Proceeding with page and API testing."
• Skip to Phase 4.

3.5 Handle Site-Level Authentication

🚦 Gate (plan · test-site:3.5.public-vs-auth): Site has Sign-in UI — test as authenticated user, skip auth-gated pages, or cancel.

If site-level authentication indicators are detected (login links in navigation, etc.), use AskUserQuestion:

Question	Header	Options
The site has a Sign in option, which means some pages or API calls may require authentication. A browser window should be open — you can click "Sign in" and log in with a user account that has the appropriate web role. Once you have successfully logged in, select "I have logged in" below.	Site Authentication	I have logged in (Recommended) — I've signed in through the site's login flow, Skip authenticated pages — Only test publicly accessible pages and APIs, Cancel testing — Stop the test

If "I have logged in":

1. Use browser_snapshot to verify the user is now logged in (login link replaced with user name/profile, or authenticated content is visible).

2. If the login form is still showing:

   🚦 Gate (pause · test-site:3.5.login-retry): Site-level login not yet complete — re-prompt or cancel.

   • Use AskUserQuestion again: "It looks like the login hasn't completed yet. The browser should still be open — please complete the login and try again."
   • Repeat until login is confirmed or user cancels.

3. Create an additional task for testing authenticated scenarios using TaskCreate:

   Task subject	activeForm	Description
   Test authenticated pages and APIs	Testing authenticated scenarios	Re-crawl site as logged-in user, verify auth-gated pages load and authenticated API calls succeed

If "Skip authenticated pages":

• Note that only public pages will be tested. Some API calls may return 401/403 — these will be flagged but not treated as failures.
• Do not create the authenticated testing task.
• Continue to Phase 4.

If "Cancel testing":

• Stop the skill and inform the user they can re-run it after resolving authentication.

Output

• Authentication status resolved for both layers:
  • Private site gate: passed, not needed, or cancelled
  • Site-level auth: logged in, skipped, or not needed
• If authenticated: additional task created for authenticated testing in Phase 5.6

---

Phase 4: Crawl & Test Pages

Goal: Discover all navigable links on the site and verify each page loads correctly.

Actions

4.1 Discover Links from Current Page

Use browser_evaluate to extract all internal links:

() => {
  const links = Array.from(document.querySelectorAll('a[href]'));
  return links
    .map(a => a.href)
    .filter(href => href.startsWith(window.location.origin))
    .filter(href => !href.includes('#') || href.split('#')[0] !== window.location.href.split('#')[0])
    .map(href => href.split('#')[0])
    .filter((href, i, arr) => arr.indexOf(href) === i);
}

Present the discovered links to the user:

"Found X internal links on the homepage. Testing each page..."

4.2 Test Each Page

For each discovered URL, in sequence:

1. Navigate: Use browser_navigate to go to the URL.
2. Wait: Use browser_wait_for with time: 3 seconds for the page to render.
3. Snapshot: Use browser_snapshot to verify the page rendered content.
4. Check for errors: Look for error indicators in the snapshot (404, 500, blank page, error messages).
5. Console errors: Use browser_console_messages with level: "error" to check for JavaScript errors.
6. Discover new links: Use browser_evaluate (same script as 4.1) to find any new internal links not already in the queue.
7. Record result: URL, status (Pass/Fail), error count, notes.

4.3 Crawl Newly Discovered Links

• Add any newly discovered links from step 4.2.6 to the test queue.
• Continue testing until all links are visited or the 25-page cap is reached.
• If the cap is hit, inform the user: "Reached the 25-page testing limit. Y additional links were discovered but not tested."

4.4 Record Page Test Results

Build a results list tracking:

• URL tested
• Load status (Pass / Fail)
• Number of console errors
• Notes (error messages, blank page, redirect, etc.)

Output

• All discoverable pages crawled (up to 25)
• Pass/fail status recorded for each page
• New links discovered during crawl added to results

---

Phase 5: Test API Requests

Goal: Capture and analyze all API requests made by the site to verify they are working.

Actions

5.1 Revisit Data-Driven Pages

Navigate back to pages that are likely to make API calls — pages with dynamic content such as data tables, lists, forms, or dashboards. Prioritize pages where /_api/ requests were observed in Phase 2.6 or Phase 4.

For each data-driven page:

1. Use browser_navigate to go to the page.
2. Use browser_wait_for with time: 5 seconds to allow API calls to complete.

5.2 Capture Network Requests

• Use browser_network_requests with includeStatic: false to get all network requests.
• Filter for API requests matching these patterns:
  • /_api/ — Power Pages Web API / OData endpoints
  • /api/ — Custom API endpoints
  • URLs containing odata or $filter, $select, $expand query parameters

5.3 Analyze API Responses

For each captured API request, evaluate:

Status Code	Category	Action
200, 201, 204	Pass	Valid successful response
304	Warning	Cached response — acceptable but note it
401	Fail	Unauthorized — missing or expired auth token
403	Fail	Forbidden — table permissions or site settings issue
404	Fail	Not found — incorrect entity set name or endpoint
500	Fail	Server error — internal Dataverse or plugin error
Other 4xx/5xx	Fail	Unexpected error

5.3b Inspect Server Logic Response Shapes

Server logic endpoints (/_api/serverlogics/<name>) commonly return a standard envelope whose data field is typically a string on success, but it is not guaranteed to be one in every response — in failure or edge cases data may be null, absent, a non-JSON string, or another non-string value. When the server logic returns serialized JSON (common), data must be parsed to reveal the actual payload — and that payload itself may be nested further. Frontend code often parses to the wrong level, reads the wrong keys, or treats data as the final object, producing silent UI failures. Test-site must surface the exact observed shape so the frontend can be corrected rather than assuming data is always directly parseable.

For each /_api/serverlogics/ request observed on any tested page:

1. Record the endpoint name from the URL (/_api/serverlogics/<endpointName>), the HTTP method, query string parameters, and HTTP status code.

2. When the request was a GET (no CSRF token required), re-execute it from the browser with browser_evaluate so the full response body is captured. Progressively parse the payload — keep parsing string-typed fields until further parsing fails — and record the shape at each level. Use a script of this form, replacing the URL with the observed one:

   async () => {
     const res = await fetch('<observed-url>', { credentials: 'include', headers: { 'Content-Type': 'application/json' } });
     const status = res.status;
     const text = await res.text();
     const levels = [];
     let current;
     try { current = JSON.parse(text); } catch { return { status, rawSample: text.slice(0, 2000) }; }
     levels.push({ type: Array.isArray(current) ? 'array' : typeof current, keys: current && typeof current === 'object' && !Array.isArray(current) ? Object.keys(current) : null, firstItemKeys: Array.isArray(current) && current[0] && typeof current[0] === 'object' ? Object.keys(current[0]) : null });
     // Progressively parse common nested-string fields (data, Body, body, payload, result)
     const nestedKeys = ['data', 'Body', 'body', 'payload', 'result'];
     while (current && typeof current === 'object') {
       const next = nestedKeys.find(k => typeof current[k] === 'string');
       if (!next) break;
       let parsed;
       try { parsed = JSON.parse(current[next]); } catch { break; }
       levels.push({ parsedFrom: next, type: Array.isArray(parsed) ? 'array' : typeof parsed, keys: parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? Object.keys(parsed) : null, firstItemKeys: Array.isArray(parsed) && parsed[0] && typeof parsed[0] === 'object' ? Object.keys(parsed[0]) : null });
       current = parsed;
     }
     return { status, levels, rawSample: text.slice(0, 2000) };
   }
   

3. For non-GET server logic requests, do not re-execute them (they may mutate data). Rely on the already-captured browser_network_requests entry and report whatever response metadata is available. Note in the report that the body was not re-captured.

4. Build a "Server Logic Response Shapes" section for the Phase 6 report. For each endpoint record: endpoint name, HTTP method, status, the chain of parse levels (what key was parsed at each step, resulting type, keys at that level, and first-item keys when the level is an array), and a raw sample (first ~2000 chars, matching the slice in the script above). If envelope.success === false and envelope.error is present, report the error verbatim.

5. Compare the observed shape to how the frontend actually consumes it (service files, hooks, components found in the repo). If there is a mismatch — e.g. the UI reads envelope.data.value as an object but the actual payload is a string that needs parsing, or expects a field name that doesn't appear in the observed keys — identify the mismatch and recommend the minimal frontend change needed to match the real shape. Be specific about the parsing or field access change required, but do not modify frontend code or create a commit in this skill; leave implementation to a separate editing/remediation skill or phase.

Record the findings and any recommended frontend fixes for the Phase 6 report.

5.4 Provide Actionable Guidance for Failures

For each failed API request, provide specific remediation:

• 401 Unauthorized: "This endpoint requires authentication. If you skipped login in Phase 3, try re-running with authentication. Otherwise, check that the auth token is being passed correctly."
• 403 Forbidden on /_api/ calls: "Check the following:\n 1. Table permissions — Ensure a table permission exists for this table with the correct scope and privileges (Read, Write, etc.) assigned to the appropriate web role.\n 2. Site settings — Verify Webapi/<tablename>/enabled is set to true. The fields value uses LogicalNames for ordinary columns, _<LogicalName>_value for lookup reads, and exact Navigation Properties for relationships written through @odata.bind. For aggregate OData, include every grouping key, aggregate input, filter column, and ordered column.\n 3. Web role assignment — Confirm the authenticated user has the correct web role assigned."
• 404 Not Found: "Verify the entity set name (should be the plural form of the table logical name). Check that the table exists in Dataverse and is published."
• 500 Internal Server Error: "Enable the Webapi/error/innererror site setting (set to true) to get detailed error messages. Redeploy and retest to see the inner error details."

5.5 Test Form Submissions (Optional)

🚦 Gate (consent · test-site:5.5.form-submit): About to submit a form on the live site — may create or modify Dataverse records. Destructive against shared state (the live Dataverse env); requires explicit opt-in.

Trigger: Forms detected via browser_snapshot in Phase 5. Why we ask: Auto-submitting test data into production records pollutes real customer data. Cancel leaves: Nothing — read-only API checks continue from earlier 5.x phases.

If forms are detected on any page (via browser_snapshot showing form elements), ask the user via AskUserQuestion before interacting:

Question	Header	Options
I found forms on the site that may trigger API calls when submitted. Should I attempt to interact with these forms to test the POST/PATCH API endpoints? Note: this may create or modify data in your Dataverse environment.	Form Testing	Yes, test form submissions — I understand this may create test data, Skip form testing (Recommended) — Only test read-only API calls

If "Yes":

1. Use browser_click to interact with form submit buttons.
2. Use browser_wait_for to wait for the form response.
3. Use browser_network_requests to capture the resulting POST/PATCH requests.
4. Analyze responses using the same criteria as 5.3.