@browserless.io/browserless 2.24.3 → 2.25.0

package/build/routes/edge/tests/function.spec.js

@@ -0,0 +1,277 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/function API', function () {
+    let browserless;
+    const start = ({ config = new Config(), metrics = new 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/build/routes/edge/tests/json-version.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/routes/edge/tests/json-version.spec.js

@@ -0,0 +1,37 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/json/version API', function () {
+    let browserless;
+    const start = ({ config = new Config(), metrics = new 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/build/routes/edge/tests/kill-sessions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/routes/edge/tests/kill-sessions.spec.js

@@ -0,0 +1,80 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+import puppeteer from 'puppeteer-core';
+describe('/kill API', function () {
+    let browserless;
+    const start = ({ config = new Config(), metrics = new 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.message).contains('closed');
+        expect(errorThrown2.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.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.message).contains('closed');
+    });
+});

package/build/routes/edge/tests/page-websocket.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/routes/edge/tests/page-websocket.spec.js

@@ -0,0 +1,97 @@
+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;
+    const start = ({ config = new Config(), metrics = new 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) {
+            //@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) {
+            //@ts-ignore
+            expect(err.message).to.include('404');
+        }
+        finally {
+            browser.close();
+        }
+    });
+});

package/build/routes/edge/tests/pdf.spec.d.ts

@@ -0,0 +1 @@
+export {};