testlint_sdk/

browser_coverage.rs

use std::fs;
use std::path::PathBuf;
use std::process::Command;

#[derive(Debug, Clone)]
pub enum BrowserTool {
    Playwright,
    Puppeteer,
}

pub struct BrowserCoverageHelper {
    tool: BrowserTool,
    output_dir: PathBuf,
}

impl BrowserCoverageHelper {
    pub fn new(tool: BrowserTool, output_dir: PathBuf) -> Self {
        BrowserCoverageHelper { tool, output_dir }
    }

    /// Generate a coverage wrapper script for the browser testing tool
    pub fn generate_wrapper_script(&self, test_command: &str) -> Result<String, String> {
        fs::create_dir_all(&self.output_dir)
            .map_err(|e| format!("Failed to create output directory: {}", e))?;

        match self.tool {
            BrowserTool::Playwright => self.generate_playwright_script(test_command),
            BrowserTool::Puppeteer => self.generate_puppeteer_script(test_command),
        }
    }

    /// Generate Playwright coverage wrapper
    fn generate_playwright_script(&self, _test_command: &str) -> Result<String, String> {
        let script_path = self.output_dir.join("playwright-coverage-wrapper.js");

        let script_content = format!(
            r#"/**
 * Playwright Coverage Wrapper
 * Auto-generated by Testlint SDK
 *
 * This script wraps Playwright tests to collect JavaScript coverage
 * from browser execution.
 */

const {{ test, chromium, firefox, webkit }} = require('@playwright/test');
const fs = require('fs');
const path = require('path');

// Coverage output directory
const coverageDir = '{}';

// Ensure coverage directory exists
if (!fs.existsSync(coverageDir)) {{
  fs.mkdirSync(coverageDir, {{ recursive: true }});
}}

// Store all coverage data
let allCoverage = [];

// Hook into Playwright's test lifecycle
test.beforeEach(async ({{ page }}) => {{
  // Start JavaScript coverage before each test
  await page.coverage.startJSCoverage({{
    resetOnNavigation: false,
    reportAnonymousScripts: true
  }});

  // Optionally start CSS coverage
  await page.coverage.startCSSCoverage({{
    resetOnNavigation: false
  }});
}});

test.afterEach(async ({{ page }}) => {{
  // Collect coverage after each test
  const [jsCoverage, cssCoverage] = await Promise.all([
    page.coverage.stopJSCoverage(),
    page.coverage.stopCSSCoverage()
  ]);

  // Store coverage data
  allCoverage.push(...jsCoverage);

  console.log(`Collected coverage for ${{jsCoverage.length}} JS files`);
}});

// Save coverage on process exit
process.on('exit', () => {{
  saveCoverage();
}});

process.on('SIGINT', () => {{
  saveCoverage();
  process.exit(0);
}});

function saveCoverage() {{
  if (allCoverage.length === 0) {{
    console.log('No coverage data collected');
    return;
  }}

  // Convert to Istanbul/NYC format
  const istanbulCoverage = convertToIstanbul(allCoverage);

  // Save as JSON
  const outputFile = path.join(coverageDir, 'coverage-playwright.json');
  fs.writeFileSync(outputFile, JSON.stringify(istanbulCoverage, null, 2));

  console.log(`✓ Coverage saved to ${{outputFile}}`);
  console.log(`  Total files: ${{Object.keys(istanbulCoverage).length}}`);

  // Also save raw V8 format
  const rawFile = path.join(coverageDir, 'coverage-raw-v8.json');
  fs.writeFileSync(rawFile, JSON.stringify(allCoverage, null, 2));
}}

function convertToIstanbul(v8Coverage) {{
  // Convert V8 coverage format to Istanbul format
  // This is a simplified conversion - for production use v8-to-istanbul package

  const istanbul = {{}};

  for (const entry of v8Coverage) {{
    const url = entry.url;

    // Skip non-file URLs
    if (!url.startsWith('http://') && !url.startsWith('https://') && !url.startsWith('file://')) {{
      continue;
    }}

    // Create Istanbul format structure
    istanbul[url] = {{
      path: url,
      statementMap: {{}},
      fnMap: {{}},
      branchMap: {{}},
      s: {{}},
      f: {{}},
      b: {{}},
      _coverageSchema: '1a1c01bbd47fc00a2c39e90264f33305004495a9',
      hash: 'placeholder'
    }};

    // Process ranges
    let statementId = 0;
    for (const func of entry.functions || []) {{
      for (const range of func.ranges || []) {{
        statementId++;
        istanbul[url].statementMap[statementId] = {{
          start: {{ line: 0, column: range.startOffset }},
          end: {{ line: 0, column: range.endOffset }}
        }};
        istanbul[url].s[statementId] = range.count;
      }}
    }}
  }}

  return istanbul;
}}

// Export for use in tests
module.exports = {{ saveCoverage, convertToIstanbul }};
"#,
            self.output_dir.display()
        );

        fs::write(&script_path, script_content)
            .map_err(|e| format!("Failed to write Playwright wrapper: {}", e))?;

        Ok(script_path.to_string_lossy().to_string())
    }

    /// Generate Puppeteer coverage wrapper
    fn generate_puppeteer_script(&self, _test_command: &str) -> Result<String, String> {
        let script_path = self.output_dir.join("puppeteer-coverage-wrapper.js");

        let script_content = format!(
            r#"/**
 * Puppeteer Coverage Wrapper
 * Auto-generated by Testlint SDK
 *
 * This script wraps Puppeteer tests to collect JavaScript coverage
 * from browser execution.
 */

const puppeteer = require('puppeteer');
const fs = require('fs');
const path = require('path');

// Coverage output directory
const coverageDir = '{}';

// Ensure coverage directory exists
if (!fs.existsSync(coverageDir)) {{
  fs.mkdirSync(coverageDir, {{ recursive: true }});
}}

class CoverageCollector {{
  constructor() {{
    this.allCoverage = [];
    this.browser = null;
    this.page = null;
  }}

  async launch(options = {{}}) {{
    this.browser = await puppeteer.launch({{
      headless: options.headless !== false,
      ...options
    }});

    this.page = await this.browser.newPage();

    // Start coverage
    await this.page.coverage.startJSCoverage({{
      resetOnNavigation: false,
      reportAnonymousScripts: true
    }});

    await this.page.coverage.startCSSCoverage({{
      resetOnNavigation: false
    }});

    return {{ browser: this.browser, page: this.page }};
  }}

  async collect() {{
    if (!this.page) {{
      throw new Error('No page initialized. Call launch() first.');
    }}

    const [jsCoverage, cssCoverage] = await Promise.all([
      this.page.coverage.stopJSCoverage(),
      this.page.coverage.stopCSSCoverage()
    ]);

    this.allCoverage.push(...jsCoverage);

    console.log(`Collected coverage for ${{jsCoverage.length}} JS files`);

    return {{ js: jsCoverage, css: cssCoverage }};
  }}

  async save() {{
    if (this.allCoverage.length === 0) {{
      console.log('No coverage data collected');
      return;
    }}

    // Convert to Istanbul format
    const istanbulCoverage = this.convertToIstanbul(this.allCoverage);

    // Save as JSON
    const outputFile = path.join(coverageDir, 'coverage-puppeteer.json');
    fs.writeFileSync(outputFile, JSON.stringify(istanbulCoverage, null, 2));

    console.log(`✓ Coverage saved to ${{outputFile}}`);
    console.log(`  Total files: ${{Object.keys(istanbulCoverage).length}}`);

    // Also save raw V8 format
    const rawFile = path.join(coverageDir, 'coverage-raw-v8.json');
    fs.writeFileSync(rawFile, JSON.stringify(this.allCoverage, null, 2));

    return outputFile;
  }}

  async close() {{
    if (this.browser) {{
      await this.browser.close();
    }}
  }}

  convertToIstanbul(v8Coverage) {{
    // Convert V8 coverage format to Istanbul format
    const istanbul = {{}};

    for (const entry of v8Coverage) {{
      const url = entry.url;

      // Skip non-file URLs
      if (!url.startsWith('http://') && !url.startsWith('https://') && !url.startsWith('file://')) {{
        continue;
      }}

      // Create Istanbul format structure
      istanbul[url] = {{
        path: url,
        statementMap: {{}},
        fnMap: {{}},
        branchMap: {{}},
        s: {{}},
        f: {{}},
        b: {{}},
        _coverageSchema: '1a1c01bbd47fc00a2c39e90264f33305004495a9',
        hash: 'placeholder'
      }};

      // Process ranges
      let statementId = 0;
      for (const func of entry.functions || []) {{
        for (const range of func.ranges || []) {{
          statementId++;
          istanbul[url].statementMap[statementId] = {{
            start: {{ line: 0, column: range.startOffset }},
            end: {{ line: 0, column: range.endOffset }}
          }};
          istanbul[url].s[statementId] = range.count;
        }}
      }}
    }}

    return istanbul;
  }}
}}

// Create global instance
global.coverageCollector = new CoverageCollector();

// Auto-save on exit
process.on('exit', () => {{
  if (global.coverageCollector.allCoverage.length > 0) {{
    global.coverageCollector.save();
  }}
}});

process.on('SIGINT', async () => {{
  await global.coverageCollector.save();
  await global.coverageCollector.close();
  process.exit(0);
}});

module.exports = CoverageCollector;

// Example usage:
// const CoverageCollector = require('./puppeteer-coverage-wrapper');
// const collector = new CoverageCollector();
// const {{ browser, page }} = await collector.launch();
// await page.goto('https://example.com');
// // ... run tests ...
// await collector.collect();
// await collector.save();
// await collector.close();
"#,
            self.output_dir.display()
        );

        fs::write(&script_path, script_content)
            .map_err(|e| format!("Failed to write Puppeteer wrapper: {}", e))?;

        Ok(script_path.to_string_lossy().to_string())
    }

    /// Install v8-to-istanbul for better coverage conversion
    pub fn ensure_dependencies(&self) -> Result<(), String> {
        println!("📦 Checking browser coverage dependencies...");

        // Check if v8-to-istanbul is installed
        let check = Command::new("npm")
            .args(["list", "v8-to-istanbul"])
            .output();

        if check.is_err() || !check.unwrap().status.success() {
            println!("📥 Installing v8-to-istanbul for coverage conversion...");

            let output = Command::new("npm")
                .args(["install", "--save-dev", "v8-to-istanbul"])
                .output()
                .map_err(|e| format!("Failed to install v8-to-istanbul: {}", e))?;

            if !output.status.success() {
                return Err(format!(
                    "npm install failed: {}",
                    String::from_utf8_lossy(&output.stderr)
                ));
            }

            println!("✓ v8-to-istanbul installed");
        }

        Ok(())
    }

    /// Generate example test file
    pub fn generate_example_test(&self) -> Result<String, String> {
        let example_path = match self.tool {
            BrowserTool::Playwright => self.output_dir.join("example.playwright.spec.js"),
            BrowserTool::Puppeteer => self.output_dir.join("example.puppeteer.test.js"),
        };

        let example_content = match self.tool {
            BrowserTool::Playwright => {
                r#"// Example Playwright test with coverage
const { test, expect } = require('@playwright/test');

test.describe('Example Test Suite', () => {
  test('should collect coverage', async ({ page }) => {
    await page.goto('https://example.com');

    const title = await page.title();
    expect(title).toBeTruthy();

    // Your test code here
    // Coverage is automatically collected via the wrapper
  });

  test('another test with coverage', async ({ page }) => {
    await page.goto('https://example.com');

    await page.click('a');
    // More interactions...
  });
});
"#
            }
            BrowserTool::Puppeteer => {
                r#"// Example Puppeteer test with coverage
const CoverageCollector = require('./puppeteer-coverage-wrapper');

describe('Example Test Suite', () => {
  let collector;
  let browser;
  let page;

  beforeAll(async () => {
    collector = new CoverageCollector();
    const launched = await collector.launch({ headless: true });
    browser = launched.browser;
    page = launched.page;
  });

  afterAll(async () => {
    await collector.collect();
    await collector.save();
    await collector.close();
  });

  test('should collect coverage', async () => {
    await page.goto('https://example.com');

    const title = await page.title();
    expect(title).toBeTruthy();

    // Your test code here
  });

  test('another test with coverage', async () => {
    await page.goto('https://example.com');

    await page.click('a');
    // More interactions...
  });
});
"#
            }
        };

        fs::write(&example_path, example_content)
            .map_err(|e| format!("Failed to write example test: {}", e))?;

        Ok(example_path.to_string_lossy().to_string())
    }
}