browser-commander 0.10.0 → 0.12.0

package/tests/unit/elements/content.test.js

@@ -1,6 +1,8 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 import {
+  content,
+  innerText,
   textContent,
   inputValue,
   getAttribute,
@@ -14,6 +16,106 @@ import {
 } from '../../helpers/mocks.js';
 
 describe('content', () => {
+  describe('content', () => {
+    for (const [engine, createPage] of [
+      ['playwright', createMockPlaywrightPage],
+      ['puppeteer', createMockPuppeteerPage],
+    ]) {
+      it(`should return the full page HTML for ${engine}`, async () => {
+        const page = createPage();
+        page.content = async () =>
+          '<!doctype html><html><body>Hello</body></html>';
+
+        const html = await content({ page, engine });
+
+        assert.strictEqual(
+          html,
+          '<!doctype html><html><body>Hello</body></html>'
+        );
+      });
+    }
+
+    it('should return null on navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.content = async () => {
+        throw new Error('Execution context was destroyed');
+      };
+
+      assert.strictEqual(await content({ page, engine: 'playwright' }), null);
+    });
+  });
+
+  describe('innerText', () => {
+    it('should return rendered text for Playwright', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { main: { innerText: 'Rendered text', count: 1 } },
+      });
+
+      const text = await innerText({
+        page,
+        engine: 'playwright',
+        selector: 'main',
+      });
+
+      assert.strictEqual(text, 'Rendered text');
+    });
+
+    it('should return rendered text for Puppeteer', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { main: { innerText: 'Rendered text', count: 1 } },
+      });
+      page.evaluate = async () => 'Rendered text';
+
+      const text = await innerText({
+        page,
+        engine: 'puppeteer',
+        selector: 'main',
+      });
+
+      assert.strictEqual(text, 'Rendered text');
+    });
+
+    it('should default to the document body', async () => {
+      const page = createMockPlaywrightPage({
+        elements: { body: { innerText: 'Page text', count: 1 } },
+      });
+
+      assert.strictEqual(
+        await innerText({ page, engine: 'playwright' }),
+        'Page text'
+      );
+    });
+
+    it('should return null when the element is not found', async () => {
+      const page = createMockPuppeteerPage({
+        elements: { main: { count: 0 } },
+      });
+
+      assert.strictEqual(
+        await innerText({ page, engine: 'puppeteer', selector: 'main' }),
+        null
+      );
+    });
+
+    it('should return null on navigation errors', async () => {
+      const page = createMockPlaywrightPage();
+      page.locator = () => ({
+        count: async () => 1,
+        first() {
+          return this;
+        },
+        innerText: async () => {
+          throw new Error('Execution context was destroyed');
+        },
+      });
+
+      assert.strictEqual(
+        await innerText({ page, engine: 'playwright', selector: 'main' }),
+        null
+      );
+    });
+  });
+
   describe('textContent', () => {
     it('should throw when selector is not provided', async () => {
       const page = createMockPlaywrightPage();

package/tests/unit/scripts/ci-workflow-policy.test.js

@@ -0,0 +1,73 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { checkWorkflow } from '../../../../scripts/check-ci-workflows.mjs';
+
+function withWorkflow(content, callback) {
+  const directory = mkdtempSync(join(tmpdir(), 'browser-commander-ci-'));
+  const filePath = join(directory, 'workflow.yml');
+  writeFileSync(filePath, content);
+
+  try {
+    return callback(filePath);
+  } finally {
+    rmSync(directory, { force: true, recursive: true });
+  }
+}
+
+describe('CI workflow policy', () => {
+  it('accepts bounded job-scoped checks', () => {
+    const workflow = `name: Test
+on: push
+permissions:
+  contents: read
+env:
+  GIT_CONFIG_KEY_0: init.defaultBranch
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    concurrency:
+      group: \${{ github.workflow }}-\${{ github.ref }}-test
+      cancel-in-progress: true
+    steps:
+      - uses: actions/checkout@v6
+`;
+
+    withWorkflow(workflow, (filePath) => {
+      assert.equal(checkWorkflow(filePath), 0);
+    });
+  });
+
+  it('rejects workflow-wide cancellation and unbounded jobs', () => {
+    const workflow = `name: Test
+on: push
+concurrency:
+  group: test
+  cancel-in-progress: true
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - run: npm install
+      - run: echo "\${{ github.head_ref }}"
+      - uses: codecov/codecov-action@v6
+        with:
+          file: coverage.xml
+`;
+    const originalError = console.error;
+    console.error = () => {};
+
+    try {
+      withWorkflow(workflow, (filePath) => {
+        assert.equal(checkWorkflow(filePath), 7);
+      });
+    } finally {
+      console.error = originalError;
+    }
+  });
+});

package/tests/unit/scripts/npm-release-helpers.test.js

@@ -127,12 +127,25 @@ describe('test runner helper', () => {
       reporter: 'spec',
       targets: ['tests/unit'],
     });
-    assert.deepEqual(buildNodeTestArgs(options, ['tests/unit/a.test.js']), [
-      '--test',
-      '--experimental-test-coverage',
-      '--test-reporter',
-      'spec',
-      'tests/unit/a.test.js',
-    ]);
+    assert.deepEqual(
+      buildNodeTestArgs(options, ['tests/unit/a.test.js'], '24.18.0'),
+      [
+        '--test',
+        '--test-isolation=none',
+        '--experimental-test-coverage',
+        '--test-reporter',
+        'spec',
+        'tests/unit/a.test.js',
+      ]
+    );
+  });
+
+  it('keeps process isolation on Node versions without isolation controls', () => {
+    const options = parseTestRunnerArgs(['tests/unit']);
+
+    assert.deepEqual(
+      buildNodeTestArgs(options, ['tests/unit/a.test.js'], '20.20.2'),
+      ['--test', 'tests/unit/a.test.js']
+    );
   });
 });