Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use SendAsync method of PuppeteerSharp.CDPSession class

Best Puppeteer-sharp code snippet using PuppeteerSharp.CDPSession.SendAsync

Connection.cs

Source:Connection.cs

...71        #region Public Methods72        internal int GetMessageID() => Interlocked.Increment(ref _lastId);73        internal Task RawSendASync(int id, string method, object args, string sessionId = null)74        {75            return Transport.SendAsync(JsonConvert.SerializeObject(76                new ConnectionRequest77                {78                    Id = id,79                    Method = method,80                    Params = args,81                    SessionId = sessionId82                },83                JsonHelper.DefaultJsonSerializerSettings));84        }85        internal async Task<JObject> SendAsync(string method, object args = null, bool waitForCallback = true)86        {87            if (IsClosed)88            {89                throw new TargetClosedException($"Protocol error({method}): Target closed.", CloseReason);90            }91            var id = GetMessageID();92            MessageTask callback = null;93            if (waitForCallback)94            {95                callback = new MessageTask96                {97                    TaskWrapper = new TaskCompletionSource<JObject>(),98                    Method = method99                };100                _callbacks[id] = callback;101            }102            await RawSendASync(id, method, args).ConfigureAwait(false);103            return waitForCallback ? await callback.TaskWrapper.Task.ConfigureAwait(false) : null;104        }105        internal async Task<T> SendAsync<T>(string method, object args = null)106        {107            var response = await SendAsync(method, args).ConfigureAwait(false);108            return response.ToObject<T>(true);109        }110        internal async Task<CDPSession> CreateSessionAsync(TargetInfo targetInfo)111        {112            var sessionId = (await SendAsync<TargetAttachToTargetResponse>("Target.attachToTarget", new TargetAttachToTargetRequest113            {114                TargetId = targetInfo.TargetId,115                Flatten = true116            }).ConfigureAwait(false)).SessionId;117            return await GetSessionAsync(sessionId).ConfigureAwait(false);118        }119        internal bool HasPendingCallbacks() => _callbacks.Count != 0;120        #endregion121        internal void Close(string closeReason)122        {123            if (IsClosed)124            {125                return;126            }...

CDPSession.cs

Source:CDPSession.cs

...8namespace PuppeteerSharp9{10    /// <summary>11    /// The CDPSession instances are used to talk raw Chrome Devtools Protocol:12    ///  * Protocol methods can be called with <see cref="CDPSession.SendAsync(string, object, bool)"/> method.13    ///  * Protocol events, using the <see cref="CDPSession.MessageReceived"/> event.14    ///15    /// Documentation on DevTools Protocol can be found here: <see href="https://chromedevtools.github.io/devtools-protocol/"/>.16    ///17    /// <code>18    /// <![CDATA[19    /// var client = await Page.Target.CreateCDPSessionAsync();20    /// await client.SendAsync("Animation.enable");21    /// client.MessageReceived += (sender, e) =>22    /// {23    ///      if (e.MessageID == "Animation.animationCreated")24    ///      {25    ///          Console.WriteLine("Animation created!");26    ///      }27    /// };28    /// JObject response = await client.SendAsync("Animation.getPlaybackRate");29    /// Console.WriteLine("playback rate is " + response.playbackRate);30    /// await client.SendAsync("Animation.setPlaybackRate", new31    /// {32    ///     playbackRate = Convert.ToInt32(response.playbackRate / 2)33    /// });34    /// ]]></code>35    /// </summary>36    public class CDPSession37    {38        internal CDPSession(Connection connection, TargetType targetType, string sessionId)39        {40            Connection = connection;41            TargetType = targetType;42            SessionId = sessionId;43            _callbacks = new ConcurrentDictionary<int, MessageTask>();44        }45        #region Private Members46        private readonly ConcurrentDictionary<int, MessageTask> _callbacks;47        #endregion48        #region Properties49        /// <summary>50        /// Gets the target type.51        /// </summary>52        /// <value>The target type.</value>53        public TargetType TargetType { get; }54        /// <summary>55        /// Gets the session identifier.56        /// </summary>57        /// <value>The session identifier.</value>58        public string SessionId { get; }59        /// <summary>60        /// Gets the connection.61        /// </summary>62        /// <value>The connection.</value>63        internal Connection Connection { get; private set; }64        /// <summary>65        /// Occurs when message received from Chromium.66        /// </summary>67        public event EventHandler<MessageEventArgs> MessageReceived;68        /// <summary>69        /// Occurs when the connection is closed.70        /// </summary>71        public event EventHandler Disconnected;72        /// <summary>73        /// Gets or sets a value indicating whether this <see cref="CDPSession"/> is closed.74        /// </summary>75        /// <value><c>true</c> if is closed; otherwise, <c>false</c>.</value>76        public bool IsClosed { get; internal set; }77        /// <summary>78        /// Connection close reason.79        /// </summary>80        public string CloseReason { get; private set; }81        /// <summary>82        /// Gets the logger factory.83        /// </summary>84        /// <value>The logger factory.</value>85        #endregion86        #region Public Methods87        internal void Send(string method, object args = null)88            => _ = SendAsync(method, args, false);89        /// <summary>90        /// Protocol methods can be called with this method.91        /// </summary>92        /// <param name="method">The method name</param>93        /// <param name="args">The method args</param>94        /// <typeparam name="T">Return type.</typeparam>95        /// <returns>The task.</returns>96        public async Task<T> SendAsync<T>(string method, object args = null)97        {98            var content = await SendAsync(method, args).ConfigureAwait(false);99            return content.ToObject<T>(true);100        }101        /// <summary>102        /// Protocol methods can be called with this method.103        /// </summary>104        /// <param name="method">The method name</param>105        /// <param name="args">The method args</param>106        /// <param name="waitForCallback">107        /// If <c>true</c> the method will return a task to be completed when the message is confirmed by Chromium.108        /// If <c>false</c> the task will be considered complete after sending the message to Chromium.109        /// </param>110        /// <returns>The task.</returns>111        /// <exception cref="PuppeteerSharp.PuppeteerException"></exception>112        public async Task<JObject> SendAsync(string method, object args = null, bool waitForCallback = true)113        {114            if (Connection == null)115            {116                throw new PuppeteerException(117                    $"Protocol error ({method}): Session closed. " +118                    $"Most likely the {TargetType} has been closed." +119                    $"Close reason: {CloseReason}");120            }121            var id = Connection.GetMessageID();122            MessageTask callback = null;123            if (waitForCallback)124            {125                callback = new MessageTask126                {127                    TaskWrapper = new TaskCompletionSource<JObject>(),128                    Method = method129                };130                _callbacks[id] = callback;131            }132            try133            {134                await Connection.RawSendASync(id, method, args, SessionId).ConfigureAwait(false);135            }136            catch (Exception ex)137            {138                if (waitForCallback && _callbacks.TryRemove(id, out _))139                {140                    callback.TaskWrapper.TrySetException(new MessageException(ex.Message, ex));141                }142            }143            return waitForCallback ? await callback.TaskWrapper.Task.ConfigureAwait(false) : null;144        }145        /// <summary>146        /// Detaches session from target. Once detached, session won't emit any events and can't be used to send messages.147        /// </summary>148        /// <returns></returns>149        /// <exception cref="T:PuppeteerSharp.PuppeteerException"></exception>150        public Task DetachAsync()151        {152            if (Connection == null)153            {154                throw new PuppeteerException($"Session already detached.Most likely the {TargetType} has been closed.");155            }156            return Connection.SendAsync("Target.detachFromTarget", new TargetDetachFromTargetRequest157            {158                SessionId = SessionId159            });160        }161        internal bool HasPendingCallbacks() => _callbacks.Count != 0;162        #endregion163        #region Private Methods164        internal void OnMessage(ConnectionResponse obj)165        {166            var id = obj.Id;167            if (id.HasValue && _callbacks.TryRemove(id.Value, out var callback))168            {169                if (obj.Error != null)170                {...

JSCoverage.cs

Source:JSCoverage.cs

...34            _scriptURLs.Clear();35            _scriptSources.Clear();36            _client.MessageReceived += client_MessageReceived;37            await Task.WhenAll(38                _client.SendAsync("Profiler.enable"),39                _client.SendAsync("Profiler.startPreciseCoverage", new { callCount = false, detailed = true }),40                _client.SendAsync("Debugger.enable"),41                _client.SendAsync("Debugger.setSkipAllPauses", new { skip = true })42            );43        }44        internal async Task<CoverageEntry[]> StopAsync()45        {46            if (!_enabled)47            {48                throw new InvalidOperationException("JSCoverage is not enabled");49            }50            _enabled = false;51            var profileResponseTask = _client.SendAsync<ProfilerTakePreciseCoverageResponse>("Profiler.takePreciseCoverage");52            await Task.WhenAll(53               profileResponseTask,54               _client.SendAsync("Profiler.stopPreciseCoverage"),55               _client.SendAsync("Profiler.disable"),56               _client.SendAsync("Debugger.disable")57           );58            _client.MessageReceived -= client_MessageReceived;59            var coverage = new List<CoverageEntry>();60            foreach (var entry in profileResponseTask.Result.Result)61            {62                if (!_scriptURLs.TryGetValue(entry.ScriptId, out var url) ||63                    !_scriptSources.TryGetValue(entry.ScriptId, out var text))64                {65                    continue;66                }67                var flattenRanges = entry.Functions.SelectMany(f => f.Ranges).ToList();68                var ranges = Coverage.ConvertToDisjointRanges(flattenRanges);69                coverage.Add(new CoverageEntry70                {71                    Url = url,72                    Ranges = ranges,73                    Text = text74                });75            }76            return coverage.ToArray();77        }78        private async void client_MessageReceived(object sender, MessageEventArgs e)79        {80            switch (e.MessageID)81            {82                case "Debugger.scriptParsed":83                    await OnScriptParsed(e.MessageData.ToObject<DebuggerScriptParsedResponse>());84                    break;85                case "Runtime.executionContextsCleared":86                    OnExecutionContextsCleared();87                    break;88            }89        }90        private async Task OnScriptParsed(DebuggerScriptParsedResponse scriptParseResponse)91        {92            if (string.IsNullOrEmpty(scriptParseResponse.Url))93            {94                return;95            }96            try97            {98                var response = await _client.SendAsync("Debugger.getScriptSource", new { scriptId = scriptParseResponse.ScriptId });99                _scriptURLs.Add(scriptParseResponse.ScriptId, scriptParseResponse.Url);100                _scriptSources.Add(scriptParseResponse.ScriptId, response.scriptSource.ToString());101            }102            catch (Exception ex)103            {104                _logger.LogError(ex.ToString());105            }106        }107        private void OnExecutionContextsCleared()108        {109            if (!_resetOnNavigation)110            {111                return;112            }...

Tracing.cs

Source:Tracing.cs

...6970            _path = options.Path;71            _recording = true;7273            await _client.SendAsync("Tracing.start", new74            {75                transferMode = "ReturnAsStream",76                categories = string.Join(", ", categories)77            });78        }7980        /// <summary>81        /// Stops tracing82        /// </summary>83        /// <returns>Stop task</returns>84        public async Task StopAsync()85        {86            var taskWrapper = new TaskCompletionSource<bool>();8788            async void EventHandler(object sender, TracingCompleteEventArgs e)89            {90                await ReadStream(e.Stream, _path);91                _client.TracingComplete -= EventHandler;92                taskWrapper.SetResult(true);93            }9495            _client.TracingComplete += EventHandler;9697            await _client.SendAsync("Tracing.end");9899            _recording = false;100101            await taskWrapper.Task;102        }103        private async Task ReadStream(string stream, string path)104        {105            using (var fs = new StreamWriter(path))106            {107                bool eof = false;108109                while (!eof)110                {111                    var response = await _client.SendAsync<IOReadResponse>("IO.read", new112                    {113                        handle = stream114                    });115116                    eof = response.Eof;117118                    await fs.WriteAsync(response.Data);119                }120            }121            await _client.SendAsync("IO.close", new122            {123                handle = stream124            });125        }126    }127}...

CreateCDPSessionTests.cs

Source:CreateCDPSessionTests.cs

...17        public async Task ShouldWork()18        {19            var client = await Page.Target.CreateCDPSessionAsync();20            await Task.WhenAll(21              client.SendAsync("Runtime.enable"),22              client.SendAsync("Runtime.evaluate", new RuntimeEvaluateRequest { Expression = "window.foo = 'bar'" })23            );24            var foo = await Page.EvaluateExpressionAsync<string>("window.foo");25            Assert.Equal("bar", foo);26        }27        [Fact]28        public async Task ShouldSendEvents()29        {30            var client = await Page.Target.CreateCDPSessionAsync();31            await client.SendAsync("Network.enable");32            var events = new List<object>();33            client.MessageReceived += (sender, e) =>34            {35                if (e.MessageID == "Network.requestWillBeSent")36                {37                    events.Add(e.MessageData);38                }39            };40            await Page.GoToAsync(TestConstants.EmptyPage);41            Assert.Single(events);42        }43        [Fact]44        public async Task ShouldEnableAndDisableDomainsIndependently()45        {46            var client = await Page.Target.CreateCDPSessionAsync();47            await client.SendAsync("Runtime.enable");48            await client.SendAsync("Debugger.enable");49            // JS coverage enables and then disables Debugger domain.50            await Page.Coverage.StartJSCoverageAsync();51            await Page.Coverage.StopJSCoverageAsync();52            // generate a script in page and wait for the event.53            var eventTask = WaitEvent(client, "Debugger.scriptParsed");54            await Task.WhenAll(55                eventTask,56                Page.EvaluateExpressionAsync("//# sourceURL=foo.js")57            );58            // expect events to be dispatched.59            Assert.Equal("foo.js", eventTask.Result["url"].Value<string>());60        }61        [Fact]62        public async Task ShouldBeAbleToDetachSession()63        {64            var client = await Page.Target.CreateCDPSessionAsync();65            await client.SendAsync("Runtime.enable");66            var evalResponse = await client.SendAsync("Runtime.evaluate", new RuntimeEvaluateRequest67            {68                Expression = "1 + 2",69                ReturnByValue = true70            });71            Assert.Equal(3, evalResponse["result"]["value"].ToObject<int>());72            await client.DetachAsync();73            var exception = await Assert.ThrowsAnyAsync<Exception>(()74                => client.SendAsync("Runtime.evaluate", new RuntimeEvaluateRequest75                {76                    Expression = "3 + 1",77                    ReturnByValue = true78                }));79            Assert.Contains("Session closed.", exception.Message);80        }81        [Fact]82        public async Task ShouldThrowNiceErrors()83        {84            var client = await Page.Target.CreateCDPSessionAsync();85            async Task TheSourceOfTheProblems() => await client.SendAsync("ThisCommand.DoesNotExist");86            var exception = await Assert.ThrowsAsync<MessageException>(async () =>87            {88                await TheSourceOfTheProblems();89            });90            Assert.Contains("TheSourceOfTheProblems", exception.StackTrace);91            Assert.Contains("ThisCommand.DoesNotExist", exception.Message);92        }93    }94}...

ProtocolStreamReader.cs

Source:ProtocolStreamReader.cs

...17            {18                var eof = false;19                while (!eof)20                {21                    var response = await client.SendAsync<IOReadResponse>("IO.read", new IOReadRequest22                    {23                        Handle = handle24                    }).ConfigureAwait(false);25                    eof = response.Eof;26                    result.Append(response.Data);27                    if (fs != null)28                    {29                        var data = Encoding.UTF8.GetBytes(response.Data);30                        await fs.WriteAsync(data, 0, data.Length).ConfigureAwait(false);31                    }32                }33                await client.SendAsync("IO.close", new IOCloseRequest34                {35                    Handle = handle36                }).ConfigureAwait(false);37                return result.ToString();38            }39            finally40            {41                fs?.Dispose();42            }43        }44        internal static async Task<byte[]> ReadProtocolStreamByteAsync(CDPSession client, string handle, string path)45        {46            IEnumerable<byte> result = null;47            var eof = false;48            var fs = !string.IsNullOrEmpty(path) ? AsyncFileHelper.CreateStream(path, FileMode.Create) : null;49            try50            {51                while (!eof)52                {53                    var response = await client.SendAsync<IOReadResponse>("IO.read", new IOReadRequest54                    {55                        Handle = handle56                    }).ConfigureAwait(false);57                    eof = response.Eof;58                    var data = Convert.FromBase64String(response.Data);59                    result = result == null ? data : result.Concat(data);60                    if (fs != null)61                    {62                        await fs.WriteAsync(data, 0, data.Length).ConfigureAwait(false);63                    }64                }65                await client.SendAsync("IO.close", new IOCloseRequest66                {67                    Handle = handle68                }).ConfigureAwait(false);69                return result.ToArray();70            }71            finally72            {73                fs?.Dispose();74            }75        }76    }77}...

EmulationManager.cs

Source:EmulationManager.cs

...29                    Angle = 0,30                    Type = ScreenOrientationType.PortraitPrimary31                };32            await Task.WhenAll(new Task[]{33                _client.SendAsync("Emulation.setDeviceMetricsOverride", new34                {35                    mobile,36                    width,37                    height,38                    deviceScaleFactor,39                    screenOrientation40                }),41                _client.SendAsync("Emulation.setTouchEmulationEnabled", new42                {43                    enabled = viewport.HasTouch,44                    configuration = viewport.IsMobile ? "mobile" : "desktop"45                })46            });47            var reloadNeeded = false;48            if (viewport.HasTouch && string.IsNullOrEmpty(_injectedTouchScriptId))49            {50                //TODO: It's not clear what to do here51                /*52                var source = $"({ injectedTouchEventsFunction})()";53                this._injectedTouchScriptId = (await this._client.send('Page.addScriptToEvaluateOnNewDocument', { source })).identifier;54                reloadNeeded = true;55                */56            }57            else if (!viewport.HasTouch && !string.IsNullOrEmpty(_injectedTouchScriptId))58            {59                await _client.SendAsync("Page.removeScriptToEvaluateOnNewDocument", new60                {61                    identifier = _injectedTouchScriptId62                });63                _injectedTouchScriptId = null;64                reloadNeeded = true;65            }66            if (_emulatingMobile != mobile)67            {68                reloadNeeded = true;69            }70            _emulatingMobile = mobile;71            return reloadNeeded;72        }73    }...

Touchscreen.cs

Source:Touchscreen.cs

...31        {32            // Touches appear to be lost during the first frame after navigation.33            // This waits a frame before sending the tap.34            // @see https://crbug.com/61321935            await _client.SendAsync("Runtime.evaluate", new RuntimeEvaluateRequest36            {37                Expression = "new Promise(x => requestAnimationFrame(() => requestAnimationFrame(x)))",38                AwaitPromise = true39            }).ConfigureAwait(false);40            var touchPoints = new[] { new TouchPoint { X = Math.Round(x), Y = Math.Round(y) } };41            await _client.SendAsync("Input.dispatchTouchEvent", new InputDispatchTouchEventRequest42            {43                Type = "touchStart",44                TouchPoints = touchPoints,45                Modifiers = _keyboard.Modifiers46            }).ConfigureAwait(false);47            await _client.SendAsync("Input.dispatchTouchEvent", new InputDispatchTouchEventRequest48            {49                Type = "touchEnd",50                TouchPoints = Array.Empty<TouchPoint>(),51                Modifiers = _keyboard.Modifiers52            }).ConfigureAwait(false);53        }54    }55}...

SendAsync

Using AI Code Generation

1using PuppeteerSharp;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultRevision);9            var browser = await Puppeteer.LaunchAsync(new LaunchOptions10            {11                Args = new string[] { "--disable-gpu", "--disable-dev-shm-usage" }12            });13            var page = await browser.NewPageAsync();14            var client = page.Target.CreateCDPSessionAsync();15            var response = await client.SendAsync("Network.enable");16            var response2 = await client.SendAsync("Network.getResponseBody", new { requestId = "1" });17            Console.WriteLine(response);18            Console.WriteLine(response2);19        }20    }21}22{result = null, id = 1}23{result = null, id = 2}

SendAsync

Using AI Code Generation

1var session = await page.Target.CreateCDPSessionAsync();2var response = await session.SendAsync("Network.enable");3Console.WriteLine(response.ToString());4var session = await page.Target.CreateCDPSessionAsync();5var response = await session.SendAsync("Network.enable");6Console.WriteLine(response.ToString());7var session = await page.Target.CreateCDPSessionAsync();8var response = await session.SendAsync("Network.enable");9Console.WriteLine(response.ToString());10var session = await page.Target.CreateCDPSessionAsync();11var response = await session.SendAsync("Network.enable");12Console.WriteLine(response.ToString());13var session = await page.Target.CreateCDPSessionAsync();14var response = await session.SendAsync("Network.enable");15Console.WriteLine(response.ToString());16var session = await page.Target.CreateCDPSessionAsync();17var response = await session.SendAsync("Network.enable");18Console.WriteLine(response.ToString());19var session = await page.Target.CreateCDPSessionAsync();20var response = await session.SendAsync("Network.enable");21Console.WriteLine(response.ToString());22var session = await page.Target.CreateCDPSessionAsync();23var response = await session.SendAsync("Network.enable");24Console.WriteLine(response.ToString());25var session = await page.Target.CreateCDPSessionAsync();26var response = await session.SendAsync("Network.enable");27Console.WriteLine(response.ToString());28var session = await page.Target.CreateCDPSessionAsync();29var response = await session.SendAsync("Network.enable");30Console.WriteLine(response.ToString());31var session = await page.Target.CreateCDPSessionAsync();32var response = await session.SendAsync("Network.enable");33Console.WriteLine(response.ToString());

SendAsync

Using AI Code Generation

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4using PuppeteerSharp.Input;5using System.Threading;6{7    static void Main(string[] args)8    {9        MainAsync(args).GetAwaiter().GetResult();10    }11    static async Task MainAsync(string[] args)12    {13        {14        };15        using (var browser = await Puppeteer.LaunchAsync(options))16        {17            using (var page = await browser.NewPageAsync())18            {19                await page.WaitForSelectorAsync("input[title='Search']");20                await page.TypeAsync("input[title='Search']", "PuppeteerSharp");21                await page.Keyboard.PressAsync("Enter");22                await page.WaitForSelectorAsync("div.g");23                var searchResults = await page.QuerySelectorAllAsync("div.g");24                foreach (var searchResult in searchResults)25                {26                    var title = await searchResult.QuerySelectorAsync("h3");27                    if (title != null)28                    {29                        Console.WriteLine(await title.EvaluateFunctionAsync<string>("node => node.innerText"));30                    }31                }32            }33        }34    }35}36using System;37using System.Threading.Tasks;38using PuppeteerSharp;39using PuppeteerSharp.Input;40using System.Threading;41{42    static void Main(string[] args)43    {44        MainAsync(args).GetAwaiter().GetResult();45    }46    static async Task MainAsync(string[] args)47    {48        {49        };50        using (var browser = await Puppeteer.LaunchAsync(options))51        {52            using (var page = await browser.NewPageAsync())53            {54                await page.WaitForSelectorAsync("input[title='Search']");55                await page.TypeAsync("input[title='Search']", "PuppeteerSharp");56                await page.Keyboard.PressAsync("Enter");57                await page.WaitForSelectorAsync("div.g");58                var searchResults = await page.QuerySelectorAllAsync("div.g");59                foreach (var searchResult in searchResults)60                {61                    var title = await searchResult.QuerySelectorAsync("h3");62                    if (title != null)

SendAsync

Using AI Code Generation

1using System.Threading.Tasks;2using PuppeteerSharp;3{4    {5        static async Task Main(string[] args)6        {7            var browser = await Puppeteer.LaunchAsync(new LaunchOptions8            {9            });10            var page = await browser.NewPageAsync();11            var client = page.Target.CreateCDPSessionAsync();12            await client.SendAsync("Emulation.setCPUThrottlingRate", new13            {14            });15        }16    }17}18using System.Threading.Tasks;19using PuppeteerSharp;20{21    {22        static async Task Main(string[] args)23        {24            var browser = await Puppeteer.LaunchAsync(new LaunchOptions25            {26            });27            var client = browser.GetCDPSessionAsync();28            await client.SendAsync("Emulation.setCPUThrottlingRate", new29            {30            });31        }32    }33}34using System.Threading.Tasks;35using PuppeteerSharp;36{37    {38        static async Task Main(string[] args)39        {40            var browser = await Puppeteer.LaunchAsync(new LaunchOptions41            {42            });43            var client = browser.GetCDPSessionAsync();44            await client.SendAsync("Emulation.setCPUThrottlingRate", new45            {46            });47        }48    }49}50using System.Threading.Tasks;51using PuppeteerSharp;52{53    {

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.