chore(test): add blank lines (#3303)

Author: pavelfeldman

test/browsercontext-add-cookies.spec.js

@@ -26,6 +26,7 @@ it('should work', async({context, page, server}) => {
   }]);
   expect(await page.evaluate(() => document.cookie)).toEqual('password=123456');
 });
+
 it('should roundtrip cookie', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   // @see https://en.wikipedia.org/wiki/Year_2038_problem
@@ -42,6 +43,7 @@ it('should roundtrip cookie', async({context, page, server}) => {
   await context.addCookies(cookies);
   expect(await context.cookies()).toEqual(cookies);
 });
+
 it('should send cookie header', async({server, context}) => {
   let cookie = '';
   server.setRoute('/empty.html', (req, res) => {
@@ -53,6 +55,7 @@ it('should send cookie header', async({server, context}) => {
   await page.goto(server.EMPTY_PAGE);
   expect(cookie).toBe('cookie=value');
 });
+
 it('should isolate cookies in browser contexts', async({context, server, browser}) => {
   const anotherContext = await browser.newContext();
   await context.addCookies([{url: server.EMPTY_PAGE, name: 'isolatecookie', value: 'page1value'}]);
@@ -68,6 +71,7 @@ it('should isolate cookies in browser contexts', async({context, server, browser
   expect(cookies2[0].value).toBe('page2value');
   await anotherContext.close();
 });
+
 it('should isolate session cookies', async({context, server, browser}) => {
   server.setRoute('/setcookie.html', (req, res) => {
     res.setHeader('Set-Cookie', 'session=value');
@@ -93,6 +97,7 @@ it('should isolate session cookies', async({context, server, browser}) => {
     await context2.close();
   }
 });
+
 it('should isolate persistent cookies', async({context, server, browser}) => {
   server.setRoute('/setcookie.html', (req, res) => {
     res.setHeader('Set-Cookie', 'persistent=persistent-value; max-age=3600');
@@ -112,6 +117,7 @@ it('should isolate persistent cookies', async({context, server, browser}) => {
   expect(cookies2.length).toBe(0);
   await context2.close();
 });
+
 it('should isolate send cookie header', async({server, context, browser}) => {
   let cookie = [];
   server.setRoute('/empty.html', (req, res) => {
@@ -132,6 +138,7 @@ it('should isolate send cookie header', async({server, context, browser}) => {
     await context.close();
   }
 });
+
 it.slow()('should isolate cookies between launches', async({browserType, server, defaultBrowserOptions}) => {
   const browser1 = await browserType.launch(defaultBrowserOptions);
   const context1 = await browser1.newContext();
@@ -144,6 +151,7 @@ it.slow()('should isolate cookies between launches', async({browserType, server,
   expect(cookies.length).toBe(0);
   await browser2.close();
 });
+
 it('should set multiple cookies', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   await context.addCookies([{
@@ -163,6 +171,7 @@ it('should set multiple cookies', async({context, page, server}) => {
     'multiple-2=bar',
   ]);
 });
+
 it('should have |expires| set to |-1| for session cookies', async({context, server}) => {
   await context.addCookies([{
     url: server.EMPTY_PAGE,
@@ -172,6 +181,7 @@ it('should have |expires| set to |-1| for session cookies', async({context, serv
   const cookies = await context.cookies();
   expect(cookies[0].expires).toBe(-1);
 });
+
 it('should set cookie with reasonable defaults', async({context, server}) => {
   await context.addCookies([{
     url: server.EMPTY_PAGE,
@@ -190,6 +200,7 @@ it('should set cookie with reasonable defaults', async({context, server}) => {
     sameSite: 'None',
   }]);
 });
+
 it('should set a cookie with a path', async({context, page, server}) => {
   await page.goto(server.PREFIX + '/grid.html');
   await context.addCookies([{
@@ -214,6 +225,7 @@ it('should set a cookie with a path', async({context, page, server}) => {
   await page.goto(server.PREFIX + '/grid.html');
   expect(await page.evaluate('document.cookie')).toBe('gridcookie=GRID');
 });
+
 it('should not set a cookie with blank page URL', async function({context, server}) {
   let error = null;
   try {
@@ -228,6 +240,7 @@ it('should not set a cookie with blank page URL', async function({context, serve
       `Blank page can not have cookie "example-cookie-blank"`
   );
 });
+
 it('should not set a cookie on a data URL page', async function({context}) {
   let error = null;
   try {
@@ -237,6 +250,7 @@ it('should not set a cookie on a data URL page', async function({context}) {
   }
   expect(error.message).toContain('Data URL page can not have cookie "example-cookie"');
 });
+
 it('should default to setting secure cookie for HTTPS websites', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   const SECURE_URL = 'https://example.com';
@@ -248,6 +262,7 @@ it('should default to setting secure cookie for HTTPS websites', async({context,
   const [cookie] = await context.cookies(SECURE_URL);
   expect(cookie.secure).toBe(true);
 });
+
 it('should be able to set unsecure cookie for HTTP website', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   const HTTP_URL = 'http://example.com';
@@ -259,6 +274,7 @@ it('should be able to set unsecure cookie for HTTP website', async({context, pag
   const [cookie] = await context.cookies(HTTP_URL);
   expect(cookie.secure).toBe(false);
 });
+
 it('should set a cookie on a different domain', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   await context.addCookies([{
@@ -278,6 +294,7 @@ it('should set a cookie on a different domain', async({context, page, server}) =
     sameSite: 'None',
   }]);
 });
+
 it('should set cookies for a frame', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   await context.addCookies([
@@ -295,6 +312,7 @@ it('should set cookies for a frame', async({context, page, server}) => {
 
   expect(await page.frames()[1].evaluate('document.cookie')).toBe('frame-cookie=value');
 });
+
 it('should(not) block third party cookies', async({context, page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   await page.evaluate(src => {

test/browsercontext-page-event.spec.js

@@ -158,6 +158,7 @@ it('should fire page lifecycle events', async function({browser, server}) {
   ]);
   await context.close();
 });
+
 it.fail(WEBKIT)('should work with Shift-clicking', async({browser, server}) => {
   // WebKit: Shift+Click does not open a new window.
   const context = await browser.newContext();
@@ -171,6 +172,7 @@ it.fail(WEBKIT)('should work with Shift-clicking', async({browser, server}) => {
   expect(await popup.opener()).toBe(null);
   await context.close();
 });
+
 it.fail(WEBKIT || FFOX)('should work with Ctrl-clicking', async({browser, server}) => {
   // Firefox: reports an opener in this case.
   // WebKit: Ctrl+Click does not open a new tab.

test/downloads-path.spec.js

@@ -99,6 +99,7 @@ it('should delete downloads when context closes', async({downloadsBrowser, downl
   expect(fs.existsSync(path)).toBeFalsy();
 
 });
+
 it('should report downloads in downloadsPath folder', async({downloadsBrowser, downloadsPath, server}) => {
   const page = await downloadsBrowser.newPage({ acceptDownloads: true });
   await page.setContent(`<a href="${server.PREFIX}/download">download</a>`);

test/elementhandle-bounding-box.spec.js

@@ -25,6 +25,7 @@ it.fail(FFOX && !HEADLESS)('should work', async ({ page, server }) => {
   const box = await elementHandle.boundingBox();
   expect(box).toEqual({ x: 100, y: 50, width: 50, height: 50 });
 });
+
 it('should handle nested frames', async ({ page, server }) => {
   await page.setViewportSize({ width: 500, height: 500 });
   await page.goto(server.PREFIX + '/frames/nested-frames.html');
@@ -33,11 +34,13 @@ it('should handle nested frames', async ({ page, server }) => {
   const box = await elementHandle.boundingBox();
   expect(box).toEqual({ x: 24, y: 224, width: 268, height: 18 });
 });
+
 it('should return null for invisible elements', async ({ page, server }) => {
   await page.setContent('<div style="display:none">hi</div>');
   const element = await page.$('div');
   expect(await element.boundingBox()).toBe(null);
 });
+
 it('should force a layout', async ({ page, server }) => {
   await page.setViewportSize({ width: 500, height: 500 });
   await page.setContent('<div style="width: 100px; height: 100px">hello</div>');
@@ -46,6 +49,7 @@ it('should force a layout', async ({ page, server }) => {
   const box = await elementHandle.boundingBox();
   expect(box).toEqual({ x: 8, y: 8, width: 100, height: 200 });
 });
+
 it('should work with SVG nodes', async ({ page, server }) => {
   await page.setContent(`
       <svg xmlns="http://www.w3.org/2000/svg" width="500" height="500">
@@ -60,6 +64,7 @@ it('should work with SVG nodes', async ({ page, server }) => {
   }, element);
   expect(pwBoundingBox).toEqual(webBoundingBox);
 });
+
 it.skip(FFOX)('should work with page scale', async ({ browser, server }) => {
   const context = await browser.newContext({ viewport: { width: 400, height: 400, isMobile: true } });
   const page = await context.newPage();
@@ -80,6 +85,7 @@ it.skip(FFOX)('should work with page scale', async ({ browser, server }) => {
   expect(Math.round(box.height * 100)).toBe(20 * 100);
   await context.close();
 });
+
 it('should work when inline box child is outside of viewport', async ({ page, server }) => {
   await page.setContent(`
       <style>

test/elementhandle-click.spec.js

@@ -24,25 +24,29 @@ it('should work', async ({ page, server }) => {
   await button.click();
   expect(await page.evaluate(() => result)).toBe('Clicked');
 });
+
 it('should work with Node removed', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/input/button.html');
   await page.evaluate(() => delete window['Node']);
   const button = await page.$('button');
   await button.click();
   expect(await page.evaluate(() => result)).toBe('Clicked');
 });
+
 it('should work for Shadow DOM v1', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/shadow.html');
   const buttonHandle = await page.evaluateHandle(() => button);
   await buttonHandle.click();
   expect(await page.evaluate(() => clicked)).toBe(true);
 });
+
 it('should work for TextNodes', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/input/button.html');
   const buttonTextNode = await page.evaluateHandle(() => document.querySelector('button').firstChild);
   await buttonTextNode.click();
   expect(await page.evaluate(() => result)).toBe('Clicked');
 });
+
 it('should throw for detached nodes', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/input/button.html');
   const button = await page.$('button');
@@ -51,26 +55,30 @@ it('should throw for detached nodes', async ({ page, server }) => {
   await button.click().catch(err => error = err);
   expect(error.message).toContain('Element is not attached to the DOM');
 });
+
 it('should throw for hidden nodes with force', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/input/button.html');
   const button = await page.$('button');
   await page.evaluate(button => button.style.display = 'none', button);
   const error = await button.click({ force: true }).catch(err => err);
   expect(error.message).toContain('Element is not visible');
 });
+
 it('should throw for recursively hidden nodes with force', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/input/button.html');
   const button = await page.$('button');
   await page.evaluate(button => button.parentElement.style.display = 'none', button);
   const error = await button.click({ force: true }).catch(err => err);
   expect(error.message).toContain('Element is not visible');
 });
+
 it('should throw for <br> elements with force', async ({ page, server }) => {
   await page.setContent('hello<br>goodbye');
   const br = await page.$('br');
   const error = await br.click({ force: true }).catch(err => err);
   expect(error.message).toContain('Element is outside of the viewport');
 });
+
 it('should double click the button', async ({ page, server }) => {
   await page.goto(server.PREFIX + '/input/button.html');
   await page.evaluate(() => {

test/elementhandle-content-frame.spec.js

@@ -25,27 +25,31 @@ it('should work', async ({ page, server }) => {
   const frame = await elementHandle.contentFrame();
   expect(frame).toBe(page.frames()[1]);
 });
+
 it('should work for cross-process iframes', async ({ page, server }) => {
   await page.goto(server.EMPTY_PAGE);
   await utils.attachFrame(page, 'frame1', server.CROSS_PROCESS_PREFIX + '/empty.html');
   const elementHandle = await page.$('#frame1');
   const frame = await elementHandle.contentFrame();
   expect(frame).toBe(page.frames()[1]);
 });
+
 it('should work for cross-frame evaluations', async ({ page, server }) => {
   await page.goto(server.EMPTY_PAGE);
   await utils.attachFrame(page, 'frame1', server.EMPTY_PAGE);
   const frame = page.frames()[1];
   const elementHandle = await frame.evaluateHandle(() => window.top.document.querySelector('#frame1'));
   expect(await elementHandle.contentFrame()).toBe(frame);
 });
+
 it('should return null for non-iframes', async ({ page, server }) => {
   await page.goto(server.EMPTY_PAGE);
   await utils.attachFrame(page, 'frame1', server.EMPTY_PAGE);
   const frame = page.frames()[1];
   const elementHandle = await frame.evaluateHandle(() => document.body);
   expect(await elementHandle.contentFrame()).toBe(null);
 });
+
 it('should return null for document.documentElement', async ({ page, server }) => {
   await page.goto(server.EMPTY_PAGE);
   await utils.attachFrame(page, 'frame1', server.EMPTY_PAGE);

test/elementhandle-convenience.spec.js

@@ -30,6 +30,7 @@ it('should have a nice preview', async ({ page, server }) => {
   expect(String(text)).toBe('JSHandle@#text=Text,↵more text');
   expect(String(check)).toBe('JSHandle@<input checked id="check" foo="bar"" type="checkbox"/>');
 });
+
 it('getAttribute should work', async ({ page, server }) => {
   await page.goto(`${server.PREFIX}/dom.html`);
   const handle = await page.$('#outer');
@@ -38,18 +39,21 @@ it('getAttribute should work', async ({ page, server }) => {
   expect(await page.getAttribute('#outer', 'name')).toBe('value');
   expect(await page.getAttribute('#outer', 'foo')).toBe(null);
 });
+
 it('innerHTML should work', async ({ page, server }) => {
   await page.goto(`${server.PREFIX}/dom.html`);
   const handle = await page.$('#outer');
   expect(await handle.innerHTML()).toBe('<div id="inner">Text,\nmore text</div>');
   expect(await page.innerHTML('#outer')).toBe('<div id="inner">Text,\nmore text</div>');
 });
+
 it('innerText should work', async ({ page, server }) => {
   await page.goto(`${server.PREFIX}/dom.html`);
   const handle = await page.$('#inner');
   expect(await handle.innerText()).toBe('Text, more text');
   expect(await page.innerText('#inner')).toBe('Text, more text');
 });
+
 it('innerText should throw', async ({ page, server }) => {
   await page.setContent(`<svg>text</svg>`);
   const error1 = await page.innerText('svg').catch(e => e);
@@ -58,12 +62,14 @@ it('innerText should throw', async ({ page, server }) => {
   const error2 = await handle.innerText().catch(e => e);
   expect(error2.message).toContain('Not an HTMLElement');
 });
+
 it('textContent should work', async ({ page, server }) => {
   await page.goto(`${server.PREFIX}/dom.html`);
   const handle = await page.$('#inner');
   expect(await handle.textContent()).toBe('Text,\nmore text');
   expect(await page.textContent('#inner')).toBe('Text,\nmore text');
 });
+
 it('textContent should be atomic', async ({ playwright, page }) => {
   const createDummySelector = () => ({
     create(root, target) { },
@@ -86,6 +92,7 @@ it('textContent should be atomic', async ({ playwright, page }) => {
   expect(tc).toBe('Hello');
   expect(await page.evaluate(() => document.querySelector('div').textContent)).toBe('modified');
 });
+
 it('innerText should be atomic', async ({ playwright, page }) => {
   const createDummySelector = () => ({
     create(root, target) { },
@@ -108,6 +115,7 @@ it('innerText should be atomic', async ({ playwright, page }) => {
   expect(tc).toBe('Hello');
   expect(await page.evaluate(() => document.querySelector('div').innerText)).toBe('modified');
 });
+
 it('innerHTML should be atomic', async ({ playwright, page }) => {
   const createDummySelector = () => ({
     create(root, target) { },
@@ -130,6 +138,7 @@ it('innerHTML should be atomic', async ({ playwright, page }) => {
   expect(tc).toBe('Hello<span>world</span>');
   expect(await page.evaluate(() => document.querySelector('div').innerHTML)).toBe('modified');
 });
+
 it('getAttribute should be atomic', async ({ playwright, page }) => {
   const createDummySelector = () => ({
     create(root, target) { },