How to use fetchBinary method in Puppeteer

The timeout you specify here needs to be shorter than the default timeout.

The default timeout is 5000 and the framework by default is jasmine in case of jest. You can specify the timeout inside the test by adding

jest.setTimeout(30000);

But this would be specific to the test. Or you can set up the configuration file for the framework.

Configuring Jest

// jest.config.js
module.exports = {
  // setupTestFrameworkScriptFile has been deprecated in
  // favor of setupFilesAfterEnv in jest 24
  setupFilesAfterEnv: ['./jest.setup.js']
}

// jest.setup.js
jest.setTimeout(30000)

See also these threads:

setTimeout per test #5055

Make jasmine.DEFAULT_TIMEOUT_INTERVAL configurable #652

P.S.: The misspelling setupFilesAfterEnv (i.e. setupFileAfterEnv) will also throw the same error.

You can use page.waitForNavigation() to wait for the new page to load completely before generating a PDF:

await page.goto(fullUrl, {
  waitUntil: 'networkidle0',
});

await page.type('#username', 'scott');
await page.type('#password', 'tiger');

await page.click('#Login_Button');

await page.waitForNavigation({
  waitUntil: 'networkidle0',
});

await page.pdf({
  path: outputFileName,
  displayHeaderFooter: true,
  headerTemplate: '',
  footerTemplate: '',
  printBackground: true,
  format: 'A4',
});

If there is a certain element that is generated dynamically that you would like included in your PDF, consider using page.waitForSelector() to ensure that the content is visible:

await page.waitForSelector('#example', {
  visible: true,
});

Give this a shot:

const puppeteer = require('puppeteer');

(async () => {
    const browser = await puppeteer.launch({
        headless: false
    });
    const page = await browser.newPage();
    await page.goto('https://www.yoursite.com');
    await page.setViewport({
        width: 1200,
        height: 800
    });

    await autoScroll(page);

    await page.screenshot({
        path: 'yoursite.png',
        fullPage: true
    });

    await browser.close();
})();

async function autoScroll(page){
    await page.evaluate(async () => {
        await new Promise((resolve) => {
            var totalHeight = 0;
            var distance = 100;
            var timer = setInterval(() => {
                var scrollHeight = document.body.scrollHeight;
                window.scrollBy(0, distance);
                totalHeight += distance;

                if(totalHeight >= scrollHeight - window.innerHeight){
                    clearInterval(timer);
                    resolve();
                }
            }, 100);
        });
    });
}

Source: https://github.com/chenxiaochun/blog/issues/38

EDIT

added window.innerHeight to the calculation because the available scrolling distance is body height minus viewport height, not the entire body height.

In your example code you're using page.$eval, not page.$$eval. Since the former uses document.querySelector instead of document.querySelectorAll, the behaviour you describe is the expected one.

Also, you should change your pageFunctionin the $$eval arguments:

const hrefs = await page.$$eval('a', as => as.map(a => a.href));

I was able to get the solution using:

const data = await page.evaluate(() => {
        const tds = Array.from(document.querySelectorAll('.GridHeader td'))
        return tds.map(td => td.textContent)
    });

console.log(data) // ['xyz', '0500', '0550','0600', '0650']

You have to await getPageContent:

var htmlList = [];
var ws = "https://www.google.com/";
var googleHtml = await getPageContent(ws);

Use sinon

While testing b, you should test for its behavior on different responses from a (happy and fail flows). So you need to stub a with different returns to test b correctly.

import * as allMethods from './whereever-the-file-is';
import sinon from 'sinon';

// inside your test case
const aStub = sinon.stub(allMethods, 'a');

aStub.returns('x');
// test your function b on what it should do when a returns 'x'

aStub.returns('y');
// test your function b on what it should do when a returns 'y'

I haven't tested this code, so pl refer to official docs if you need to know more about sinon stubs.

You are correct in your assumption, but make sure that the printBackground option in page.pdf() is set to true before attempting to print.

Otherwise, the background colors and graphics will not be printed.

await page.emulateMedia('screen');

await page.pdf({
  path: 'example.pdf',
  printBackground: true,
});

I had the same problem with Firefox. It looks like if the user data gets corrupted if you don't close the browser properly. I turned headless off and then manually closed the browser when I was done. Then, my user data never got corrupted again.