intellitester-astro 0.1.12

package/README.md

@@ -0,0 +1,64 @@
+# @autotester/astro
+
+Astro integration for AutoTester - SSR and hydration testing for Astro applications.
+
+## Installation
+
+```bash
+pnpm add @autotester/astro -D
+```
+
+## Usage
+
+Add the integration to your `astro.config.mjs`:
+
+```javascript
+import { defineConfig } from 'astro/config';
+import autotester from '@autotester/astro';
+
+export default defineConfig({
+  integrations: [
+    autotester({
+      testsDir: './tests',
+      runOnBuild: true,
+      testSSR: true,
+      testHydration: true,
+      testIslands: true,
+    })
+  ]
+});
+```
+
+## Options
+
+- `testsDir` - Directory containing test files (default: `./tests`)
+- `runOnBuild` - Run tests during build (default: `false`)
+- `testSSR` - Validate SSR output (default: `false`)
+- `testHydration` - Test hydration directives (default: `false`)
+- `testIslands` - Test island isolation (default: `false`)
+
+## Features
+
+### SSR Testing
+
+Validates that components render correctly on the server side.
+
+### Hydration Testing
+
+Tests Astro's hydration directives:
+- `client:load`
+- `client:visible`
+- `client:idle`
+- `client:only`
+
+### Island Isolation
+
+Verifies that Astro islands are properly isolated and hydrate independently.
+
+## Test Runner
+
+The integration adds a `/__autotester` route to your dev server to view test results.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "intellitester-astro",
+  "version": "0.1.12",
+  "description": "Astro integration for IntelliTester - AI-powered automated testing",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://forge.blackleafdigital.com/zachhandley/Intellitester.git",
+    "directory": "packages/astro-integration"
+  },
+  "homepage": "https://github.com/ZachHandley/Intellitester",
+  "bugs": {
+    "url": "https://github.com/ZachHandley/Intellitester/issues"
+  },
+  "author": "Zach Handley <zachhandley@gmail.com> (https://zachhandley.com)",
+  "license": "MIT",
+  "keywords": [
+    "astro-integration",
+    "astro",
+    "testing",
+    "intellitester",
+    "e2e"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "astro": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "vite-plugin-intellitester": "0.1.12"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "astro": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/hydration.ts

@@ -0,0 +1,50 @@
+export interface HydrationTest {
+  directive: 'client:load' | 'client:visible' | 'client:idle' | 'client:only';
+  selector: string;
+  expectedBehavior: string;
+}
+
+export interface HydrationTestResult {
+  passed: boolean;
+  results: Array<{
+    test: HydrationTest;
+    success: boolean;
+    error?: string;
+  }>;
+}
+
+export async function testHydrationDirectives(
+  buildDir: URL,
+  tests: HydrationTest[]
+): Promise<HydrationTestResult> {
+  const results: HydrationTestResult['results'] = [];
+
+  for (const test of tests) {
+    try {
+      // TODO: Implement actual hydration testing logic
+      // This would involve:
+      // 1. Loading the built output
+      // 2. Checking for proper hydration scripts
+      // 3. Validating that components hydrate with the correct directive
+      // 4. Testing that client-side JavaScript loads as expected
+
+      console.log(`Testing hydration directive ${test.directive} for selector: ${test.selector}`);
+
+      results.push({
+        test,
+        success: true
+      });
+    } catch (error) {
+      results.push({
+        test,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+
+  return {
+    passed: results.every(r => r.success),
+    results
+  };
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import { createIntegration } from './integration';
+
+export default createIntegration;
+export type { AstroIntellitesterOptions } from './types';
+export type { HydrationTest, HydrationTestResult } from './hydration';
+export type { SSRValidationResult } from './ssr-testing';

package/src/integration.ts

@@ -0,0 +1,52 @@
+import type { AstroIntegration } from 'astro';
+import { intellitester as vitePlugin } from 'vite-plugin-intellitester';
+import type { AstroIntellitesterOptions } from './types';
+import { validateSSROutput } from './ssr-testing';
+import { testHydrationDirectives } from './hydration';
+
+export function createIntegration(options: AstroIntellitesterOptions = {}): AstroIntegration {
+  return {
+    name: '@intellitester/astro',
+    hooks: {
+      'astro:config:setup': ({ updateConfig, injectRoute, logger }) => {
+        logger.info('Setting up IntelliTester integration');
+
+        // Add Vite plugin
+        updateConfig({
+          vite: {
+            plugins: [vitePlugin({
+              testsDir: options.testsDir,
+              runOnBuild: options.runOnBuild,
+            })]
+          }
+        });
+
+        // Inject test runner route
+        injectRoute({
+          pattern: '/__intellitester',
+          entrypoint: '@intellitester/astro/pages/test-runner.astro'
+        });
+      },
+
+      'astro:server:setup': ({ server, logger }) => {
+        logger.info('IntelliTester dev server ready');
+        // Could add custom middleware here
+      },
+
+      'astro:build:done': async ({ dir, routes, logger }) => {
+        if (options.testSSR) {
+          logger.info('Running SSR tests...');
+          const result = await validateSSROutput(dir, routes);
+          if (!result.passed) {
+            logger.error('SSR tests failed: ' + result.errors.join(', '));
+          }
+        }
+
+        if (options.testHydration) {
+          logger.info('Running hydration tests...');
+          // Run hydration tests
+        }
+      }
+    }
+  };
+}

package/src/pages/test-runner.astro

@@ -0,0 +1,28 @@
+---
+// Test runner page injected by the integration
+const testResults = await Astro.locals.intellitesterResults || [];
+---
+<html>
+<head>
+  <title>IntelliTester Results</title>
+  <style>
+    body { font-family: system-ui; padding: 2rem; }
+    .pass { color: green; }
+    .fail { color: red; }
+  </style>
+</head>
+<body>
+  <h1>IntelliTester Results</h1>
+  <div id="results">
+    {testResults.length === 0 ? (
+      <p>No tests run yet. Run <code>intellitester run</code> to execute tests.</p>
+    ) : (
+      testResults.map(r => (
+        <div class={r.status}>
+          {r.status === 'passed' ? '✓' : '✗'} {r.name}
+        </div>
+      ))
+    )}
+  </div>
+</body>
+</html>

package/src/ssr-testing.ts

@@ -0,0 +1,38 @@
+export interface SSRValidationResult {
+  passed: boolean;
+  errors: string[];
+}
+
+export async function validateSSROutput(
+  buildDir: URL,
+  routes: { pathname: string }[]
+): Promise<SSRValidationResult> {
+  // Check that components render correctly in SSR
+  const errors: string[] = [];
+
+  try {
+    // Iterate through routes and validate SSR output
+    for (const route of routes) {
+      // TODO: Implement actual SSR validation logic
+      // This would involve:
+      // 1. Loading the built SSR output
+      // 2. Checking for proper HTML structure
+      // 3. Validating that required elements are present
+      // 4. Ensuring no hydration errors in the output
+
+      // Placeholder validation
+      console.log(`Validating SSR output for route: ${route.pathname}`);
+    }
+
+    return {
+      passed: errors.length === 0,
+      errors
+    };
+  } catch (error) {
+    errors.push(`SSR validation failed: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      passed: false,
+      errors
+    };
+  }
+}

package/src/types.ts

@@ -0,0 +1,10 @@
+export interface AstroIntellitesterOptions {
+  // Inherited from Vite plugin
+  testsDir?: string;
+  runOnBuild?: boolean;
+
+  // Astro-specific
+  testSSR?: boolean;           // Validate SSR output
+  testHydration?: boolean;     // Test hydration directives
+  testIslands?: boolean;       // Test island isolation
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src"]
+}