mirror of
https://github.com/microsoft/playwright.git
synced 2024-10-27 13:50:25 +03:00
d76166beca
This patch moves fixtures.js to base.fixtures.ts that sits next to tests. All tests get an extra import to get the base fixtures (both types and implementations).
212 lines
7.4 KiB
JavaScript
212 lines
7.4 KiB
JavaScript
/**
|
|
* Copyright 2018 Google Inc. All rights reserved.
|
|
* Modifications copyright (c) Microsoft Corporation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
require('./base.fixture');
|
|
|
|
const utils = require('./utils');
|
|
const {FFOX, CHROMIUM, WEBKIT, CHANNEL} = testOptions;
|
|
|
|
it('should timeout', async({page, server}) => {
|
|
const startTime = Date.now();
|
|
const timeout = 42;
|
|
await page.waitForTimeout(timeout);
|
|
expect(Date.now() - startTime).not.toBeLessThan(timeout / 2);
|
|
});
|
|
|
|
it('should accept a string', async({page, server}) => {
|
|
const watchdog = page.waitForFunction('window.__FOO === 1');
|
|
await page.evaluate(() => window.__FOO = 1);
|
|
await watchdog;
|
|
});
|
|
|
|
it('should work when resolved right before execution context disposal', async({page, server}) => {
|
|
await page.addInitScript(() => window.__RELOADED = true);
|
|
await page.waitForFunction(() => {
|
|
if (!window.__RELOADED)
|
|
window.location.reload();
|
|
return true;
|
|
});
|
|
});
|
|
|
|
it('should poll on interval', async({page, server}) => {
|
|
const polling = 100;
|
|
const timeDelta = await page.waitForFunction(() => {
|
|
if (!window.__startTime) {
|
|
window.__startTime = Date.now();
|
|
return false;
|
|
}
|
|
return Date.now() - window.__startTime;
|
|
}, {}, {polling});
|
|
expect(await timeDelta.jsonValue()).not.toBeLessThan(polling);
|
|
});
|
|
|
|
it('should avoid side effects after timeout', async({page, server}) => {
|
|
let counter = 0;
|
|
page.on('console', () => ++counter);
|
|
|
|
const error = await page.waitForFunction(() => {
|
|
window.counter = (window.counter || 0) + 1;
|
|
console.log(window.counter);
|
|
}, {}, { polling: 1, timeout: 1000 }).catch(e => e);
|
|
|
|
const savedCounter = counter;
|
|
await page.waitForTimeout(2000); // Give it some time to produce more logs.
|
|
|
|
expect(error.message).toContain('page.waitForFunction: Timeout 1000ms exceeded');
|
|
expect(counter).toBe(savedCounter);
|
|
});
|
|
|
|
it('should throw on polling:mutation', async({page, server}) => {
|
|
const error = await page.waitForFunction(() => true, {}, {polling: 'mutation'}).catch(e => e);
|
|
expect(error.message).toContain('Unknown polling option: mutation');
|
|
});
|
|
|
|
it('should poll on raf', async({page, server}) => {
|
|
const watchdog = page.waitForFunction(() => window.__FOO === 'hit', {}, {polling: 'raf'});
|
|
await page.evaluate(() => window.__FOO = 'hit');
|
|
await watchdog;
|
|
});
|
|
|
|
it('should fail with predicate throwing on first call', async({page, server}) => {
|
|
const error = await page.waitForFunction(() => { throw new Error('oh my'); }).catch(e => e);
|
|
expect(error.message).toContain('oh my');
|
|
});
|
|
|
|
it('should fail with predicate throwing sometimes', async({page, server}) => {
|
|
const error = await page.waitForFunction(() => {
|
|
window.counter = (window.counter || 0) + 1;
|
|
if (window.counter === 3)
|
|
throw new Error('Bad counter!');
|
|
return window.counter === 5 ? 'result' : false;
|
|
}).catch(e => e);
|
|
expect(error.message).toContain('Bad counter!');
|
|
});
|
|
|
|
it('should fail with ReferenceError on wrong page', async({page, server}) => {
|
|
const error = await page.waitForFunction(() => globalVar === 123).catch(e => e);
|
|
expect(error.message).toContain('globalVar');
|
|
});
|
|
|
|
it('should work with strict CSP policy', async({page, server}) => {
|
|
server.setCSP('/empty.html', 'script-src ' + server.PREFIX);
|
|
await page.goto(server.EMPTY_PAGE);
|
|
let error = null;
|
|
await Promise.all([
|
|
page.waitForFunction(() => window.__FOO === 'hit', {}, {polling: 'raf'}).catch(e => error = e),
|
|
page.evaluate(() => window.__FOO = 'hit')
|
|
]);
|
|
expect(error).toBe(null);
|
|
});
|
|
|
|
it('should throw on bad polling value', async({page, server}) => {
|
|
let error = null;
|
|
try {
|
|
await page.waitForFunction(() => !!document.body, {}, {polling: 'unknown'});
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
expect(error).toBeTruthy();
|
|
expect(error.message).toContain('polling');
|
|
});
|
|
|
|
it('should throw negative polling interval', async({page, server}) => {
|
|
let error = null;
|
|
try {
|
|
await page.waitForFunction(() => !!document.body, {}, {polling: -10});
|
|
} catch (e) {
|
|
error = e;
|
|
}
|
|
expect(error).toBeTruthy();
|
|
expect(error.message).toContain('Cannot poll with non-positive interval');
|
|
});
|
|
|
|
it('should return the success value as a JSHandle', async({page}) => {
|
|
expect(await (await page.waitForFunction(() => 5)).jsonValue()).toBe(5);
|
|
});
|
|
|
|
it('should return the window as a success value', async({ page }) => {
|
|
expect(await page.waitForFunction(() => window)).toBeTruthy();
|
|
});
|
|
|
|
it('should accept ElementHandle arguments', async({page}) => {
|
|
await page.setContent('<div></div>');
|
|
const div = await page.$('div');
|
|
let resolved = false;
|
|
const waitForFunction = page.waitForFunction(element => !element.parentElement, div).then(() => resolved = true);
|
|
expect(resolved).toBe(false);
|
|
await page.evaluate(element => element.remove(), div);
|
|
await waitForFunction;
|
|
});
|
|
|
|
it('should respect timeout', async({page, playwright}) => {
|
|
let error = null;
|
|
await page.waitForFunction('false', {}, {timeout: 10}).catch(e => error = e);
|
|
expect(error).toBeTruthy();
|
|
expect(error.message).toContain('page.waitForFunction: Timeout 10ms exceeded');
|
|
expect(error).toBeInstanceOf(playwright.errors.TimeoutError);
|
|
});
|
|
|
|
it('should respect default timeout', async({page, playwright}) => {
|
|
page.setDefaultTimeout(1);
|
|
let error = null;
|
|
await page.waitForFunction('false').catch(e => error = e);
|
|
expect(error).toBeInstanceOf(playwright.errors.TimeoutError);
|
|
expect(error.message).toContain('page.waitForFunction: Timeout 1ms exceeded');
|
|
});
|
|
|
|
it('should disable timeout when its set to 0', async({page}) => {
|
|
const watchdog = page.waitForFunction(() => {
|
|
window.__counter = (window.__counter || 0) + 1;
|
|
return window.__injected;
|
|
}, {}, {timeout: 0, polling: 10});
|
|
await page.waitForFunction(() => window.__counter > 10);
|
|
await page.evaluate(() => window.__injected = true);
|
|
await watchdog;
|
|
});
|
|
|
|
it('should survive cross-process navigation', async({page, server}) => {
|
|
let fooFound = false;
|
|
const waitForFunction = page.waitForFunction('window.__FOO === 1').then(() => fooFound = true);
|
|
await page.goto(server.EMPTY_PAGE);
|
|
expect(fooFound).toBe(false);
|
|
await page.reload();
|
|
expect(fooFound).toBe(false);
|
|
await page.goto(server.CROSS_PROCESS_PREFIX + '/grid.html');
|
|
expect(fooFound).toBe(false);
|
|
await page.evaluate(() => window.__FOO = 1);
|
|
await waitForFunction;
|
|
expect(fooFound).toBe(true);
|
|
});
|
|
|
|
it('should survive navigations', async({page, server}) => {
|
|
const watchdog = page.waitForFunction(() => window.__done);
|
|
await page.goto(server.EMPTY_PAGE);
|
|
await page.goto(server.PREFIX + '/consolelog.html');
|
|
await page.evaluate(() => window.__done = true);
|
|
await watchdog;
|
|
});
|
|
|
|
it('should work with multiline body', async({page, server}) => {
|
|
const result = await page.waitForFunction(`
|
|
(() => true)()
|
|
`);
|
|
expect(await result.jsonValue()).toBe(true);
|
|
});
|
|
|
|
it('should wait for predicate with arguments', async({page, server}) => {
|
|
await page.waitForFunction(({arg1, arg2}) => arg1 + arg2 === 3, { arg1: 1, arg2: 2});
|
|
});
|