Dwinzo-Beta/dwinzo-sdet
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

screenshot/test_1

Browse Source
This commit is contained in:
ramkumarp
2025-03-27 11:21:02 +00:00
commit 616d466383
470 changed files with 144705 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

283
node_modules/playwright-core/lib/remote/playwrightConnection.js generated vendored Normal file
View File

@@ -0,0 +1,283 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PlaywrightConnection = void 0;
var _socksProxy = require("../server/utils/socksProxy");
var _server = require("../server");
var _android = require("../server/android/android");
var _browser = require("../server/browser");
var _debugControllerDispatcher = require("../server/dispatchers/debugControllerDispatcher");
var _instrumentation = require("../server/instrumentation");
var _assert = require("../utils/isomorphic/assert");
var _debug = require("../server/utils/debug");
var _profiler = require("../server/utils/profiler");
var _utils = require("../utils");
var _debugLogger = require("../server/utils/debugLogger");
/**
* 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.
*/
class PlaywrightConnection {
constructor(lock, clientType, ws, options, preLaunched, id, onClose) {
this._ws = void 0;
this._onClose = void 0;
this._dispatcherConnection = void 0;
this._cleanups = [];
this._id = void 0;
this._disconnected = false;
this._preLaunched = void 0;
this._options = void 0;
this._root = void 0;
this._profileName = void 0;
this._ws = ws;
this._preLaunched = preLaunched;
this._options = options;
options.launchOptions = filterLaunchOptions(options.launchOptions, options.allowFSPaths);
if (clientType === 'reuse-browser' || clientType === 'pre-launched-browser-or-android') (0, _assert.assert)(preLaunched.playwright);
if (clientType === 'pre-launched-browser-or-android') (0, _assert.assert)(preLaunched.browser || preLaunched.androidDevice);
this._onClose = onClose;
this._id = id;
this._profileName = `${new Date().toISOString()}-${clientType}`;
this._dispatcherConnection = new _server.DispatcherConnection();
this._dispatcherConnection.onmessage = async message => {
await lock;
if (ws.readyState !== ws.CLOSING) {
const messageString = JSON.stringify(message);
if (_debugLogger.debugLogger.isEnabled('server:channel')) _debugLogger.debugLogger.log('server:channel', `[${this._id}] ${(0, _utils.monotonicTime)() * 1000} SEND ► ${messageString}`);
if (_debugLogger.debugLogger.isEnabled('server:metadata')) this.logServerMetadata(message, messageString, 'SEND');
ws.send(messageString);
}
};
ws.on('message', async message => {
await lock;
const messageString = Buffer.from(message).toString();
const jsonMessage = JSON.parse(messageString);
if (_debugLogger.debugLogger.isEnabled('server:channel')) _debugLogger.debugLogger.log('server:channel', `[${this._id}] ${(0, _utils.monotonicTime)() * 1000} ◀ RECV ${messageString}`);
if (_debugLogger.debugLogger.isEnabled('server:metadata')) this.logServerMetadata(jsonMessage, messageString, 'RECV');
this._dispatcherConnection.dispatch(jsonMessage);
});
ws.on('close', () => this._onDisconnect());
ws.on('error', error => this._onDisconnect(error));
if (clientType === 'controller') {
this._root = this._initDebugControllerMode();
return;
}
this._root = new _server.RootDispatcher(this._dispatcherConnection, async (scope, options) => {
await (0, _profiler.startProfiling)();
if (clientType === 'reuse-browser') return await this._initReuseBrowsersMode(scope);
if (clientType === 'pre-launched-browser-or-android') return this._preLaunched.browser ? await this._initPreLaunchedBrowserMode(scope) : await this._initPreLaunchedAndroidMode(scope);
if (clientType === 'launch-browser') return await this._initLaunchBrowserMode(scope, options);
throw new Error('Unsupported client type: ' + clientType);
});
}
async _initLaunchBrowserMode(scope, options) {
_debugLogger.debugLogger.log('server', `[${this._id}] engaged launch mode for "${this._options.browserName}"`);
const playwright = (0, _server.createPlaywright)({
sdkLanguage: options.sdkLanguage,
isServer: true
});
const ownedSocksProxy = await this._createOwnedSocksProxy(playwright);
let browserName = this._options.browserName;
if ('bidi' === browserName) {
var _this$_options$launch;
if ((_this$_options$launch = this._options.launchOptions) !== null && _this$_options$launch !== void 0 && (_this$_options$launch = _this$_options$launch.channel) !== null && _this$_options$launch !== void 0 && _this$_options$launch.toLocaleLowerCase().includes('firefox')) browserName = 'bidiFirefox';else browserName = 'bidiChromium';
}
const browser = await playwright[browserName].launch((0, _instrumentation.serverSideCallMetadata)(), this._options.launchOptions);
this._cleanups.push(async () => {
for (const browser of playwright.allBrowsers()) await browser.close({
reason: 'Connection terminated'
});
});
browser.on(_browser.Browser.Events.Disconnected, () => {
// Underlying browser did close for some reason - force disconnect the client.
this.close({
code: 1001,
reason: 'Browser closed'
});
});
return new _server.PlaywrightDispatcher(scope, playwright, ownedSocksProxy, browser);
}
async _initPreLaunchedBrowserMode(scope) {
var _this$_preLaunched$so;
_debugLogger.debugLogger.log('server', `[${this._id}] engaged pre-launched (browser) mode`);
const playwright = this._preLaunched.playwright;
// Note: connected client owns the socks proxy and configures the pattern.
(_this$_preLaunched$so = this._preLaunched.socksProxy) === null || _this$_preLaunched$so === void 0 || _this$_preLaunched$so.setPattern(this._options.socksProxyPattern);
const browser = this._preLaunched.browser;
browser.on(_browser.Browser.Events.Disconnected, () => {
// Underlying browser did close for some reason - force disconnect the client.
this.close({
code: 1001,
reason: 'Browser closed'
});
});
const playwrightDispatcher = new _server.PlaywrightDispatcher(scope, playwright, this._preLaunched.socksProxy, browser);
// In pre-launched mode, keep only the pre-launched browser.
for (const b of playwright.allBrowsers()) {
if (b !== browser) await b.close({
reason: 'Connection terminated'
});
}
this._cleanups.push(() => playwrightDispatcher.cleanup());
return playwrightDispatcher;
}
async _initPreLaunchedAndroidMode(scope) {
_debugLogger.debugLogger.log('server', `[${this._id}] engaged pre-launched (Android) mode`);
const playwright = this._preLaunched.playwright;
const androidDevice = this._preLaunched.androidDevice;
androidDevice.on(_android.AndroidDevice.Events.Close, () => {
// Underlying browser did close for some reason - force disconnect the client.
this.close({
code: 1001,
reason: 'Android device disconnected'
});
});
const playwrightDispatcher = new _server.PlaywrightDispatcher(scope, playwright, undefined, undefined, androidDevice);
this._cleanups.push(() => playwrightDispatcher.cleanup());
return playwrightDispatcher;
}
_initDebugControllerMode() {
_debugLogger.debugLogger.log('server', `[${this._id}] engaged reuse controller mode`);
const playwright = this._preLaunched.playwright;
// Always create new instance based on the reused Playwright instance.
return new _debugControllerDispatcher.DebugControllerDispatcher(this._dispatcherConnection, playwright.debugController);
}
async _initReuseBrowsersMode(scope) {
// Note: reuse browser mode does not support socks proxy, because
// clients come and go, while the browser stays the same.
_debugLogger.debugLogger.log('server', `[${this._id}] engaged reuse browsers mode for ${this._options.browserName}`);
const playwright = this._preLaunched.playwright;
const requestedOptions = launchOptionsHash(this._options.launchOptions);
let browser = playwright.allBrowsers().find(b => {
if (b.options.name !== this._options.browserName) return false;
const existingOptions = launchOptionsHash(b.options.originalLaunchOptions);
return existingOptions === requestedOptions;
});
// Close remaining browsers of this type+channel. Keep different browser types for the speed.
for (const b of playwright.allBrowsers()) {
if (b === browser) continue;
if (b.options.name === this._options.browserName && b.options.channel === this._options.launchOptions.channel) await b.close({
reason: 'Connection terminated'
});
}
if (!browser) {
browser = await playwright[this._options.browserName || 'chromium'].launch((0, _instrumentation.serverSideCallMetadata)(), {
...this._options.launchOptions,
headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS
});
browser.on(_browser.Browser.Events.Disconnected, () => {
// Underlying browser did close for some reason - force disconnect the client.
this.close({
code: 1001,
reason: 'Browser closed'
});
});
}
this._cleanups.push(async () => {
// Don't close the pages so that user could debug them,
// but close all the empty browsers and contexts to clean up.
for (const browser of playwright.allBrowsers()) {
for (const context of browser.contexts()) {
if (!context.pages().length) await context.close({
reason: 'Connection terminated'
});else await context.stopPendingOperations('Connection closed');
}
if (!browser.contexts()) await browser.close({
reason: 'Connection terminated'
});
}
});
const playwrightDispatcher = new _server.PlaywrightDispatcher(scope, playwright, undefined, browser);
return playwrightDispatcher;
}
async _createOwnedSocksProxy(playwright) {
if (!this._options.socksProxyPattern) return;
const socksProxy = new _socksProxy.SocksProxy();
socksProxy.setPattern(this._options.socksProxyPattern);
playwright.options.socksProxyPort = await socksProxy.listen(0);
_debugLogger.debugLogger.log('server', `[${this._id}] started socks proxy on port ${playwright.options.socksProxyPort}`);
this._cleanups.push(() => socksProxy.close());
return socksProxy;
}
async _onDisconnect(error) {
this._disconnected = true;
_debugLogger.debugLogger.log('server', `[${this._id}] disconnected. error: ${error}`);
this._root._dispose();
_debugLogger.debugLogger.log('server', `[${this._id}] starting cleanup`);
for (const cleanup of this._cleanups) await cleanup().catch(() => {});
await (0, _profiler.stopProfiling)(this._profileName);
this._onClose();
_debugLogger.debugLogger.log('server', `[${this._id}] finished cleanup`);
}
logServerMetadata(message, messageString, direction) {
const serverLogMetadata = {
wallTime: Date.now(),
id: message.id,
guid: message.guid,
method: message.method,
payloadSizeInBytes: Buffer.byteLength(messageString, 'utf-8')
};
_debugLogger.debugLogger.log('server:metadata', (direction === 'SEND' ? 'SEND ► ' : '◀ RECV ') + JSON.stringify(serverLogMetadata));
}
async close(reason) {
if (this._disconnected) return;
_debugLogger.debugLogger.log('server', `[${this._id}] force closing connection: ${(reason === null || reason === void 0 ? void 0 : reason.reason) || ''} (${(reason === null || reason === void 0 ? void 0 : reason.code) || 0})`);
try {
this._ws.close(reason === null || reason === void 0 ? void 0 : reason.code, reason === null || reason === void 0 ? void 0 : reason.reason);
} catch (e) {}
}
}
exports.PlaywrightConnection = PlaywrightConnection;
function launchOptionsHash(options) {
const copy = {
...options
};
for (const k of Object.keys(copy)) {
const key = k;
if (copy[key] === defaultLaunchOptions[key]) delete copy[key];
}
for (const key of optionsThatAllowBrowserReuse) delete copy[key];
return JSON.stringify(copy);
}
function filterLaunchOptions(options, allowFSPaths) {
return {
channel: options.channel,
args: options.args,
ignoreAllDefaultArgs: options.ignoreAllDefaultArgs,
ignoreDefaultArgs: options.ignoreDefaultArgs,
timeout: options.timeout,
headless: options.headless,
proxy: options.proxy,
chromiumSandbox: options.chromiumSandbox,
firefoxUserPrefs: options.firefoxUserPrefs,
slowMo: options.slowMo,
executablePath: (0, _debug.isUnderTest)() || allowFSPaths ? options.executablePath : undefined,
downloadsPath: allowFSPaths ? options.downloadsPath : undefined
};
}
const defaultLaunchOptions = {
ignoreAllDefaultArgs: false,
handleSIGINT: false,
handleSIGTERM: false,
handleSIGHUP: false,
headless: true,
devtools: false
};
const optionsThatAllowBrowserReuse = ['headless', 'tracesDir'];

124
node_modules/playwright-core/lib/remote/playwrightServer.js generated vendored Normal file
View File

@@ -0,0 +1,124 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PlaywrightServer = void 0;
var _playwrightConnection = require("./playwrightConnection");
var _playwright = require("../server/playwright");
var _debugLogger = require("../server/utils/debugLogger");
var _semaphore = require("../utils/isomorphic/semaphore");
var _wsServer = require("../server/utils/wsServer");
var _ascii = require("../server/utils/ascii");
var _userAgent = require("../server/utils/userAgent");
/**
* 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.
*/
class PlaywrightServer {
constructor(options) {
this._preLaunchedPlaywright = void 0;
this._options = void 0;
this._wsServer = void 0;
this._options = options;
if (options.preLaunchedBrowser) this._preLaunchedPlaywright = options.preLaunchedBrowser.attribution.playwright;
if (options.preLaunchedAndroidDevice) this._preLaunchedPlaywright = options.preLaunchedAndroidDevice._android.attribution.playwright;
const browserSemaphore = new _semaphore.Semaphore(this._options.maxConnections);
const controllerSemaphore = new _semaphore.Semaphore(1);
const reuseBrowserSemaphore = new _semaphore.Semaphore(1);
this._wsServer = new _wsServer.WSServer({
onUpgrade: (request, socket) => {
const uaError = userAgentVersionMatchesErrorMessage(request.headers['user-agent'] || '');
if (uaError) return {
error: `HTTP/${request.httpVersion} 428 Precondition Required\r\n\r\n${uaError}`
};
},
onHeaders: headers => {
if (process.env.PWTEST_SERVER_WS_HEADERS) headers.push(process.env.PWTEST_SERVER_WS_HEADERS);
},
onConnection: (request, url, ws, id) => {
const browserHeader = request.headers['x-playwright-browser'];
const browserName = url.searchParams.get('browser') || (Array.isArray(browserHeader) ? browserHeader[0] : browserHeader) || null;
const proxyHeader = request.headers['x-playwright-proxy'];
const proxyValue = url.searchParams.get('proxy') || (Array.isArray(proxyHeader) ? proxyHeader[0] : proxyHeader);
const launchOptionsHeader = request.headers['x-playwright-launch-options'] || '';
const launchOptionsHeaderValue = Array.isArray(launchOptionsHeader) ? launchOptionsHeader[0] : launchOptionsHeader;
const launchOptionsParam = url.searchParams.get('launch-options');
let launchOptions = {};
try {
launchOptions = JSON.parse(launchOptionsParam || launchOptionsHeaderValue);
} catch (e) {}
// Instantiate playwright for the extension modes.
const isExtension = this._options.mode === 'extension';
if (isExtension) {
if (!this._preLaunchedPlaywright) this._preLaunchedPlaywright = (0, _playwright.createPlaywright)({
sdkLanguage: 'javascript',
isServer: true
});
}
let clientType = 'launch-browser';
let semaphore = browserSemaphore;
if (isExtension && url.searchParams.has('debug-controller')) {
clientType = 'controller';
semaphore = controllerSemaphore;
} else if (isExtension) {
clientType = 'reuse-browser';
semaphore = reuseBrowserSemaphore;
} else if (this._options.mode === 'launchServer') {
clientType = 'pre-launched-browser-or-android';
semaphore = browserSemaphore;
}
return new _playwrightConnection.PlaywrightConnection(semaphore.acquire(), clientType, ws, {
socksProxyPattern: proxyValue,
browserName,
launchOptions,
allowFSPaths: this._options.mode === 'extension'
}, {
playwright: this._preLaunchedPlaywright,
browser: this._options.preLaunchedBrowser,
androidDevice: this._options.preLaunchedAndroidDevice,
socksProxy: this._options.preLaunchedSocksProxy
}, id, () => semaphore.release());
},
onClose: async () => {
_debugLogger.debugLogger.log('server', 'closing browsers');
if (this._preLaunchedPlaywright) await Promise.all(this._preLaunchedPlaywright.allBrowsers().map(browser => browser.close({
reason: 'Playwright Server stopped'
})));
_debugLogger.debugLogger.log('server', 'closed browsers');
}
});
}
async listen(port = 0, hostname) {
return this._wsServer.listen(port, hostname, this._options.path);
}
async close() {
await this._wsServer.close();
}
}
exports.PlaywrightServer = PlaywrightServer;
function userAgentVersionMatchesErrorMessage(userAgent) {
const match = userAgent.match(/^Playwright\/(\d+\.\d+\.\d+)/);
if (!match) {
// Cannot parse user agent - be lax.
return;
}
const received = match[1].split('.').slice(0, 2).join('.');
const expected = (0, _userAgent.getPlaywrightVersion)(true);
if (received !== expected) {
return (0, _ascii.wrapInASCIIBox)([`Playwright version mismatch:`, ` - server version: v${expected}`, ` - client version: v${received}`, ``, `If you are using VSCode extension, restart VSCode.`, ``, `If you are connecting to a remote service,`, `keep your local Playwright version in sync`, `with the remote service version.`, ``, `<3 Playwright Team`].join('\n'), 1);
}
}