@browserless.io/browserless 2.24.3 → 2.25.0

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

@@ -0,0 +1,345 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/pdf 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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            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('application/pdf');
+            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/pdf?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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf?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();
+        const metrics = new Metrics();
+        config.setConcurrent(0);
+        config.setQueued(0);
+        config.setToken('browserless');
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.status).to.equal(429);
+        });
+    });
+    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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows setting 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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            expect(res.status).to.equal(200);
+        });
+    });
+    it('allows setting PDF options', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            options: {
+                landscape: true,
+            },
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            expect(res.status).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/pdf?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            expect(res.headers.get('content-type')).to.equal('application/pdf');
+            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/pdf', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then(async (res) => {
+            await res.body?.pipeTo(new WritableStream({}));
+            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('application/pdf');
+            expect(res.status).to.equal(200);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,124 @@
+import { Browserless, Config, Metrics } from '@browserless.io/browserless';
+import { expect } from 'chai';
+describe('/edge/performance 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/performance?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/performance?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 setting config', async () => {
+        const config = new Config();
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            config: {
+                extends: 'lighthouse:default',
+                settings: {
+                    onlyAudits: ['unminified-css'],
+                },
+            },
+            url: 'https://browserless.io',
+        };
+        await fetch('http://localhost:3000/edge/performance?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('data');
+            expect(json.data.audits).to.have.all.keys('unminified-css');
+        });
+    });
+    it('times out request', async () => {
+        const config = new Config();
+        config.setTimeout(10);
+        config.setToken('browserless');
+        const metrics = new Metrics();
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/performance?token=browserless', {
+            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();
+        const metrics = new Metrics();
+        config.setConcurrent(0);
+        config.setQueued(0);
+        config.setToken('browserless');
+        await start({ config, metrics });
+        const body = {
+            url: 'https://example.com',
+        };
+        await fetch('http://localhost:3000/edge/performance?token=browserless', {
+            body: JSON.stringify(body),
+            headers: {
+                'content-type': 'application/json',
+            },
+            method: 'POST',
+        }).then((res) => {
+            expect(res.status).to.equal(429);
+        });
+    });
+    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/performance', {
+            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/scrape.spec.d.ts

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