2021-04-02 02:35:26 +03:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2021-06-07 03:09:53 +03:00
|
|
|
import type { Fixtures } from './test-runner';
|
2021-04-29 21:11:32 +03:00
|
|
|
import type { Browser, BrowserContext, BrowserContextOptions, BrowserType, LaunchOptions, Page } from '../../index';
|
|
|
|
import { removeFolders } from '../../lib/utils/utils';
|
|
|
|
import * as path from 'path';
|
|
|
|
import * as fs from 'fs';
|
|
|
|
import * as os from 'os';
|
|
|
|
import { RemoteServer, RemoteServerOptions } from './remoteServer';
|
2021-05-17 05:58:26 +03:00
|
|
|
import { baseTest, CommonWorkerFixtures } from './baseTest';
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-05-17 05:58:26 +03:00
|
|
|
type PlaywrightWorkerOptions = {
|
|
|
|
executablePath: LaunchOptions['executablePath'];
|
|
|
|
proxy: LaunchOptions['proxy'];
|
|
|
|
args: LaunchOptions['args'];
|
2021-04-29 21:11:32 +03:00
|
|
|
};
|
2021-05-17 05:58:26 +03:00
|
|
|
export type PlaywrightWorkerFixtures = {
|
2021-04-29 21:11:32 +03:00
|
|
|
browserType: BrowserType;
|
|
|
|
browserOptions: LaunchOptions;
|
2021-05-17 05:58:26 +03:00
|
|
|
browser: Browser;
|
|
|
|
browserVersion: string;
|
|
|
|
};
|
|
|
|
type PlaywrightTestOptions = {
|
|
|
|
hasTouch: BrowserContextOptions['hasTouch'];
|
2021-04-29 21:11:32 +03:00
|
|
|
};
|
2021-05-17 05:58:26 +03:00
|
|
|
type PlaywrightTestFixtures = {
|
|
|
|
createUserDataDir: () => Promise<string>;
|
|
|
|
launchPersistent: (options?: Parameters<BrowserType['launchPersistentContext']>[1]) => Promise<{ context: BrowserContext, page: Page }>;
|
|
|
|
startRemoteServer: (options?: RemoteServerOptions) => Promise<RemoteServer>;
|
|
|
|
contextOptions: BrowserContextOptions;
|
|
|
|
contextFactory: (options?: BrowserContextOptions) => Promise<BrowserContext>;
|
|
|
|
context: BrowserContext;
|
|
|
|
page: Page;
|
|
|
|
};
|
|
|
|
export type PlaywrightOptions = PlaywrightWorkerOptions & PlaywrightTestOptions;
|
|
|
|
|
2021-06-07 03:09:53 +03:00
|
|
|
export const playwrightFixtures: Fixtures<PlaywrightTestOptions & PlaywrightTestFixtures, PlaywrightWorkerOptions & PlaywrightWorkerFixtures, {}, CommonWorkerFixtures> = {
|
2021-05-17 05:58:26 +03:00
|
|
|
executablePath: [ undefined, { scope: 'worker' } ],
|
|
|
|
proxy: [ undefined, { scope: 'worker' } ],
|
|
|
|
args: [ undefined, { scope: 'worker' } ],
|
|
|
|
hasTouch: undefined,
|
|
|
|
|
|
|
|
browserType: [async ({ playwright, browserName }, run) => {
|
|
|
|
await run(playwright[browserName]);
|
|
|
|
}, { scope: 'worker' } ],
|
|
|
|
|
2021-08-20 05:09:19 +03:00
|
|
|
browserOptions: [async ({ headless, channel, executablePath, proxy, args }, run) => {
|
2021-05-17 05:58:26 +03:00
|
|
|
await run({
|
|
|
|
headless,
|
|
|
|
channel,
|
|
|
|
executablePath,
|
|
|
|
proxy,
|
|
|
|
args,
|
|
|
|
handleSIGINT: false,
|
|
|
|
});
|
|
|
|
}, { scope: 'worker' } ],
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-05-17 05:58:26 +03:00
|
|
|
browser: [async ({ browserType, browserOptions }, run) => {
|
|
|
|
const browser = await browserType.launch(browserOptions);
|
|
|
|
await run(browser);
|
|
|
|
await browser.close();
|
|
|
|
}, { scope: 'worker' } ],
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-05-17 05:58:26 +03:00
|
|
|
browserVersion: [async ({ browser }, run) => {
|
|
|
|
await run(browser.version());
|
|
|
|
}, { scope: 'worker' } ],
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-05-17 05:58:26 +03:00
|
|
|
createUserDataDir: async ({}, run) => {
|
|
|
|
const dirs: string[] = [];
|
2021-04-29 21:11:32 +03:00
|
|
|
// We do not put user data dir in testOutputPath,
|
|
|
|
// because we do not want to upload them as test result artifacts.
|
|
|
|
//
|
|
|
|
// Additionally, it is impossible to upload user data dir after test run:
|
|
|
|
// - Firefox removes lock file later, presumably from another watchdog process?
|
|
|
|
// - WebKit has circular symlinks that makes CI go crazy.
|
2021-05-17 05:58:26 +03:00
|
|
|
await run(async () => {
|
2021-06-03 19:55:33 +03:00
|
|
|
const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'playwright-test-'));
|
2021-05-17 05:58:26 +03:00
|
|
|
dirs.push(dir);
|
|
|
|
return dir;
|
|
|
|
});
|
|
|
|
await removeFolders(dirs);
|
|
|
|
},
|
|
|
|
|
|
|
|
launchPersistent: async ({ createUserDataDir, browserType, browserOptions }, run) => {
|
|
|
|
let persistentContext: BrowserContext | undefined;
|
|
|
|
await run(async options => {
|
|
|
|
if (persistentContext)
|
|
|
|
throw new Error('can only launch one persitent context');
|
|
|
|
const userDataDir = await createUserDataDir();
|
|
|
|
persistentContext = await browserType.launchPersistentContext(userDataDir, { ...browserOptions, ...options });
|
|
|
|
const page = persistentContext.pages()[0];
|
|
|
|
return { context: persistentContext, page };
|
|
|
|
});
|
|
|
|
if (persistentContext)
|
|
|
|
await persistentContext.close();
|
|
|
|
},
|
|
|
|
|
|
|
|
startRemoteServer: async ({ browserType, browserOptions }, run) => {
|
|
|
|
let remoteServer: RemoteServer | undefined;
|
|
|
|
await run(async options => {
|
|
|
|
if (remoteServer)
|
|
|
|
throw new Error('can only start one remote server');
|
|
|
|
remoteServer = new RemoteServer();
|
|
|
|
await remoteServer._start(browserType, browserOptions, options);
|
|
|
|
return remoteServer;
|
|
|
|
});
|
|
|
|
if (remoteServer)
|
|
|
|
await remoteServer.close();
|
|
|
|
},
|
|
|
|
|
2021-08-20 05:09:19 +03:00
|
|
|
contextOptions: async ({ video, hasTouch }, run, testInfo) => {
|
2021-05-08 01:25:55 +03:00
|
|
|
const debugName = path.relative(testInfo.project.outputDir, testInfo.outputDir).replace(/[\/\\]/g, '-');
|
2021-04-29 21:11:32 +03:00
|
|
|
const contextOptions = {
|
2021-05-17 05:58:26 +03:00
|
|
|
recordVideo: video ? { dir: testInfo.outputPath('') } : undefined,
|
2021-04-29 21:11:32 +03:00
|
|
|
_debugName: debugName,
|
2021-05-17 05:58:26 +03:00
|
|
|
hasTouch,
|
2021-04-29 21:11:32 +03:00
|
|
|
} as BrowserContextOptions;
|
2021-05-17 05:58:26 +03:00
|
|
|
await run(contextOptions);
|
|
|
|
},
|
|
|
|
|
2021-08-20 05:09:19 +03:00
|
|
|
contextFactory: async ({ browser, contextOptions, trace }, run, testInfo) => {
|
2021-05-17 05:58:26 +03:00
|
|
|
const contexts: BrowserContext[] = [];
|
|
|
|
await run(async options => {
|
|
|
|
const context = await browser.newContext({ ...contextOptions, ...options });
|
2021-08-20 05:09:19 +03:00
|
|
|
if (trace)
|
|
|
|
await context.tracing.start({ screenshots: true, snapshots: true });
|
2021-08-05 23:36:47 +03:00
|
|
|
(context as any)._csi = {
|
2021-09-03 23:08:17 +03:00
|
|
|
onApiCall: (stackTrace: any) => {
|
2021-09-10 03:35:31 +03:00
|
|
|
const testInfoImpl = testInfo as any;
|
|
|
|
const existingStep = testInfoImpl._currentSteps().find(step => step.category === 'pw:api' || step.category === 'expect');
|
2021-09-14 04:07:15 +03:00
|
|
|
const newStep = existingStep ? undefined : testInfoImpl._addStep('pw:api', stackTrace.apiName);
|
|
|
|
return (error?: Error) => newStep?.complete(error);
|
2021-08-05 23:36:47 +03:00
|
|
|
},
|
|
|
|
};
|
2021-05-17 05:58:26 +03:00
|
|
|
contexts.push(context);
|
|
|
|
return context;
|
|
|
|
});
|
2021-08-08 01:47:03 +03:00
|
|
|
await Promise.all(contexts.map(async context => {
|
|
|
|
const videos = context.pages().map(p => p.video()).filter(Boolean);
|
2021-08-20 05:09:19 +03:00
|
|
|
if (!(context as any)._closed && trace)
|
|
|
|
await context.tracing.stop({ path: testInfo.outputPath('trace.zip') });
|
2021-08-08 01:47:03 +03:00
|
|
|
await context.close();
|
|
|
|
for (const v of videos) {
|
2021-08-10 11:24:14 +03:00
|
|
|
const videoPath = await v.path().catch(() => null);
|
|
|
|
if (!videoPath)
|
|
|
|
continue;
|
2021-08-08 01:47:03 +03:00
|
|
|
const savedPath = testInfo.outputPath(path.basename(videoPath));
|
|
|
|
await v.saveAs(savedPath);
|
|
|
|
testInfo.attachments.push({ name: 'video', path: savedPath, contentType: 'video/webm' });
|
|
|
|
}
|
|
|
|
}));
|
2021-05-17 05:58:26 +03:00
|
|
|
},
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-05-17 05:58:26 +03:00
|
|
|
context: async ({ contextFactory }, run) => {
|
|
|
|
await run(await contextFactory());
|
|
|
|
},
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-05-17 05:58:26 +03:00
|
|
|
page: async ({ context }, run) => {
|
|
|
|
await run(await context.newPage());
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
const test = baseTest.extend<PlaywrightTestOptions & PlaywrightTestFixtures, PlaywrightWorkerOptions & PlaywrightWorkerFixtures>(playwrightFixtures);
|
|
|
|
export const playwrightTest = test;
|
|
|
|
export const browserTest = test;
|
|
|
|
export const contextTest = test;
|
2021-04-29 21:11:32 +03:00
|
|
|
|
2021-06-07 03:09:53 +03:00
|
|
|
export { expect } from './test-runner';
|