Best JavaScript code snippet using playwright-internal
temp.js
Source: temp.js
...994 Object.defineProperty(BoardController.prototype, 'commonUi', {995 enumerable: false,996 value: function (options) {997 if (this.loading)998 return this.lastPromise = this._awaitPromise(this.lastPromise);999 this.lastPromise = this.__commonUi(options);1000 return this.lastPromise;1001 }1002 });1003 Object.defineProperty(BoardController.prototype, '__commonUi', {1004 enumerable: false,1005 value: (typeof regeneratorRuntime != 'object' ? core.VW.Ecma2015.Parser : undefined, function callee$0$0($_ref0) {1006 var noredirect, userScope, usuario;1007 return regeneratorRuntime.async(function callee$0$0$(context$1$0) {1008 while (1)1009 switch (context$1$0.prev = context$1$0.next) {1010 case 0:1011 noredirect = $_ref0 ? $_ref0.noredirect : undefined;1012 this.loading = true;...
destructible.js
Source: destructible.js
...540 // Monitor our new destructible as child of this destructible.541 const scrammable = new Future542 const node = this._scrammable.push(scrammable)543 try {544 await this._awaitPromise(destructible.promise, wait, {}).catch(noop)545 } finally {546 // TODO Convince yourself that it doens't matter if you call a547 // scrammable before you call `_complete`.548 List.unlink(scram)549 List.unlink(node)550 scrammable.resolve()551 }552 }553 _await (method, vargs) {554 if (!(this._destructing && method == 'ephemeral')) {555 this.operational()556 }557 const options = {558 $trace: typeof vargs[0] == 'function' ? vargs.shift() : null,559 timeout: typeof vargs[0] == 'number' ? vargs.shift() : this._timeout,560 ...(typeof vargs[0] == 'object' ? vargs.shift() : {}),561 id: vargs.shift()562 }563 if (options.$trace != null) {564 Interrupt.assertTracer(options.$trace)565 }566 assert(typeof options.id == 'string')567 const wait = this._waiting.push({ method, id: options.id })568 //569 // If a function, invoke it it and await the result as a promise, if no570 // arguments it is a sub-destructible, treat anything else as a promise,571 // it will get wrapped by `async` if it is not a promise already.572 //573 if (typeof vargs[0] == 'function') {574 return new Future(this._awaitPromise(vargs.shift()(), wait, { $trace: options.$trace }))575 } else if (vargs.length == 0) {576 // Construct our destructible with the options, then poke into it to577 // make it a sub-destructible.578 const destructible = new Destructible(options, options.id)579 destructible._tracer = this._tracer580 destructible.path = this.path.concat(options.id)581 // If the caller provided a countdown, we are a deferred582 // destructible.583 const deferrable = options.countdown != null584 const countdown = deferrable ? options.countdown : 0585 Destructible.Error.assert(Number.isInteger(countdown) && countdown >= 0, 'INVALID_COUNTDOWN', { _countdown: countdown })586 destructible._countdown = countdown587 destructible.deferrable = deferrable588 // Inherit the instance symbol, common to the entire destructible589 // tree.590 Object.defineProperty(destructible._properties, 'instance', Object.getOwnPropertyDescriptor(this._properties, 'instance'))591 // Set error isolation. Sub-destructibles created during `destruct`592 // are error isolated.593 if (! options.isolated && ! this._isolation.errored) {594 destructible._isolation = this._isolation595 }596 // Are we ephemeral? If so we get our own progress marker.597 destructible._ephemeral = method == 'ephemeral'598 if (destructible._ephemeral) {599 destructible._progress = [ true ]600 }601 //602 // Parent down to leaf destructor path. Destructors run603 // synchronously so all the associated state is set atomically.604 //605 // Destroy the child destructible when we are destroyed. Becasue606 // this destructible is destroyed, it or an ancestor will run a607 // shutdown timer and the child will defer to that shutdown timer.608 //609 // Even if the child is deferrable, when it destructs it is not610 // going to run its own shutdown timer so we tell it that it is no611 // longer ephemeral. Truely, it's state has switched from ephemeral612 // for durable because it will no longer be able to shutdown before613 // the parent shuts down because the parent has already shutdown.614 //615 // We do not destroy deferrables with an outstanding countdown.616 // Asking if the child's isolation is errored is akin to aksing if617 // the child is a memember of the parent's isolation. Think about618 // it.619 //620 // **TODO** Wait? We are destructing. Destruction stops at621 // deferrable boundaries not error isolation boundaries. The child622 // is still destroyed, it is just not errored.623 //624 // Gotta think use case. Database service. Server service errors so625 // all of them are panicing, shutting down as hard as possible, but626 // the database service still can perform its orderly shutdown.627 //628 // But, if the boundary is both deferrable and isolated, we don't629 // destroy it on panic.630 //631 // Ergo, if we do not destroy the child for any reason, we will632 // destory the child if we panic and the child is a member of our633 // isolation.634 //635 const downward = this.destruct(() => {636 destructible._ephemeral = false637 destructible._progress = this._progress638 if (destructible._countdown == 0 || destructible._isolation.errored) {639 this._tracer.push({640 method: 'downward',641 errored: this._isolation.errored,642 path: destructible.path643 })644 destructible._countdown = 0645 destructible._destroy()646 } else if (destructible._isolation === this._isolation) {647 const panic = this.panic(() => {648 this._tracer.push({649 method: 'panic',650 errored: this._isolation.errored,651 path: destructible.path652 })653 destructible._countdown = 0654 destructible._destroy()655 })656 destructible._cleanup.push(() => this.clear(panic))657 }658 })659 //660 // Child up to parent destructor path.661 // If we encounter an error after destruction we want to be sure to662 // destroy the sub-destructible if it is not isolated.663 // Clear the downward destructor. If the sub-destructible is durable664 // or errored we propagate the destruction.665 // If the sub-destructible is ephemeral we register a new destructor666 // that will tell the ephemeral to surrender its scram timer and667 // allow the parent ephemeral to oversee the scram. When the timer668 // wakes it will check ephemeral before it checks progress.669 // **TODO** Is there a progress/ephemeral race? Can we set670 // destructible while at the same time calling scram for the last671 // time so that the destructible goes into wait-on-parent-scram when672 // the parent has already exited? (Doubtful. Tired.)673 // If the child is not in our isolation and it panics, we want to674 // panic. Errors and panics propagate upward.675 // If the child is not in our isolation we do not propagate our676 // panic downward. If it is in our isolation it will share our677 // panic.678 //679 destructible.destruct(() => {680 this.clear(downward)681 if (destructible._ephemeral && ! destructible._isolation.errored) {682 const destruct = this.destruct(() => {683 destructible._ephemeral = false684 destructible._progress = this._progress685 destructible._timer.resolve()686 })687 destructible._cleanup.push(() => this.clear(destruct))688 if (this._isolation !== destructible._isolation) {689 const panic = destructible.panic(() => {690 this._isolation.errored = true691 while (this._isolation.panic.length != 0) {692 const panic = this._isolation.panic.shift()693 while (! panic.empty) {694 panic.shift()()695 }696 }697 })698 destructible._cleanup.push(() => this.clear(panic))699 }700 } else {701 this._isolation.errored = this._isolation.errored || destructible._isolation.errored702 if (! this.destroyed) {703 if (! destructible._ephemeral && ! destructible._isolation.errored) {704 this._isolation.errored = true705 this._errors.push(new Destructible.Error({ $trace: options.$trace }, 'DURABLE', wait.value))706 }707 this._tracer.push({708 method: 'upward',709 errored: this._isolation.errored,710 path: this.path711 })712 this._countdown = 0713 this._destroy()714 }715 }716 })717 // Scram the child destructible if we are scrammed. Cancel our scram718 // forwarding if the child's `_scrams` unlatches. (A `Destructible`719 // will unlatch`_scrams` when it completes normally and no scram is720 // necessary.) Note that we can't use `Promise`s because `then` is721 // not cancellable, but `Signal.wait()` is. If we used722 // `Promise.then`, then a long-running, like a server, would have an723 // ever growing list of callbacks for a short-term child, like a724 // socket connection.725 // Propagate scram cancelling propagation if child exits.726 const scram = this._scrams.push(() => {727 destructible._scram()728 })729 // This is added at a late date to propagate the progress flag.730 // Until now, all parent/child communication was done through731 // generalized structures so that the parent or child was just732 // another consumer of child or parent services respectively.733 // Temptation is to rethink whether this should be the case or if734 // more parent/child interation should be explicit, but rather than735 // give it a lot of thought, I'm going to assume that if I did, I'd736 // realize that this is the way it's supposed to be.737 // I now depend on this to determine if two destructibles are part738 // of the same stage.739 destructible._parent = this740 this._awaitScrammable(destructible, wait, scram)741 return destructible742 } else {743 return new Future(this._awaitPromise(vargs.shift(), wait, { $trace: options.$trace }))744 }745 }746 progress () {747 this._progress[0] = true748 }749 durable (...vargs) {750 this.durables++751 return this._await('durable', vargs)752 }753 // `async ephemeral(id, [ Promise ])` — Start a strand that does not754 // last the lifetime of the `Destructible`. Only if the `Promise` rejects do755 // we perform an orderly shutdown of the `Destructible`. No exception is756 // raised if the `Promise` of strand rejects.757 //...
_destructible.js
Source: _destructible.js
...411 // Monitor our new destructible as child of this destructible.412 const scrammable = {}413 this._scrammable.push(new Promise(resolve => scrammable.resolve = resolve))414 try {415 await this._awaitPromise(destructible.destructed, wait, [])416 } finally {417 // TODO Much better as a linked list, right? `_scrame` may have418 // shifted scram, maybe it should just `for` over them? No, bad419 // because here we're splicing. A linked list is so much better.420 //421 // TODO Convince yourself that it doens't matter if you call a422 // scrammable before you call `_complete`.423 const index = this._scrams.indexOf(scram)424 if (~index) {425 this._scrams.splice(index, 1)426 }427 this._scrammable.splice(this._scrammable.indexOf(scrammable), 1)428 scrammable.resolve.call()429 }430 }431 // To implement scrammable, it seemed that we want to make the last argument432 // the scram function instead of a destructor, which is never all that433 // pleasant to look at anyway, but then we need to have a major version bump434 // because it breaks the interface in a way that is hard to see.435 //436 // The scramability of a `Promise` is a property of the promise, while the437 // destructibility is more a property of the desctructible. The438 // implementation as it stands points in this direction and I'm not going439 // back to rethink it all. Software as Plinko.440 //441 _await (method, key, vargs) {442 if (this.destroyed) {443 throw new Destructible.Rescuable('destroyed')444 }445 const wait = { method, key }446 this.waiting.push(wait)447 // Ephemeral destructible children can set a scram timeout.448 if (typeof vargs[0] == 'function') {449 //const promise = async function () { return await vargs.shift()() } ()450 return this._awaitPromise(vargs.shift()(), wait, vargs)451 } else if (vargs.length == 0) {452 // Ephemeral sub-destructibles can have their own timeout and scram453 // timer, durable sub-destructibles are scrammed by their root.454 //assert(typeof vargs[0] != 'number')455 // Create the child destructible.456 //assert(typeof this._timeout == 'number' && this._timeout != Infinity)457 const destructible = new Destructible(this._timeout, key)458 // Destroy the child destructible when we are destroyed.459 const destruct = this.destruct(() => {460 destructible._ephemeral = false461 destructible._destroy()462 })463 if (method == 'ephemeral') {464 destructible._ephemeral = true465 }466 // Propagate destruction on error. Recall that we need to send this467 // message up though our alternate route, we can't wait on the468 // promise of a sub-destructible to complete and propagate the469 // returned error. Why do we have scram if we can rely on that470 // return? We need a separate `_errored` boolean, we can't just471 // check `_errored.length` because of scram, and because we have472 // some objects that only shutdown from a user function (Conduit,473 // Turnstile, Fracture) so they're going to need to be scrammed, we474 // kind of want them to be scrammed, or else the user has to think475 // hard about the difference between ordered shutdown and abnormal476 // shutdown.477 destructible.destruct(() => {478 this.clear(destruct)479 if (method == 'durable' || destructible._errored) {480 this._errored = this._errored || destructible._errored481 this._destroy()482 }483 })484 // Scram the child destructible if we are scrammed. Cancel our scram485 // forwarding if the child's `_scrams` unlatches. (A `Destructible`486 // will unlatch`_scrams` when it completes normally and no scram is487 // necessary.) Note that we can't use `Promise`s because `then` is488 // not cancellable, but `Signal.wait()` is. If we used489 // `Promise.then`, then a long-running, like a server, would have an490 // ever growing list of callbacks for a short-term child, like a491 // socket connection.492 // Propagate scram cancelling propagation if child exits.493 const scram = () => destructible._scram()494 this._scrams.push(scram)495 // This is added at a late date to propagate the working flag. Until496 // now, all parent/child communication was done through generalized497 // structures so that the parent or child was just another consumer498 // of child or parent services respectively. Temptation is to499 // rethink whether this should be the case or if more parent/child500 // interation should be explicit, but rather than give it a lof501 // thought, I'm going to assume that if I did, I'd realize that this502 // is the way it's supposed to be.503 destructible._parent = this504 this._awaitScrammable(destructible, wait, scram)505 return destructible506 } else {507 return this._awaitPromise(vargs.shift(), wait, vargs)508 }509 }510 working () {511 if (this.destroyed) {512 this._working = true513 if (this._parent != null) {514 this._parent.working()515 }516 }517 }518 // Launch an operation that lasts the lifetime of the `Destructible`. When519 // the promise resolves or rejects we perform an orderly shutdown of the520 // `Destructible`.521 //...
Runtime.js
Source: Runtime.js
...189 for (const tearDown of this._eventListeners)190 tearDown.call(null);191 this._eventListeners = [];192 }193 async _awaitPromise(executionContext, obj, exceptionDetails = {}) {194 if (obj.promiseState === 'fulfilled')195 return {success: true, obj: obj.promiseValue};196 if (obj.promiseState === 'rejected') {197 const global = executionContext._global;198 exceptionDetails.text = global.executeInGlobalWithBindings('e.message', {e: obj.promiseReason}).return;199 exceptionDetails.stack = global.executeInGlobalWithBindings('e.stack', {e: obj.promiseReason}).return;200 return {success: false, obj: null};201 }202 let resolve, reject;203 const promise = new Promise((a, b) => {204 resolve = a;205 reject = b;206 });207 this._pendingPromises.set(obj.promiseID, {resolve, reject, executionContext, exceptionDetails});208 if (this._pendingPromises.size === 1)209 this._debugger.onPromiseSettled = this._onPromiseSettled.bind(this);210 return await promise;211 }212 _onPromiseSettled(obj) {213 const pendingPromise = this._pendingPromises.get(obj.promiseID);214 if (!pendingPromise)215 return;216 this._pendingPromises.delete(obj.promiseID);217 if (!this._pendingPromises.size)218 this._debugger.onPromiseSettled = undefined;219 if (obj.promiseState === 'fulfilled') {220 pendingPromise.resolve({success: true, obj: obj.promiseValue});221 return;222 };223 const global = pendingPromise.executionContext._global;224 pendingPromise.exceptionDetails.text = global.executeInGlobalWithBindings('e.message', {e: obj.promiseReason}).return;225 pendingPromise.exceptionDetails.stack = global.executeInGlobalWithBindings('e.stack', {e: obj.promiseReason}).return;226 pendingPromise.resolve({success: false, obj: null});227 }228 createExecutionContext(domWindow, contextGlobal, auxData) {229 // Note: domWindow is null for workers.230 const context = new ExecutionContext(this, domWindow, contextGlobal, this._debugger.addDebuggee(contextGlobal), auxData);231 this._executionContexts.set(context._id, context);232 if (domWindow)233 this._windowToExecutionContext.set(domWindow, context);234 emitEvent(this.events.onExecutionContextCreated, context);235 return context;236 }237 findExecutionContext(executionContextId) {238 const executionContext = this._executionContexts.get(executionContextId);239 if (!executionContext)240 throw new Error('Failed to find execution context with id = ' + executionContextId);241 return executionContext;242 }243 destroyExecutionContext(destroyedContext) {244 for (const [promiseID, {reject, executionContext}] of this._pendingPromises) {245 if (executionContext === destroyedContext) {246 reject(new Error('Execution context was destroyed!'));247 this._pendingPromises.delete(promiseID);248 }249 }250 if (!this._pendingPromises.size)251 this._debugger.onPromiseSettled = undefined;252 this._debugger.removeDebuggee(destroyedContext._contextGlobal);253 this._executionContexts.delete(destroyedContext._id);254 if (destroyedContext._domWindow)255 this._windowToExecutionContext.delete(destroyedContext._domWindow);256 emitEvent(this.events.onExecutionContextDestroyed, destroyedContext);257 }258}259class ExecutionContext {260 constructor(runtime, domWindow, contextGlobal, global, auxData) {261 this._runtime = runtime;262 this._domWindow = domWindow;263 this._contextGlobal = contextGlobal;264 this._global = global;265 this._remoteObjects = new Map();266 this._id = generateId();267 this._auxData = auxData;268 this._jsonStringifyObject = this._global.executeInGlobal(`((stringify, dateProto, object) => {269 const oldToJson = dateProto.toJSON;270 dateProto.toJSON = undefined;271 let hasSymbol = false;272 const result = stringify(object, (key, value) => {273 if (typeof value === 'symbol')274 hasSymbol = true;275 return value;276 });277 dateProto.toJSON = oldToJson;278 return hasSymbol ? undefined : result;279 }).bind(null, JSON.stringify.bind(JSON), Date.prototype)`).return;280 }281 id() {282 return this._id;283 }284 auxData() {285 return this._auxData;286 }287 async evaluateScript(script, exceptionDetails = {}) {288 const userInputHelper = this._domWindow ? this._domWindow.windowUtils.setHandlingUserInput(true) : null;289 if (this._domWindow && this._domWindow.document)290 this._domWindow.document.notifyUserGestureActivation();291 let {success, obj} = this._getResult(this._global.executeInGlobal(script), exceptionDetails);292 userInputHelper && userInputHelper.destruct();293 if (!success)294 return null;295 if (obj && obj.isPromise) {296 const awaitResult = await this._runtime._awaitPromise(this, obj, exceptionDetails);297 if (!awaitResult.success)298 return null;299 obj = awaitResult.obj;300 }301 return this._createRemoteObject(obj);302 }303 async evaluateFunction(functionText, args, exceptionDetails = {}) {304 const funEvaluation = this._getResult(this._global.executeInGlobal('(' + functionText + ')'), exceptionDetails);305 if (!funEvaluation.success)306 return null;307 if (!funEvaluation.obj.callable)308 throw new Error('functionText does not evaluate to a function!');309 args = args.map(arg => {310 if (arg.objectId) {311 if (!this._remoteObjects.has(arg.objectId))312 throw new Error('Cannot find object with id = ' + arg.objectId);313 return this._remoteObjects.get(arg.objectId);314 }315 switch (arg.unserializableValue) {316 case 'Infinity': return Infinity;317 case '-Infinity': return -Infinity;318 case '-0': return -0;319 case 'NaN': return NaN;320 default: return this._toDebugger(arg.value);321 }322 });323 const userInputHelper = this._domWindow ? this._domWindow.windowUtils.setHandlingUserInput(true) : null;324 if (this._domWindow && this._domWindow.document)325 this._domWindow.document.notifyUserGestureActivation();326 let {success, obj} = this._getResult(funEvaluation.obj.apply(null, args), exceptionDetails);327 userInputHelper && userInputHelper.destruct();328 if (!success)329 return null;330 if (obj && obj.isPromise) {331 const awaitResult = await this._runtime._awaitPromise(this, obj, exceptionDetails);332 if (!awaitResult.success)333 return null;334 obj = awaitResult.obj;335 }336 return this._createRemoteObject(obj);337 }338 unsafeObject(objectId) {339 if (!this._remoteObjects.has(objectId))340 return;341 return { object: this._remoteObjects.get(objectId).unsafeDereference() };342 }343 rawValueToRemoteObject(rawValue) {344 const debuggerObj = this._global.makeDebuggeeValue(rawValue);345 return this._createRemoteObject(debuggerObj);...
RuntimeAgent.js
Source: RuntimeAgent.js
...11 this._debugger = new Debugger();12 this._pendingPromises = new Map();13 }14 dispose() {}15 async _awaitPromise(executionContext, obj, exceptionDetails = {}) {16 if (obj.promiseState === 'fulfilled')17 return {success: true, obj: obj.promiseValue};18 if (obj.promiseState === 'rejected') {19 const global = executionContext._global;20 exceptionDetails.text = global.executeInGlobalWithBindings('e.message', {e: obj.promiseReason}).return;21 exceptionDetails.stack = global.executeInGlobalWithBindings('e.stack', {e: obj.promiseReason}).return;22 return {success: false, obj: null};23 }24 let resolve, reject;25 const promise = new Promise((a, b) => {26 resolve = a;27 reject = b;28 });29 this._pendingPromises.set(obj.promiseID, {resolve, reject, executionContext, exceptionDetails});30 if (this._pendingPromises.size === 1)31 this._debugger.onPromiseSettled = this._onPromiseSettled.bind(this);32 return await promise;33 }34 _onPromiseSettled(obj) {35 const pendingPromise = this._pendingPromises.get(obj.promiseID);36 if (!pendingPromise)37 return;38 this._pendingPromises.delete(obj.promiseID);39 if (!this._pendingPromises.size)40 this._debugger.onPromiseSettled = undefined;41 if (obj.promiseState === 'fulfilled') {42 pendingPromise.resolve({success: true, obj: obj.promiseValue});43 return;44 };45 const global = pendingPromise.executionContext._global;46 pendingPromise.exceptionDetails.text = global.executeInGlobalWithBindings('e.message', {e: obj.promiseReason}).return;47 pendingPromise.exceptionDetails.stack = global.executeInGlobalWithBindings('e.stack', {e: obj.promiseReason}).return;48 pendingPromise.resolve({success: false, obj: null});49 }50 createExecutionContext(domWindow) {51 return new ExecutionContext(this, domWindow, this._debugger.addDebuggee(domWindow));52 }53 destroyExecutionContext(destroyedContext) {54 for (const [promiseID, {reject, executionContext}] of this._pendingPromises) {55 if (executionContext === destroyedContext) {56 reject(new Error('Execution context was destroyed!'));57 this._pendingPromises.delete(promiseID);58 }59 }60 if (!this._pendingPromises.size)61 this._debugger.onPromiseSettled = undefined;62 this._debugger.removeDebuggee(destroyedContext._domWindow);63 }64}65class ExecutionContext {66 constructor(runtime, DOMWindow, global) {67 this._runtime = runtime;68 this._domWindow = DOMWindow;69 this._global = global;70 this._remoteObjects = new Map();71 }72 async evaluateScript(script, exceptionDetails = {}) {73 const userInputHelper = this._domWindow.windowUtils.setHandlingUserInput(true);74 let {success, obj} = this._getResult(this._global.executeInGlobal(script), exceptionDetails);75 userInputHelper.destruct();76 if (!success)77 return null;78 if (obj && obj.isPromise) {79 const awaitResult = await this._runtime._awaitPromise(this, obj, exceptionDetails);80 if (!awaitResult.success)81 return null;82 obj = awaitResult.obj;83 }84 return this._createRemoteObject(obj);85 }86 async evaluateFunction(functionText, args, exceptionDetails = {}) {87 const funEvaluation = this._getResult(this._global.executeInGlobal('(' + functionText + ')'), exceptionDetails);88 if (!funEvaluation.success)89 return null;90 if (!funEvaluation.obj.callable)91 throw new Error('functionText does not evaluate to a function!');92 args = args.map(arg => {93 if (arg.objectId) {94 if (!this._remoteObjects.has(arg.objectId))95 throw new Error('Cannot find object with id = ' + arg.objectId);96 return this._remoteObjects.get(arg.objectId);97 }98 switch (arg.unserializableValue) {99 case 'Infinity': return Infinity;100 case '-Infinity': return -Infinity;101 case '-0': return -0;102 case 'NaN': return NaN;103 default: return this._toDebugger(arg.value);104 }105 });106 const userInputHelper = this._domWindow.windowUtils.setHandlingUserInput(true);107 let {success, obj} = this._getResult(funEvaluation.obj.apply(null, args), exceptionDetails);108 userInputHelper.destruct();109 if (!success)110 return null;111 if (obj && obj.isPromise) {112 const awaitResult = await this._runtime._awaitPromise(this, obj, exceptionDetails);113 if (!awaitResult.success)114 return null;115 obj = awaitResult.obj;116 }117 return this._createRemoteObject(obj);118 }119 unsafeObject(objectId) {120 if (!this._remoteObjects.has(objectId))121 throw new Error('Cannot find object with id = ' + objectId);122 return this._remoteObjects.get(objectId).unsafeDereference();123 }124 rawValueToRemoteObject(rawValue) {125 const debuggerObj = this._global.makeDebuggeeValue(rawValue);126 return this._createRemoteObject(debuggerObj);...
Throttler.js
Source: Throttler.js
...56 _clearTimer() {57 Timer.clear(this.timer);58 this.timer = null;59 }60 async _awaitPromise() {61 if(this.waitFor && this.waitFor instanceof Promise) {62 await this.waitFor;63 this.waitFor = null;64 }65 }66 /**67 * Removes the top action from the Throttler's queue if any is present, and executes it with the correct binding context.68 * @returns {void}69 * @private70 */71 async _executeTopAction() {72 if(this.waitFor && this.waitFor instanceof Promise) {73 return;74 }75 let action = this.queue.shift();76 if (action && typeof action === 'function') {77 let result = action.call(this.actionContext);78 this.waitFor = result instanceof Promise ? result : null;79 }80 if (!this.queue.length) {81 this._clearTimer();82 } else {83 this._clearTimer();84 await this._awaitPromise();85 this._setTimer();86 }87 }...
Using AI Code Generation
1const { _awaitPromise } = require('playwright/lib/helper');2const { chromium } = require('playwright');3(async () => {4 const browser = await chromium.launch();5 const page = await browser.newPage();6 console.log(await _awaitPromise(page.title()));7 await browser.close();8})();9const { chromium } = require('playwright');10(async () => {11 const browser = await chromium.launch();12 const page = await browser.newPage();13 console.log(await page.title());14 await browser.close();15})();16const { chromium } = require('playwright');17(async () => {18 const browser = await chromium.launch();19 const page = await browser.newPage();20 console.log(await page.title());21 await browser.close();22})();23const { chromium } = require('playwright');24(async () => {25 const browser = await chromium.launch();26 const page = await browser.newPage();27 console.log(await page.title());28 await browser.close();29})();30const { chromium } = require('playwright');31(async () => {32 const browser = await chromium.launch();33 const page = await browser.newPage();34 console.log(await page.title());35 await browser.close();36})();37const { chromium } = require('playwright');38(async () => {
Using AI Code Generation
1const { _awaitPromise } = require('playwright-core/lib/helper');2const { chromium } = require('playwright-core');3(async () => {4 const browser = await chromium.launch();5 const page = await browser.newPage();6 await page.screenshot({ path: 'google.png' });7 await browser.close();8 await _awaitPromise(browser._closedPromise);9})();10module.exports = {11 use: {12 executablePath: 'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe',13 },14};15const { chromium } = require('playwright-core');16(async () => {17 const browser = await chromium.launch();18 const page = await browser.newPage();19 await page.screenshot({ path: 'google.png' });20 await browser.close();21 await browser._closedPromise;22})();23module.exports = {24 use: {25 executablePath: 'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe',26 },27};
Using AI Code Generation
1const { _awaitPromise } = require("playwright");2const { chromium } = require("playwright");3(async () => {4 const browser = await chromium.launch();5 const page = await browser.newPage();6 await _awaitPromise(page.waitForSelector("text=Get started"));7 await browser.close();8})();
Using AI Code Generation
1const { _awaitPromise } = require('playwright/lib/utils/progress');2const { chromium } = require('playwright');3(async () => {4 const browser = await chromium.launch();5 const page = await browser.newPage();6 await page.click('text=Show my user agent');7 const ua = await page.$eval('#your-user-agent', (el) => el.textContent);8 console.log(ua);9 await browser.close();10})();11(async () => {12 const browser = await chromium.launch();13 const page = await browser.newPage();14 await page.click('text=Show my user agent');15 const ua = await _awaitPromise(page.$eval('#your-user-agent', (el) => el.textContent));16 console.log(ua);17 await browser.close();18})();19(async () => {20 const browser = await chromium.launch();21 const page = await browser.newPage();22 await page.click('text=Show my user agent');23 const ua = await _awaitPromise(page.$eval('#your-user-agent', (el) => el.textContent));24 console.log(ua);25 await browser.close();26})();27(async () => {28 const browser = await chromium.launch();29 const page = await browser.newPage();30 await page.click('text=Show my user agent');31 const ua = await _awaitPromise(page.$eval('#your-user-agent', (el) => el.textContent));32 console.log(ua);33 await browser.close();34})();35(async () => {36 const browser = await chromium.launch();37 const page = await browser.newPage();38 await page.click('text=Show my user agent');39 const ua = await _awaitPromise(page.$eval('#your-user-agent', (el) => el.textContent));40 console.log(ua);41 await browser.close();42})();
Using AI Code Generation
1const { _awaitPromise } = require('playwright/lib/helper');2const fs = require('fs');3const path = require('path');4const { chromium } = require('playwright');5(async () => {6 const browser = await chromium.launch();7 const page = await browser.newPage();8 await page.screenshot({ path: 'google.png' });9 await browser.close();10})();11const { _awaitPromise } = require('playwright/lib/helper');12const fs = require('fs');13const path = require('path');14const { chromium } = require('playwright');15(async () => {16 const browser = await chromium.launch();17 const page = await browser.newPage();18 await page.screenshot({ path: 'google.png' });19 await browser.close();20})();21const { _awaitPromise } = require('playwright/lib/helper');22const fs = require('fs');23const path = require('path');24const { chromium } = require('playwright');25(async () => {26 const browser = await chromium.launch();27 const page = await browser.newPage();28 await page.screenshot({ path: 'google.png' });29 await browser.close();30})();31const { _awaitPromise } = require('playwright/lib/helper');32const fs = require('fs');33const path = require('path');
Using AI Code Generation
1const promise = page.waitForSelector('div');2await page._awaitPromise(promise, 'WaitForSelector', 'div');3const promise = page.waitForSelector('div');4await page._awaitPromise(promise, 'WaitForSelector', 'div');5const promise = page.waitForSelector('div');6await page._awaitPromise(promise, 'WaitForSelector', 'div');7const promise = page.waitForSelector('div');8await page._awaitPromise(promise, 'WaitForSelector', 'div');9const promise = page.waitForSelector('div');10await page._awaitPromise(promise, 'WaitForSelector', 'div');11const promise = page.waitForSelector('div');12await page._awaitPromise(promise, 'WaitForSelector', 'div');13const promise = page.waitForSelector('div');14await page._awaitPromise(promise, 'WaitForSelector', 'div');15const promise = page.waitForSelector('div');16await page._awaitPromise(promise, 'WaitForSelector', 'div');17const promise = page.waitForSelector('div');18await page._awaitPromise(promise, 'WaitForSelector', 'div');19const promise = page.waitForSelector('div');20await page._awaitPromise(promise, 'WaitForSelector', 'div');21const promise = page.waitForSelector('div');22await page._awaitPromise(promise, 'WaitForSelector', 'div');23const promise = page.waitForSelector('div');24await page._awaitPromise(promise, 'WaitForSelector', 'div');25const promise = page.waitForSelector('div');26await page._awaitPromise(promise, 'WaitForSelector', 'div');
Using AI Code Generation
1const { _awaitPromise } = require('playwright/lib/helper');2(async () => {3 await _awaitPromise(async () => {4 console.log('hello');5 return 'world';6 });7})();8const { _awaitPromise } = require('playwright/lib/helper');9(async () => {10 await _awaitPromise(async () => {11 await new Promise(res => setTimeout(res, 1000));12 console.log('hello');13 return 'world';14 });15})();16Your name to display (optional):17Your name to display (optional):18const { _awaitPromise } = require('playwright/lib/helper');19(async () => {20 await _awaitPromise(async () => {21 await new Promise(res => setTimeout(res, 1000));22 console.log('hello');23 return 'world';24 });25})();26Your name to display (optional):
Using AI Code Generation
1var result = await this._awaitPromise(promise);2console.log(result);3var result = await this._awaitPromise(promise);4console.log(result);5var result = await this._awaitPromise(promise);6console.log(result);7var result = await this._awaitPromise(promise);8console.log(result);9var result = await this._awaitPromise(promise);10console.log(result);11var result = await this._awaitPromise(promise);12console.log(result);13var result = await this._awaitPromise(promise);14console.log(result);15var result = await this._awaitPromise(promise);16console.log(result);
Jest + Playwright - Test callbacks of event-based DOM library
firefox browser does not start in playwright
Is it possible to get the selector from a locator object in playwright?
How to run a list of test suites in a single file concurrently in jest?
Running Playwright in Azure Function
firefox browser does not start in playwright
This question is quite close to a "need more focus" question. But let's try to give it some focus:
Does Playwright has access to the cPicker object on the page? Does it has access to the window object?
Yes, you can access both cPicker and the window object inside an evaluate call.
Should I trigger the events from the HTML file itself, and in the callbacks, print in the DOM the result, in some dummy-element, and then infer from that dummy element text that the callbacks fired?
Exactly, or you can assign values to a javascript variable:
const cPicker = new ColorPicker({
onClickOutside(e){
},
onInput(color){
window['color'] = color;
},
onChange(color){
window['result'] = color;
}
})
And then
it('Should call all callbacks with correct arguments', async() => {
await page.goto(`http://localhost:5000/tests/visual/basic.html`, {waitUntil:'load'})
// Wait until the next frame
await page.evaluate(() => new Promise(requestAnimationFrame))
// Act
// Assert
const result = await page.evaluate(() => window['color']);
// Check the value
})
Check out the latest blogs from LambdaTest on this topic:
Native apps are developed specifically for one platform. Hence they are fast and deliver superior performance. They can be downloaded from various app stores and are not accessible through browsers.
One of the essential parts when performing automated UI testing, whether using Selenium or another framework, is identifying the correct web elements the tests will interact with. However, if the web elements are not located correctly, you might get NoSuchElementException in Selenium. This would cause a false negative result because we won’t get to the actual functionality check. Instead, our test will fail simply because it failed to interact with the correct element.
Smartphones have changed the way humans interact with technology. Be it travel, fitness, lifestyle, video games, or even services, it’s all just a few touches away (quite literally so). We only need to look at the growing throngs of smartphone or tablet users vs. desktop users to grasp this reality.
As part of one of my consulting efforts, I worked with a mid-sized company that was looking to move toward a more agile manner of developing software. As with any shift in work style, there is some bewilderment and, for some, considerable anxiety. People are being challenged to leave their comfort zones and embrace a continuously changing, dynamic working environment. And, dare I say it, testing may be the most ‘disturbed’ of the software roles in agile development.
LambdaTest’s Playwright tutorial will give you a broader idea about the Playwright automation framework, its unique features, and use cases with examples to exceed your understanding of Playwright testing. This tutorial will give A to Z guidance, from installing the Playwright framework to some best practices and advanced concepts.
Get 100 minutes of automation test minutes FREE!!