@browserless.io/browserless 2.25.0-beta-2 → 2.25.1

package/build/routes/edge/http/screenshot.post.query.json

@@ -0,0 +1,120 @@
+{
+  "type": "object",
+  "properties": {
+    "launch": {
+      "description": "Launch options, which can be either an object\nof puppeteer.launch options or playwright.launchServer\noptions, depending on the API. Must be either JSON\nobject, or a base64-encoded JSON object.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/CDPLaunchOptions"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "blockAds": {
+      "description": "Whether or nor to load ad-blocking extensions for the session.\nThis currently uses uBlock Origin and may cause certain sites\nto not load properly.",
+      "type": "boolean"
+    },
+    "timeout": {
+      "description": "Override the system-level timeout for this request.\nAccepts a value in milliseconds.",
+      "type": "number"
+    },
+    "token": {
+      "description": "The authorization token",
+      "type": "string"
+    },
+    "trackingId": {
+      "description": "Custom session identifier",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "CDPLaunchOptions": {
+      "type": "object",
+      "properties": {
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "defaultViewport": {
+          "type": "object",
+          "properties": {
+            "deviceScaleFactor": {
+              "type": "number"
+            },
+            "hasTouch": {
+              "type": "boolean"
+            },
+            "height": {
+              "type": "number"
+            },
+            "isLandscape": {
+              "type": "boolean"
+            },
+            "isMobile": {
+              "type": "boolean"
+            },
+            "width": {
+              "type": "number"
+            }
+          },
+          "additionalProperties": false,
+          "required": [
+            "height",
+            "width"
+          ]
+        },
+        "devtools": {
+          "type": "boolean"
+        },
+        "dumpio": {
+          "type": "boolean"
+        },
+        "headless": {
+          "enum": [
+            false,
+            "shell",
+            true
+          ]
+        },
+        "ignoreDefaultArgs": {
+          "anyOf": [
+            {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "boolean"
+            }
+          ]
+        },
+        "ignoreHTTPSErrors": {
+          "type": "boolean"
+        },
+        "slowMo": {
+          "type": "number"
+        },
+        "stealth": {
+          "type": "boolean"
+        },
+        "timeout": {
+          "type": "number"
+        },
+        "userDataDir": {
+          "type": "string"
+        },
+        "waitForInitialPage": {
+          "type": "boolean"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

package/build/routes/edge/http/screenshot.post.response.json

@@ -0,0 +1,5 @@
+{
+  "description": "Response can either be a text/plain base64 encoded body\nor a binary stream with png/jpeg as a content-type",
+  "type": "string",
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

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

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

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

@@ -0,0 +1,312 @@
+/* eslint-disable no-unused-expressions */
+import { Browserless, Config, Metrics, sleep, } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/content 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', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('x-response-code')).to.not.be.undefined;
+            expect(res.headers.get('x-response-url')).to.not.be.undefined;
+            expect(res.headers.get('x-response-ip')).to.not.be.undefined;
+            expect(res.headers.get('x-response-por')).to.not.be.undefined;
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('cancels request when they are closed early', async () => {
+        const config = new Config();
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://cnn.com',
+        };
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const promise = fetch('http://localhost:3000/edge/content', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+            signal,
+        }).catch(async (error) => {
+            await sleep(100);
+            expect(error).to.have.property('name', 'AbortError');
+            expect(metrics.get().error).to.equal(1);
+            expect(metrics.get().successful).to.equal(0);
+        });
+        await sleep(1000);
+        controller.abort();
+        return promise;
+    });
+    it('404s GET requests', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        await fetch('http://localhost:3000/edge/content?token=browserless').then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/plain; charset=UTF-8');
+            expect(res.status).not.to.equal(200);
+        });
+    });
+    it('handles `waitForFunction` properties', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+            waitForFunction: {
+                fn: '() => 5 + 5',
+            },
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('handles async `waitForFunction` properties', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+            waitForFunction: {
+                fn: 'async () => new Promise(resolve => resolve(5))',
+            },
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('handles `waitForSelector` properties', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+            waitForSelector: {
+                selector: 'h1',
+            },
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('handles `waitForTimeout` properties', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+            waitForTimeout: 500,
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('handles `waitForEvent` properties', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            html: `<script type="text/javascript">
+      const event = new Event("customEvent");
+      setTimeout(() => document.dispatchEvent(event), 1500);
+      </script>`,
+            waitForEvent: {
+                event: 'customEvent',
+            },
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows cookies', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            cookies: [{ domain: 'example.com', name: 'foo', value: 'bar' }],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            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 = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content?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', async () => {
+        const config = new Config();
+        config.setConcurrent(0);
+        config.setQueued(0);
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(await res.text()).to.equal('Too many requests\n');
+            expect(res.status).to.equal(429);
+        });
+    });
+    it('allows for providing http response payloads', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        config.setTimeout(30000);
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            requestInterceptors: [
+                {
+                    pattern: '.*data.json',
+                    response: {
+                        body: '{"data": 123}',
+                        contentType: 'application/json',
+                        status: 200,
+                    },
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows goto options', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            gotoOptions: {
+                waitUntil: `networkidle2`,
+            },
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows requests without token when auth token is not set', async () => {
+        await start();
+        const body = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/content', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('x-response-code')).to.not.be.undefined;
+            expect(res.headers.get('x-response-url')).to.not.be.undefined;
+            expect(res.headers.get('x-response-ip')).to.not.be.undefined;
+            expect(res.headers.get('x-response-por')).to.not.be.undefined;
+            expect(res.headers.get('content-type')).to.equal('text/html; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,67 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/download 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', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        await fetch('http://localhost:3000/edge/download?token=browserless', {
+            body: `export default async ({ page }) => {
+        await page.evaluate(() => {
+          const txtContent = "data:text/plain;charset=utf-8,Hello world!";
+          const encodedUri = encodeURI(txtContent);
+          const link = document.createElement("a");
+          link.setAttribute("href", encodedUri);
+          link.setAttribute("download", "data.txt");
+          document.body.appendChild(link);
+
+          link.click();
+        });
+        await new Promise(r => setTimeout(r, 1000));
+      }`,
+            headers: {
+                'content-type': 'application/javascript',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(res.status).to.equal(200);
+            expect(res.headers.get('content-type')).to.equal('text/plain');
+            expect(await res.text()).to.equal('Hello world!');
+        });
+    });
+    it('allows requests without token when auth token is not set', async () => {
+        await start();
+        await fetch('http://localhost:3000/edge/download', {
+            body: `export default async ({ page }) => {
+        await page.evaluate(() => {
+          const txtContent = "data:text/plain;charset=utf-8,Hello world!";
+          const encodedUri = encodeURI(txtContent);
+          const link = document.createElement("a");
+          link.setAttribute("href", encodedUri);
+          link.setAttribute("download", "data.txt");
+          document.body.appendChild(link);
+
+          link.click();
+        });
+        await new Promise(r => setTimeout(r, 1000));
+      }`,
+            headers: {
+                'content-type': 'application/javascript',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(res.status).to.equal(200);
+            expect(res.headers.get('content-type')).to.equal('text/plain');
+            expect(await res.text()).to.equal('Hello world!');
+        });
+    });
+});

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

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