@browserless.io/browserless 2.24.3 → 2.25.0

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

@@ -0,0 +1,354 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/scrape 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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+    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/scrape?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 debug options', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            debugOpts: {
+                network: true,
+            },
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; charset=UTF-8');
+            expect(res.status).to.equal(200);
+            const json = await res.json();
+            expect(json).to.have.property('debug');
+            expect(json.debug).to.have.property('network');
+        });
+    });
+    it('handles selector timeouts', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            elements: [
+                {
+                    selector: 'blink',
+                    timeout: 1000,
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            expect(await res.text()).to.contain('Timed out waiting for selector');
+            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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+            waitForFunction: {
+                fn: '() => 5 + 5',
+            },
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; 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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+            waitForFunction: {
+                fn: 'async () => new Promise(resolve => resolve(5))',
+            },
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; 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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+            waitForSelector: {
+                selector: 'h1',
+            },
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; 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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+            waitForTimeout: 500,
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; 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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            html: `<script type="text/javascript">
+      const event = new Event("customEvent");
+      setTimeout(() => document.dispatchEvent(event), 1500);
+      </script><a href="/">Link</a>`,
+            waitForEvent: {
+                event: 'customEvent',
+            },
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.status).to.equal(200);
+            expect(res.headers.get('content-type')).to.equal('application/json; charset=UTF-8');
+        });
+    });
+    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' }],
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; 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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?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 = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.status).to.equal(429);
+        });
+    });
+    it('allows goto options', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows requests without token when auth token is not set', async () => {
+        await start();
+        const body = {
+            elements: [
+                {
+                    selector: 'a',
+                },
+            ],
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/scrape', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('application/json; charset=UTF-8');
+            expect(res.status).to.equal(200);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,339 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/screenshot 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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            expect(res.status).to.equal(200);
+        });
+    });
+    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/screenshot?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('allows custom viewports', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+            viewport: {
+                deviceScaleFactor: 3,
+                height: 100,
+                width: 100,
+            },
+        };
+        await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows to specify selector', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            selector: 'h1',
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows setting HTML body', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            html: '<h1>Hello!</h1>',
+        };
+        await fetch('http://localhost:3000/edge/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows for providing http response payloads', async () => {
+        const config = new Config();
+        const metrics = new Metrics();
+        config.setConcurrent(10);
+        config.setQueued(10);
+        config.setTimeout(30000);
+        config.setToken('browserless');
+        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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            expect(res.status).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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            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/screenshot?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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.status).to.equal(429);
+        });
+    });
+    it('allows goto options', 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/screenshot?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((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/screenshot', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.headers.get('content-type')).to.equal('image/png');
+            expect(res.status).to.equal(200);
+        });
+    });
+});

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

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