microsoft
/
playwright
зеркало из https://github.com/microsoft/playwright.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

test: unskip working Android tests (#16171)

This commit is contained in:
Max Schmitt 2022-08-02 22:51:10 +02:00 коммит произвёл GitHub
Родитель 135971c406
Коммит a2fc636f8e
Не найден ключ, соответствующий данной подписи
Идентификатор ключа GPG: 4AEE18F83AFDEB23
22 изменённых файлов: 55 добавлений и 149 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

94
tests/library/browsercontext-har.spec.ts
Просмотреть файл

@ -19,9 +19,7 @@ import fs from 'fs';
import path from 'path';
import extractZip from '../../packages/playwright-core/bundles/zip/node_modules/extract-zip';
it('should context.routeFromHAR, matching the method and following redirects', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should context.routeFromHAR, matching the method and following redirects', async ({ context, asset }) => {
const path = asset('har-fulfill.har');
await context.routeFromHAR(path);
const page = await context.newPage();
@ -32,9 +30,7 @@ it('should context.routeFromHAR, matching the method and following redirects', a
await expect(page.locator('body')).toHaveCSS('background-color', 'rgb(255, 0, 0)');
});
it('should page.routeFromHAR, matching the method and following redirects', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should page.routeFromHAR, matching the method and following redirects', async ({ context, asset }) => {
const path = asset('har-fulfill.har');
const page = await context.newPage();
await page.routeFromHAR(path);
@ -45,9 +41,7 @@ it('should page.routeFromHAR, matching the method and following redirects', asyn
await expect(page.locator('body')).toHaveCSS('background-color', 'rgb(255, 0, 0)');
});
it('fallback:continue should continue when not found in har', async ({ context, server, isAndroid, asset }) => {
it.fixme(isAndroid);
it('fallback:continue should continue when not found in har', async ({ context, server, asset }) => {
const path = asset('har-fulfill.har');
await context.routeFromHAR(path, { notFound: 'fallback' });
const page = await context.newPage();
@ -55,9 +49,7 @@ it('fallback:continue should continue when not found in har', async ({ context,
await expect(page.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('by default should abort requests not found in har', async ({ context, server, isAndroid, asset }) => {
it.fixme(isAndroid);
it('by default should abort requests not found in har', async ({ context, server, asset }) => {
const path = asset('har-fulfill.har');
await context.routeFromHAR(path);
const page = await context.newPage();
@ -65,9 +57,7 @@ it('by default should abort requests not found in har', async ({ context, server
expect(error instanceof Error).toBe(true);
});
it('fallback:continue should continue requests on bad har', async ({ context, server, isAndroid }, testInfo) => {
it.fixme(isAndroid);
it('fallback:continue should continue requests on bad har', async ({ context, server }, testInfo) => {
const path = testInfo.outputPath('test.har');
fs.writeFileSync(path, JSON.stringify({ log: {} }), 'utf-8');
await context.routeFromHAR(path, { notFound: 'fallback' });
@ -76,9 +66,7 @@ it('fallback:continue should continue requests on bad har', async ({ context, se
await expect(page.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('should only handle requests matching url filter', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should only handle requests matching url filter', async ({ context, asset }) => {
const path = asset('har-fulfill.har');
await context.routeFromHAR(path, { notFound: 'fallback', url: '**/*.js' });
const page = await context.newPage();
@ -96,9 +84,7 @@ it('should only handle requests matching url filter', async ({ context, isAndroi
await expect(page.locator('body')).toHaveCSS('background-color', 'rgba(0, 0, 0, 0)');
});
it('should only context.routeFromHAR requests matching url filter', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should only context.routeFromHAR requests matching url filter', async ({ context, asset }) => {
const path = asset('har-fulfill.har');
await context.routeFromHAR(path, { url: '**/*.js' });
const page = await context.newPage();
@ -116,9 +102,7 @@ it('should only context.routeFromHAR requests matching url filter', async ({ con
await expect(page.locator('body')).toHaveCSS('background-color', 'rgba(0, 0, 0, 0)');
});
it('should only page.routeFromHAR requests matching url filter', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should only page.routeFromHAR requests matching url filter', async ({ context, asset }) => {
const path = asset('har-fulfill.har');
const page = await context.newPage();
await page.routeFromHAR(path, { url: '**/*.js' });
@ -136,9 +120,7 @@ it('should only page.routeFromHAR requests matching url filter', async ({ contex
await expect(page.locator('body')).toHaveCSS('background-color', 'rgba(0, 0, 0, 0)');
});
it('should support regex filter', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should support regex filter', async ({ context, asset }) => {
const path = asset('har-fulfill.har');
await context.routeFromHAR(path, { url: /.*(\.js|.*\.css|no.playwright\/)$/ });
const page = await context.newPage();
@ -147,9 +129,7 @@ it('should support regex filter', async ({ context, isAndroid, asset }) => {
await expect(page.locator('body')).toHaveCSS('background-color', 'rgb(255, 0, 0)');
});
it('newPage should fulfill from har, matching the method and following redirects', async ({ browser, isAndroid, asset }) => {
it.fixme(isAndroid);
it('newPage should fulfill from har, matching the method and following redirects', async ({ browser, asset }) => {
const path = asset('har-fulfill.har');
const page = await browser.newPage();
await page.routeFromHAR(path);
@ -161,9 +141,7 @@ it('newPage should fulfill from har, matching the method and following redirects
await page.close();
});
it('should change document URL after redirected navigation', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should change document URL after redirected navigation', async ({ context, asset }) => {
const path = asset('har-redirect.har');
await context.routeFromHAR(path);
const page = await context.newPage();
@ -177,9 +155,7 @@ it('should change document URL after redirected navigation', async ({ context, i
expect(await page.evaluate(() => location.href)).toBe('https://www.theverge.com/');
});
it('should change document URL after redirected navigation on click', async ({ server, context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should change document URL after redirected navigation on click', async ({ server, context, asset }) => {
const path = asset('har-redirect.har');
await context.routeFromHAR(path, { url: /.*theverge.*/ });
const page = await context.newPage();
@ -194,9 +170,7 @@ it('should change document URL after redirected navigation on click', async ({ s
expect(await page.evaluate(() => location.href)).toBe('https://www.theverge.com/');
});
it('should goBack to redirected navigation', async ({ context, isAndroid, asset, server }) => {
it.fixme(isAndroid);
it('should goBack to redirected navigation', async ({ context, asset, server }) => {
const path = asset('har-redirect.har');
await context.routeFromHAR(path, { url: /.*theverge.*/ });
const page = await context.newPage();
@ -209,8 +183,7 @@ it('should goBack to redirected navigation', async ({ context, isAndroid, asset,
expect(await page.evaluate(() => location.href)).toBe('https://www.theverge.com/');
});
it('should goForward to redirected navigation', async ({ context, isAndroid, asset, server, browserName }) => {
it.fixme(isAndroid);
it('should goForward to redirected navigation', async ({ context, asset, server, browserName }) => {
it.fixme(browserName === 'firefox', 'Flaky in firefox');
const path = asset('har-redirect.har');
@ -228,9 +201,7 @@ it('should goForward to redirected navigation', async ({ context, isAndroid, ass
expect(await page.evaluate(() => location.href)).toBe('https://www.theverge.com/');
});
it('should reload redirected navigation', async ({ context, isAndroid, asset, server }) => {
it.fixme(isAndroid);
it('should reload redirected navigation', async ({ context, asset, server }) => {
const path = asset('har-redirect.har');
await context.routeFromHAR(path, { url: /.*theverge.*/ });
const page = await context.newPage();
@ -242,9 +213,7 @@ it('should reload redirected navigation', async ({ context, isAndroid, asset, se
expect(await page.evaluate(() => location.href)).toBe('https://www.theverge.com/');
});
it('should fulfill from har with content in a file', async ({ context, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should fulfill from har with content in a file', async ({ context, asset }) => {
const path = asset('har-sha1.har');
await context.routeFromHAR(path);
const page = await context.newPage();
@ -252,9 +221,7 @@ it('should fulfill from har with content in a file', async ({ context, isAndroid
expect(await page.content()).toBe('<html><head></head><body>Hello, world</body></html>');
});
it('should round-trip har.zip', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should round-trip har.zip', async ({ contextFactory, server }, testInfo) => {
const harPath = testInfo.outputPath('har.zip');
const context1 = await contextFactory({ recordHar: { mode: 'minimal', path: harPath } });
const page1 = await context1.newPage();
@ -269,9 +236,7 @@ it('should round-trip har.zip', async ({ contextFactory, isAndroid, server }, te
await expect(page2.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('should produce extracted zip', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should produce extracted zip', async ({ contextFactory, server }, testInfo) => {
const harPath = testInfo.outputPath('har.har');
const context1 = await contextFactory({ recordHar: { mode: 'minimal', path: harPath, content: 'attach' } });
const page1 = await context1.newPage();
@ -290,9 +255,7 @@ it('should produce extracted zip', async ({ contextFactory, isAndroid, server },
await expect(page2.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('should round-trip extracted har.zip', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should round-trip extracted har.zip', async ({ contextFactory, server }, testInfo) => {
const harPath = testInfo.outputPath('har.zip');
const context1 = await contextFactory({ recordHar: { mode: 'minimal', path: harPath } });
const page1 = await context1.newPage();
@ -310,8 +273,7 @@ it('should round-trip extracted har.zip', async ({ contextFactory, isAndroid, se
await expect(page2.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('should round-trip har with postData', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should round-trip har with postData', async ({ contextFactory, server }, testInfo) => {
server.setRoute('/echo', async (req, res) => {
const body = await req.postBody;
res.end(body.toString());
@ -341,9 +303,7 @@ it('should round-trip har with postData', async ({ contextFactory, isAndroid, se
expect(await page2.evaluate(fetchFunction, '4').catch(e => e)).toBeTruthy();
});
it('should disambiguate by header', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should disambiguate by header', async ({ contextFactory, server }, testInfo) => {
server.setRoute('/echo', async (req, res) => {
res.end(req.headers['baz']);
});
@ -381,9 +341,7 @@ it('should disambiguate by header', async ({ contextFactory, isAndroid, server }
expect(await page2.evaluate(fetchFunction, 'baz4')).toBe('baz1');
});
it('should update har.zip for context', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should update har.zip for context', async ({ contextFactory, server }, testInfo) => {
const harPath = testInfo.outputPath('har.zip');
const context1 = await contextFactory();
await context1.routeFromHAR(harPath, { update: true });
@ -399,9 +357,7 @@ it('should update har.zip for context', async ({ contextFactory, isAndroid, serv
await expect(page2.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('should update har.zip for page', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should update har.zip for page', async ({ contextFactory, server }, testInfo) => {
const harPath = testInfo.outputPath('har.zip');
const context1 = await contextFactory();
const page1 = await context1.newPage();
@ -417,9 +373,7 @@ it('should update har.zip for page', async ({ contextFactory, isAndroid, server
await expect(page2.locator('body')).toHaveCSS('background-color', 'rgb(255, 192, 203)');
});
it('should update extracted har.zip for page', async ({ contextFactory, isAndroid, server }, testInfo) => {
it.fixme(isAndroid);
it('should update extracted har.zip for page', async ({ contextFactory, server }, testInfo) => {
const harPath = testInfo.outputPath('har.har');
const context1 = await contextFactory();
const page1 = await context1.newPage();

4
tests/library/defaultbrowsercontext-2.spec.ts
Просмотреть файл

@ -224,9 +224,7 @@ it('should connect to a browser with the default page', async ({ browserType,cre
await context.close();
});
it('should support har option', async ({ isAndroid, launchPersistent, asset }) => {
it.fixme(isAndroid);
it('should support har option', async ({ launchPersistent, asset }) => {
const path = asset('har-fulfill.har');
const { page } = await launchPersistent();
await page.routeFromHAR(path);

4
tests/page/frame-goto.spec.ts
Просмотреть файл

@ -40,9 +40,7 @@ it('should reject when frame detaches', async ({ page, server }) => {
expect(error.message).toContain('frame was detached');
});
it('should continue after client redirect', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid);
it('should continue after client redirect', async ({ page, server }) => {
server.setRoute('/frames/script.js', () => {});
const url = server.PREFIX + '/frames/child-redirect.html';
const error = await page.goto(url, { timeout: 5000, waitUntil: 'networkidle' }).catch(e => e);

3
tests/page/locator-frame.spec.ts
Просмотреть файл

@ -106,8 +106,7 @@ it('should wait for frame 2', async ({ page, server }) => {
await page.frameLocator('iframe').locator('button').click();
});
it('should wait for frame to go', async ({ page, server, isAndroid }) => {
it.fail(isAndroid, 'iframe is not removed on Android');
it('should wait for frame to go', async ({ page, server }) => {
await routeIframe(page);
await page.goto(server.EMPTY_PAGE);
setTimeout(() => page.$eval('iframe', e => e.remove()).catch(() => {}), 300);

3
tests/page/matchers.misc.spec.ts
Просмотреть файл

@ -16,8 +16,7 @@
import { test as it, expect } from './pageTest';
it('should outlive frame navigation', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Should be fixed when rolling the emulator');
it('should outlive frame navigation', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
setTimeout(async () => {
await page.goto(server.PREFIX + '/grid.html').catch(() => {});

2
tests/page/network-post-data.spec.ts
Просмотреть файл

@ -16,8 +16,6 @@
import { test as it, expect } from './pageTest';
it.fixme(({ isAndroid }) => isAndroid, 'Post data does not work');
it('should return correct postData buffer for utf-8 body', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
const value = 'baẞ';

2
tests/page/page-autowaiting-basic.spec.ts
Просмотреть файл

@ -28,8 +28,6 @@ function initServer(server: TestServer): string[] {
return messages;
}
it.skip(({ isAndroid }) => isAndroid, 'Too flaky on Android');
it('should await navigation when clicking anchor', async ({ page, server }) => {
const messages = initServer(server);
await page.setContent(`<a id="anchor" href="${server.EMPTY_PAGE}">empty.html</a>`);

3
tests/page/page-click-scroll.spec.ts
Просмотреть файл

@ -16,10 +16,9 @@
import { test as it } from './pageTest';
it('should not hit scroll bar', async ({ page, isAndroid, browserName, platform }) => {
it('should not hit scroll bar', async ({ page, browserName, platform }) => {
it.fixme(browserName === 'webkit' && platform === 'darwin');
it.fixme(browserName === 'webkit' && platform === 'linux', 'Fails in headless and in headful on Ubuntu 22.04');
it.skip(isAndroid);
await page.setContent(`
<style>

10
tests/page/page-click.spec.ts
Просмотреть файл

@ -392,8 +392,7 @@ it('should click the button with em border with offset', async ({ page, server,
expect(await page.evaluate('offsetY')).toBe(browserName === 'webkit' ? 12 * 2 + 10 : 10);
});
it('should click a very large button with offset', async ({ page, server, browserName, isAndroid }) => {
it.fixme(isAndroid);
it('should click a very large button with offset', async ({ page, server, browserName }) => {
await page.goto(server.PREFIX + '/input/button.html');
await page.$eval('button', button => button.style.borderWidth = '8px');
@ -405,8 +404,7 @@ it('should click a very large button with offset', async ({ page, server, browse
expect(await page.evaluate('offsetY')).toBe(browserName === 'webkit' ? 1910 + 8 : 1910);
});
it('should click a button in scrolling container with offset', async ({ page, server, browserName, isAndroid }) => {
it.fixme(isAndroid);
it('should click a button in scrolling container with offset', async ({ page, server, browserName }) => {
await page.goto(server.PREFIX + '/input/button.html');
await page.$eval('button', button => {
@ -840,8 +838,8 @@ it('should not throw protocol error when navigating during the click', async ({
expect(await page.evaluate('result')).toBe('Clicked');
});
it('should retry when navigating during the click', async ({ page, server, mode, isAndroid }) => {
it.skip(mode !== 'default' || isAndroid);
it('should retry when navigating during the click', async ({ page, server, mode }) => {
it.skip(mode !== 'default');
await page.goto(server.PREFIX + '/input/button.html');
let firstTime = true;

5
tests/page/page-drag.spec.ts
Просмотреть файл

@ -19,7 +19,6 @@ import { test as it, expect } from './pageTest';
import { attachFrame } from '../config/utils';
it.describe('Drag and drop', () => {
it.skip(({ isAndroid }) => isAndroid);
it.skip(({ browserName, browserMajorVersion }) => browserName === 'chromium' && browserMajorVersion < 91);
it('should work @smoke', async ({ page, server }) => {
@ -202,7 +201,9 @@ it.describe('Drag and drop', () => {
expect(await page.$eval('#target', target => target.contains(document.querySelector('#source')))).toBe(true);
});
it('should be able to drag the mouse in a frame', async ({ page, server }) => {
it('should be able to drag the mouse in a frame', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid);
await page.goto(server.PREFIX + '/frames/one-frame.html');
const eventsHandle = await trackEvents(await page.frames()[1].$('html'));
await page.mouse.move(30, 30);

2
tests/page/page-emulate-media.spec.ts
Просмотреть файл

@ -17,8 +17,6 @@
import { test as it, expect } from './pageTest';
it.skip(({ isAndroid }) => isAndroid);
it('should emulate type @smoke', async ({ page }) => {
expect(await page.evaluate(() => matchMedia('screen').matches)).toBe(true);
expect(await page.evaluate(() => matchMedia('print').matches)).toBe(false);

2
tests/page/page-fill.spec.ts
Просмотреть файл

@ -17,8 +17,6 @@
import { test as it, expect } from './pageTest';
it.skip(({ isAndroid }) => isAndroid);
async function giveItAChanceToFill(page) {
for (let i = 0; i < 5; i++)
await page.evaluate(() => new Promise(f => requestAnimationFrame(() => requestAnimationFrame(f))));

3
tests/page/page-goto.spec.ts
Просмотреть файл

@ -634,9 +634,8 @@ it('should properly report window.stop()', async ({ page, server }) => {
await page.goto(server.PREFIX + '/window-stop.html');
});
it('should return from goto if new navigation is started', async ({ page, server, browserName, isAndroid }) => {
it('should return from goto if new navigation is started', async ({ page, server, browserName }) => {
it.fixme(browserName === 'webkit', 'WebKit has a bug where Page.frameStoppedLoading is sent too early.');
it.fail(isAndroid, 'Navigation gets aborted on Android');
server.setRoute('/slow.js', async (req, res) => void 0);
let finished = false;
const navigation = page.goto(server.PREFIX + '/load-event/load-event.html').then(r => {

2
tests/page/page-mouse.spec.ts
Просмотреть файл

@ -231,7 +231,7 @@ it('should tween mouse movement', async ({ page, browserName, isAndroid }) => {
]);
});
it('should always round down', async ({ page, browserName, isAndroid }) => {
it('should always round down', async ({ page }) => {
await page.evaluate(() => {
document.addEventListener('mousedown', event => {
window['result'] = [event.clientX, event.clientY];

4
tests/page/page-network-idle.spec.ts
Просмотреть файл

@ -138,9 +138,7 @@ it('should wait for networkidle from the child frame', async ({ page, server })
});
});
it('should wait for networkidle from the popup', async ({ page, server, isAndroid }) => {
it.skip(isAndroid, 'Too slow');
it('should wait for networkidle from the popup', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
await page.setContent(`
<button id=box1 onclick="window.open('./popup/popup.html')">Button1</button>

28
tests/page/page-network-request.spec.ts
Просмотреть файл

@ -200,9 +200,7 @@ it('should not get preflight CORS requests when intercepting', async ({ page, se
}
});
it('should return postData', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should return postData', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
server.setRoute('/post', (req, res) => res.end());
let request = null;
@ -212,9 +210,7 @@ it('should return postData', async ({ page, server, isAndroid }) => {
expect(request.postData()).toBe('{"foo":"bar"}');
});
it('should work with binary post data', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should work with binary post data', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
server.setRoute('/post', (req, res) => res.end());
let request = null;
@ -229,9 +225,7 @@ it('should work with binary post data', async ({ page, server, isAndroid }) => {
expect(buffer[i]).toBe(i);
});
it('should work with binary post data and interception', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should work with binary post data and interception', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
server.setRoute('/post', (req, res) => res.end());
let request = null;
@ -247,9 +241,7 @@ it('should work with binary post data and interception', async ({ page, server,
expect(buffer[i]).toBe(i);
});
it('should override post data content type', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should override post data content type', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
let request = null;
server.setRoute('/post', (req, res) => {
@ -271,16 +263,12 @@ it('should override post data content type', async ({ page, server, isAndroid })
expect(request.headers['content-type']).toBe('application/x-www-form-urlencoded; charset=UTF-8');
});
it('should get |undefined| with postData() when there is no post data', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should get |undefined| with postData() when there is no post data', async ({ page, server }) => {
const response = await page.goto(server.EMPTY_PAGE);
expect(response.request().postData()).toBe(null);
});
it('should parse the json post data', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should parse the json post data', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
server.setRoute('/post', (req, res) => res.end());
let request = null;
@ -290,9 +278,7 @@ it('should parse the json post data', async ({ page, server, isAndroid }) => {
expect(request.postDataJSON()).toEqual({ 'foo': 'bar' });
});
it('should parse the data if content-type is application/x-www-form-urlencoded', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid, 'Post data does not work');
it('should parse the data if content-type is application/x-www-form-urlencoded', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
server.setRoute('/post', (req, res) => res.end());
let request = null;

3
tests/page/page-network-response.spec.ts
Просмотреть файл

@ -239,9 +239,8 @@ it('should report multiple set-cookie headers', async ({ page, server, isElectro
expect(await response.headerValues('set-cookie')).toEqual(['a=b', 'c=d']);
});
it('should behave the same way for headers and allHeaders', async ({ page, server, browserName, channel, platform, isAndroid }) => {
it('should behave the same way for headers and allHeaders', async ({ page, server, browserName, platform }) => {
it.fixme(browserName === 'webkit' && platform === 'win32', 'libcurl does not support non-set-cookie multivalue headers');
it.fixme(isAndroid, 'Android uses \n as a header separator in non-raw headers');
server.setRoute('/headers', (req, res) => {
const headers = {
'Set-Cookie': ['a=b', 'c=d'],

2
tests/page/page-request-continue.spec.ts
Просмотреть файл

@ -161,8 +161,6 @@ it('should amend method on main request', async ({ page, server }) => {
});
it.describe('post data', () => {
it.fixme(({ isAndroid }) => isAndroid, 'Post data does not work');
it('should amend post data', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
await page.route('**/*', route => {

6
tests/page/page-request-fallback.spec.ts
Просмотреть файл

@ -94,9 +94,7 @@ it('should not chain abort', async ({ page, server }) => {
expect(failed).toBeFalsy();
});
it('should fall back after exception', async ({ page, server, isAndroid }) => {
it.fixme(isAndroid);
it('should fall back after exception', async ({ page, server }) => {
await page.route('**/empty.html', route => {
route.continue();
});
@ -222,8 +220,6 @@ it('should override request url', async ({ page, server }) => {
});
it.describe('post data', () => {
it.fixme(({ isAndroid }) => isAndroid, 'Post data does not work');
it('should amend post data', async ({ page, server }) => {
await page.goto(server.EMPTY_PAGE);
let postData: string;

13
tests/page/page-request-fulfill.spec.ts
Просмотреть файл

@ -121,9 +121,8 @@ it('should allow mocking svg with charset', async ({ page, server, browserName,
expect(await img.screenshot()).toMatchSnapshot('mock-svg.png');
});
it('should work with file path', async ({ page, server, asset, isAndroid, mode }) => {
it('should work with file path', async ({ page, server, asset, mode }) => {
it.skip(mode === 'service');
it.skip(isAndroid);
await page.route('**/*', route => route.fulfill({ contentType: 'shouldBeIgnored', path: asset('pptr.png') }));
await page.evaluate(PREFIX => {
@ -270,9 +269,8 @@ it('should fetch original request and fulfill', async ({ page, server, isElectro
expect(await page.title()).toEqual('Woof-Woof');
});
it('should fulfill with multiple set-cookie', async ({ page, server, isAndroid, isElectron }) => {
it('should fulfill with multiple set-cookie', async ({ page, server, isElectron }) => {
it.fixme(isElectron, 'Electron 14+ is required');
it.fixme(isAndroid);
const cookies = ['a=b', 'c=d'];
await page.route('**/empty.html', async route => {
route.fulfill({
@ -291,8 +289,7 @@ it('should fulfill with multiple set-cookie', async ({ page, server, isAndroid,
expect(await response.headerValue('X-Header-2')).toBe('v2');
});
it('should fulfill with fetch response that has multiple set-cookie', async ({ playwright, page, server, isAndroid }) => {
it.fixme(isAndroid);
it('should fulfill with fetch response that has multiple set-cookie', async ({ playwright, page, server }) => {
server.setRoute('/empty.html', (req, res) => {
res.setHeader('Set-Cookie', ['a=b', 'c=d']);
res.setHeader('Content-Type', 'text/html');
@ -324,9 +321,7 @@ it('headerValue should return set-cookie from intercepted response', async ({ pa
expect(await response.headerValue('Set-Cookie')).toBe('a=b');
});
it('should fulfill with har response', async ({ page, isAndroid, asset }) => {
it.fixme(isAndroid);
it('should fulfill with har response', async ({ page, asset }) => {
const harPath = asset('har-fulfill.har');
const har = JSON.parse(await fs.promises.readFile(harPath, 'utf-8')) as har.HARFile;
await page.route('**/*', async route => {

6
tests/page/page-set-input-files.spec.ts
Просмотреть файл

@ -351,8 +351,7 @@ it('should accept single file', async ({ page, asset }) => {
expect(await page.$eval('input', input => input.files[0].name)).toBe('file-to-upload.txt');
});
it('should detect mime type', async ({ page, server, asset, isAndroid }) => {
it.fixme(isAndroid);
it('should detect mime type', async ({ page, server, asset }) => {
let files: Record<string, formidable.File>;
server.setRoute('/upload', async (req, res) => {
@ -387,8 +386,7 @@ it('should detect mime type', async ({ page, server, asset, isAndroid }) => {
});
// @see https://github.com/microsoft/playwright/issues/4704
it('should not trim big uploaded files', async ({ page, server, asset, isAndroid }) => {
it.fixme(isAndroid);
it('should not trim big uploaded files', async ({ page, server }) => {
let files: Record<string, formidable.File>;
server.setRoute('/upload', async (req, res) => {

3
tests/page/selectors-misc.spec.ts
Просмотреть файл

@ -27,9 +27,8 @@ it('should work for open shadow roots', async ({ page, server }) => {
expect(await page.$$(`data-testid:light=foo`)).toEqual([]);
});
it('should click on links in shadow dom', async ({ page, server, browserName, browserMajorVersion, isAndroid }) => {
it('should click on links in shadow dom', async ({ page, server, browserName, browserMajorVersion }) => {
it.fixme(browserName === 'chromium' && browserMajorVersion < 91, 'Remove when crrev.com/864024 gets to the stable channel');
it.fixme(isAndroid);
await page.goto(server.PREFIX + '/shadow-dom-link.html');
expect(await page.evaluate(() => (window as any).clickCount)).toBe(0);