@browserless.io/browserless 2.24.3 → 2.25.0

package/src/routes/edge/tests/function.spec.ts

@@ -0,0 +1,317 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+
+describe('/edge/function API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('runs functions', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('ok');
+      expect(res.status).to.equal(200);
+    });
+  });
+
+  it('runs functions with "context"', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `export default async function ({ page, context }) {
+        if (!!context.ok) {
+          return Promise.resolve({
+            data: "ok",
+            type: "application/text",
+          });
+        }
+        return Promise.reject(new Error('Bad context!'));
+      }`,
+      context: {
+        ok: true,
+      },
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('ok');
+      expect(res.status).to.equal(200);
+    });
+  });
+
+  it('runs "application/javascript" functions', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = `export default async function ({ page }) {
+      return Promise.resolve({
+        data: "ok",
+        type: "application/text",
+      });
+    }`;
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body,
+      headers: { 'Content-Type': 'application/javascript' },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('ok');
+      expect(json.type).to.equal('application/text');
+      expect(res.status).to.equal(200);
+    });
+  });
+
+  it('runs functions that import libraries', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `
+      import 'https://code.jquery.com/jquery-3.6.0.min.js';
+      export default async function ({ page }) {
+        return Promise.resolve({
+          data: typeof window.jQuery,
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('function');
+      expect(res.status).to.equal(200);
+    });
+  });
+
+  it('runs functions with custom return types', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `
+      export default async function ({ page }) {
+        return Promise.resolve({
+          data: {
+            status: 'ok',
+          },
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+
+      expect(res.headers.get('content-type')).to.equal(
+        `application/json; charset=UTF-8`,
+      );
+      expect(json).to.have.property('data');
+      expect(res.status).to.equal(200);
+    });
+  });
+
+  it('times out requests', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch(
+      'http://localhost:3000/edge/function?token=browserless&timeout=10',
+      {
+        body: JSON.stringify(body),
+        headers: {
+          'content-type': 'application/json',
+        },
+        method: 'POST',
+      },
+    ).then((res) => {
+      expect(res.status).to.equal(408);
+    });
+  });
+
+  it('rejects requests with bad content-types', async () => {
+    const config = new Config();
+    config.setConcurrent(0);
+    config.setQueued(0);
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'joelson',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      return expect(res.status).to.equal(404);
+    });
+  });
+
+  it('rejects requests with 429', async () => {
+    const config = new Config();
+    config.setConcurrent(0);
+    config.setQueued(0);
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=browserless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      return expect(res.status).to.equal(429);
+    });
+  });
+
+  it('rejects requests that are unauthorized', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function?token=bless', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      return expect(res.status).to.equal(401);
+    });
+  });
+
+  it('allows requests without token when auth token is not set', async () => {
+    const config = new Config();
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const body = {
+      code: `export default async function ({ page }) {
+        return Promise.resolve({
+          data: "ok",
+          type: "application/text",
+        });
+      }`,
+      context: {},
+    };
+
+    await fetch('http://localhost:3000/edge/function', {
+      body: JSON.stringify(body),
+      headers: {
+        'content-type': 'application/json',
+      },
+      method: 'POST',
+    }).then(async (res) => {
+      const json = await res.json();
+
+      expect(json).to.have.property('data');
+      expect(json.data).to.equal('ok');
+      expect(res.status).to.equal(200);
+    });
+  });
+});

package/src/routes/edge/tests/json-version.spec.ts

@@ -0,0 +1,52 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+
+describe('/json/version API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('allows requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=browserless',
+    );
+    const resJSON = await res.json();
+
+    [
+      'Browser',
+      'Protocol-Version',
+      'User-Agent',
+      'V8-Version',
+      'WebKit-Version',
+      'webSocketDebuggerUrl',
+      'Debugger-Version',
+    ].forEach((k) => expect(resJSON).to.haveOwnProperty(k));
+  });
+
+  it('rejects unauthorized requests to /json/version', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const res = await fetch(
+      'http://localhost:3000/json/version?token=imabadboi',
+    );
+    expect(res.status).to.equal(401);
+  });
+});

package/src/routes/edge/tests/kill-sessions.spec.ts

@@ -0,0 +1,99 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+import puppeteer from 'puppeteer-core';
+
+describe('/kill API', function () {
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    config.setToken('6R0W53R135510');
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('Kill all sessions', async () => {
+    await start();
+    const browser1 = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge?token=6R0W53R135510`,
+    });
+    const browser2 = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge?token=6R0W53R135510`,
+    });
+
+    await fetch('http://localhost:3000/kill/all?token=6R0W53R135510').then(
+      async (res) => {
+        expect(res.status).to.equal(204);
+      },
+    );
+
+    let errorThrown1;
+    try {
+      await browser1.newPage();
+    } catch (e) {
+      errorThrown1 = e;
+    }
+    let errorThrown2;
+    try {
+      await browser2.newPage();
+    } catch (e) {
+      errorThrown2 = e;
+    }
+    expect((errorThrown1 as Error).message).contains('closed');
+    expect((errorThrown2 as Error).message).contains('closed');
+  });
+
+  it('Kill session by browserId', async () => {
+    await start();
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge?token=6R0W53R135510`,
+    });
+
+    await fetch('http://localhost:3000/sessions?token=6R0W53R135510').then(
+      async (res) => {
+        const sessions = await res.json();
+        const browserId = sessions[0].browserId;
+        await fetch(
+          `http://localhost:3000/kill/${browserId}?token=6R0W53R135510`,
+        ).then(async (res) => {
+          expect(res.status).to.equal(204);
+        });
+      },
+    );
+
+    let errorThrown;
+    try {
+      await browser.newPage();
+    } catch (e) {
+      errorThrown = e;
+    }
+    expect((errorThrown as Error).message).contains('closed');
+  });
+
+  it('Kill session by trackingId', async () => {
+    await start();
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge?token=6R0W53R135510&trackingId=session-1`,
+    });
+
+    await fetch(
+      'http://localhost:3000/kill/session-1?token=6R0W53R135510',
+    ).then(async (res) => {
+      expect(res.status).to.equal(204);
+    });
+
+    let errorThrown;
+    try {
+      await browser.newPage();
+    } catch (e) {
+      errorThrown = e;
+    }
+    expect((errorThrown as Error).message).contains('closed');
+  });
+});

package/src/routes/edge/tests/page-websocket.spec.ts

@@ -0,0 +1,129 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import puppeteer, { Connection } from 'puppeteer-core';
+import { NodeWebSocketTransport } from 'puppeteer-core/lib/esm/puppeteer/node/NodeWebSocketTransport.js';
+import { expect } from 'chai';
+
+describe('WebSocket Page API', function () {
+  // Server shutdown can take a few seconds
+  // and so can these tests :/
+  this.timeout(5000);
+
+  let browserless: Browserless;
+
+  const start = ({
+    config = new Config(),
+    metrics = new Metrics(),
+  }: { config?: Config; metrics?: Metrics } = {}) => {
+    browserless = new Browserless({ config, metrics });
+    return browserless.start();
+  };
+
+  afterEach(async () => {
+    await browserless.stop();
+  });
+
+  it('forwards requests to running pages', async () => {
+    const config = new Config();
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge`,
+    });
+    const page = await browser.newPage();
+    await page.goto('https://example.com/');
+    // @ts-ignore
+    const pageId = page.target()._targetId;
+    const webSocketDebuggerUrl = `ws://localhost:3000/devtools/page/${pageId}`;
+
+    // Connect to raw page target
+    const cdp = new Connection(
+      webSocketDebuggerUrl,
+      await NodeWebSocketTransport.create(webSocketDebuggerUrl),
+    );
+
+    // Send a command
+    const result = await cdp.send('Page.enable');
+    await browser.close();
+    expect(result);
+  });
+
+  it('creates pages when interacting with /json/new', async () => {
+    const config = new Config();
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const { webSocketDebuggerUrl } = await fetch(
+      'http://localhost:3000/json/new',
+      {
+        method: 'PUT',
+      },
+    ).then((r) => r.json());
+
+    // Connect to raw page target
+    const cdp = new Connection(
+      webSocketDebuggerUrl,
+      await NodeWebSocketTransport.create(webSocketDebuggerUrl),
+    );
+
+    // Send a command
+    const result = await cdp.send('Page.enable');
+    cdp.dispose();
+    expect(result);
+  });
+
+  it('rejects unauthorized page requests', async () => {
+    const config = new Config();
+    config.setToken('browserless');
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+    });
+    const page = await browser.newPage();
+    await page.goto('https://example.com/');
+    // @ts-ignore
+    const pageId = page.target()._targetId;
+    const webSocketDebuggerUrl = `ws://localhost:3000/devtools/page/${pageId}`;
+
+    // Connect to raw page target without authorization
+    try {
+      new Connection(
+        webSocketDebuggerUrl,
+        await NodeWebSocketTransport.create(webSocketDebuggerUrl),
+      );
+    } catch (err: unknown) {
+      //@ts-ignore
+      expect(err.message).to.include('401');
+    } finally {
+      browser.close();
+    }
+  });
+
+  it('404s pages not found', async () => {
+    const config = new Config();
+    const metrics = new Metrics();
+    await start({ config, metrics });
+
+    const browser = await puppeteer.connect({
+      browserWSEndpoint: `ws://localhost:3000/edge?token=browserless`,
+    });
+    const page = await browser.newPage();
+    await page.goto('https://example.com/');
+    const webSocketDebuggerUrl = `ws://localhost:3000/devtools/page/im-a-banana`;
+
+    // Connect to raw page target without authorization
+    try {
+      new Connection(
+        webSocketDebuggerUrl,
+        await NodeWebSocketTransport.create(webSocketDebuggerUrl),
+      );
+    } catch (err: unknown) {
+      //@ts-ignore
+      expect(err.message).to.include('404');
+    } finally {
+      browser.close();
+    }
+  });
+});