KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use MessageTask class of PuppeteerSharp package

Best Puppeteer-sharp code snippet using PuppeteerSharp.MessageTask

Connection.cs

Source:Connection.cs

...23            Delay = delay;24            Transport = transport;25            Transport.MessageReceived += Transport_MessageReceived;26            Transport.Closed += Transport_Closed;27            _callbacks = new ConcurrentDictionary<int, MessageTask>();28            _sessions = new ConcurrentDictionary<string, CDPSession>();29            _asyncSessions = new AsyncDictionaryHelper<string, CDPSession>(_sessions, "Session {0} not found");30        }31        #region Private Members32        private int _lastId;33        private readonly ConcurrentDictionary<int, MessageTask> _callbacks;34        private readonly ConcurrentDictionary<string, CDPSession> _sessions;35        private readonly AsyncDictionaryHelper<string, CDPSession> _asyncSessions;36        #endregion37        #region Properties38        /// <summary>39        /// Gets the WebSocket URL.40        /// </summary>41        /// <value>The URL.</value>42        public string Url { get; }43        /// <summary>44        /// Gets the sleep time when a message is received.45        /// </summary>46        /// <value>The delay.</value>47        public int Delay { get; }48        /// <summary>49        /// Gets the Connection transport.50        /// </summary>51        /// <value>Connection transport.</value>52        public IConnectionTransport Transport { get; }53        /// <summary>54        /// Occurs when the connection is closed.55        /// </summary>56        public event EventHandler Disconnected;57        /// <summary>58        /// Occurs when a message from chromium is received.59        /// </summary>60        public event EventHandler<MessageEventArgs> MessageReceived;61        /// <summary>62        /// Gets or sets a value indicating whether this <see cref="Connection"/> is closed.63        /// </summary>64        /// <value><c>true</c> if is closed; otherwise, <c>false</c>.</value>65        public bool IsClosed { get; internal set; }66        /// <summary>67        /// Connection close reason.68        /// </summary>69        public string CloseReason { get; private set; }70        #endregion71        #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        }...

CDPSession.cs

Source:CDPSession.cs

...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                {...

PageEventsConsoleTests.cs

Source:PageEventsConsoleTests.cs

1using System.Linq;2using System.Collections.Generic;3using System.Threading.Tasks;4using Xunit;5using Xunit.Abstractions;6using PuppeteerSharp.Tests.Attributes;7using PuppeteerSharp.Xunit;8namespace PuppeteerSharp.Tests.PageTests.Events9{10    [Collection(TestConstants.TestFixtureCollectionName)]11    public class PageEventsConsoleTests : PuppeteerPageBaseTest12    {13        public PageEventsConsoleTests(ITestOutputHelper output) : base(output)14        {15        }16        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should work")]17        [SkipBrowserFact(skipFirefox: true)]18        public async Task ShouldWork()19        {20            ConsoleMessage message = null;21            void EventHandler(object sender, ConsoleEventArgs e)22            {23                message = e.Message;24                Page.Console -= EventHandler;25            }26            Page.Console += EventHandler;27            await Page.EvaluateExpressionAsync("console.log('hello', 5, {foo: 'bar'})");28            var obj = new Dictionary<string, object> { { "foo", "bar" } };29            Assert.Equal("hello 5 JSHandle@object", message.Text);30            Assert.Equal(ConsoleType.Log, message.Type);31            Assert.Equal("hello", await message.Args[0].JsonValueAsync());32            Assert.Equal(5, await message.Args[1].JsonValueAsync<float>());33            Assert.Equal(obj, await message.Args[2].JsonValueAsync<Dictionary<string, object>>());34            Assert.Equal("bar", (await message.Args[2].JsonValueAsync<dynamic>()).foo.ToString());35        }36        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should work for different console API calls")]37        [SkipBrowserFact(skipFirefox: true)]38        public async Task ShouldWorkForDifferentConsoleApiCalls()39        {40            var messages = new List<ConsoleMessage>();41            Page.Console += (_, e) => messages.Add(e.Message);42            await Page.EvaluateFunctionAsync(@"() => {43              // A pair of time/timeEnd generates only one Console API call.44              console.time('calling console.time');45              console.timeEnd('calling console.time');46              console.trace('calling console.trace');47              console.dir('calling console.dir');48              console.warn('calling console.warn');49              console.error('calling console.error');50              console.log(Promise.resolve('should not wait until resolved!'));51            }");52            Assert.Equal(new[]53            {54                ConsoleType.TimeEnd,55                ConsoleType.Trace,56                ConsoleType.Dir,57                ConsoleType.Warning,58                ConsoleType.Error,59                ConsoleType.Log60            }, messages61                .Select(_ => _.Type)62                .ToArray());63            Assert.Contains("calling console.time", messages[0].Text);64            Assert.Equal(new[]65            {66                "calling console.trace",67                "calling console.dir",68                "calling console.warn",69                "calling console.error",70                "JSHandle@promise"71            }, messages72                .Skip(1)73                .Select(msg => msg.Text)74                .ToArray());75        }76        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should not fail for window object")]77        [SkipBrowserFact(skipFirefox: true)]78        public async Task ShouldNotFailForWindowObject()79        {80            var consoleTcs = new TaskCompletionSource<string>();81            void EventHandler(object sender, ConsoleEventArgs e)82            {83                consoleTcs.TrySetResult(e.Message.Text);84                Page.Console -= EventHandler;85            }86            Page.Console += EventHandler;87            await Task.WhenAll(88                consoleTcs.Task,89                Page.EvaluateExpressionAsync("console.error(window)")90            );91            Assert.Equal("JSHandle@object", await consoleTcs.Task);92        }93        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should trigger correct Log")]94        [SkipBrowserFact(skipFirefox: true)]95        public async Task ShouldTriggerCorrectLog()96        {97            await Page.GoToAsync(TestConstants.AboutBlank);98            var messageTask = new TaskCompletionSource<ConsoleMessage>();99            Page.Console += (_, e) => messageTask.TrySetResult(e.Message);100            await Page.EvaluateFunctionAsync("async url => fetch(url).catch(e => {})", TestConstants.EmptyPage);101            var message = await messageTask.Task;102            Assert.Contains("No 'Access-Control-Allow-Origin'", message.Text);103            if (TestConstants.IsChrome)104            {105                Assert.Equal(ConsoleType.Error, message.Type);106            }107            else108            {109                Assert.Equal(ConsoleType.Warning, message.Type);110            }111        }112        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should have location when fetch fails")]113        [SkipBrowserFact(skipFirefox: true)]114        public async Task ShouldHaveLocationWhenFetchFails()115        {116            await Page.GoToAsync(TestConstants.EmptyPage);117            var consoleTask = new TaskCompletionSource<ConsoleEventArgs>();118            Page.Console += (_, e) => consoleTask.TrySetResult(e);119            await Task.WhenAll(120                consoleTask.Task,121                Page.SetContentAsync("<script>fetch('http://wat');</script>"));122            var args = await consoleTask.Task;123            Assert.Contains("ERR_NAME", args.Message.Text);124            Assert.Equal(ConsoleType.Error, args.Message.Type);125            Assert.Equal(new ConsoleMessageLocation126            {127                URL = "http://wat/",128            }, args.Message.Location);129        }130        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should have location and stack trace for console API calls")]131        [SkipBrowserFact(skipFirefox: true)]132        public async Task ShouldHaveLocationForConsoleAPICalls()133        {134            await Page.GoToAsync(TestConstants.EmptyPage);135            var consoleTask = new TaskCompletionSource<ConsoleEventArgs>();136            Page.Console += (_, e) => consoleTask.TrySetResult(e);137            await Task.WhenAll(138                consoleTask.Task,139                Page.GoToAsync(TestConstants.ServerUrl + "/consolelog.html"));140            var args = await consoleTask.Task;141            Assert.Equal("yellow", args.Message.Text);142            Assert.Equal(ConsoleType.Log, args.Message.Type);143            Assert.Equal(new ConsoleMessageLocation144            {145                URL = TestConstants.ServerUrl + "/consolelog.html",146                LineNumber = 7,147                ColumnNumber = 14148            }, args.Message.Location);149        }150        [PuppeteerTest("page.spec.ts", "Page.Events.Console", "should not throw when there are console messages in detached iframes")]151        [SkipBrowserFact(skipFirefox: true)]152        public async Task ShouldNotThrowWhenThereAreConsoleMessagesInDetachedIframes()153        {154            await Page.GoToAsync(TestConstants.EmptyPage);155            await Page.EvaluateFunctionAsync(@"async () =>156            {157                // 1. Create a popup that Puppeteer is not connected to.158                const win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=780,height=200,top=0,left=0');159                await new Promise(x => win.onload = x);160                // 2. In this popup, create an iframe that console.logs a message.161                win.document.body.innerHTML = `<iframe src='/consolelog.html'></iframe>`;162                const frame = win.document.querySelector('iframe');163                await new Promise(x => frame.onload = x);164                // 3. After that, remove the iframe.165                frame.remove();166            }");167            var popupTarget = Page.BrowserContext.Targets().First(target => target != Page.Target);168            // 4. Connect to the popup and make sure it doesn't throw.169            await popupTarget.PageAsync();170        }171    }172}...

ConsoleTests.cs

Source:ConsoleTests.cs

1ï»¿using System.Linq;2using System.Collections.Generic;3using System.Threading.Tasks;4using Xunit;5using Xunit.Abstractions;6namespace PuppeteerSharp.Tests.PageTests.Events7{8    [Collection(TestConstants.TestFixtureCollectionName)]9    public class ConsoleTests : PuppeteerPageBaseTest10    {11        public ConsoleTests(ITestOutputHelper output) : base(output)12        {13        }14        [Fact]15        public async Task ShouldWork()16        {17            ConsoleMessage message = null;18            void EventHandler(object sender, ConsoleEventArgs e)19            {20                message = e.Message;21                Page.Console -= EventHandler;22            }23            Page.Console += EventHandler;24            await Page.EvaluateExpressionAsync("console.log('hello', 5, {foo: 'bar'})");25            var obj = new Dictionary<string, object> { { "foo", "bar" } };26            Assert.Equal("hello 5 JSHandle@object", message.Text);27            Assert.Equal(ConsoleType.Log, message.Type);28            Assert.Equal("hello", await message.Args[0].JsonValueAsync());29            Assert.Equal(5, await message.Args[1].JsonValueAsync<float>());30            Assert.Equal(obj, await message.Args[2].JsonValueAsync<Dictionary<string, object>>());31            Assert.Equal("bar", (await message.Args[2].JsonValueAsync<dynamic>()).foo.ToString());32        }33        [Fact]34        public async Task ShouldWorkForDifferentConsoleApiCalls()35        {36            var messages = new List<ConsoleMessage>();37            Page.Console += (sender, e) => messages.Add(e.Message);38            await Page.EvaluateFunctionAsync(@"() => {39              // A pair of time/timeEnd generates only one Console API call.40              console.time('calling console.time');41              console.timeEnd('calling console.time');42              console.trace('calling console.trace');43              console.dir('calling console.dir');44              console.warn('calling console.warn');45              console.error('calling console.error');46              console.log(Promise.resolve('should not wait until resolved!'));47            }");48            Assert.Equal(new[]49            {50                ConsoleType.TimeEnd,51                ConsoleType.Trace,52                ConsoleType.Dir,53                ConsoleType.Warning,54                ConsoleType.Error,55                ConsoleType.Log56            }, messages57                .Select(_ => _.Type)58                .ToArray());59            Assert.Contains("calling console.time", messages[0].Text);60            Assert.Equal(new[]61            {62                "calling console.trace",63                "calling console.dir",64                "calling console.warn",65                "calling console.error",66                "JSHandle@promise"67            }, messages68                .Skip(1)69                .Select(msg => msg.Text)70                .ToArray());71        }72        [Fact]73        public async Task ShouldNotFailForWindowObject()74        {75            var consoleTcs = new TaskCompletionSource<string>();76            void EventHandler(object sender, ConsoleEventArgs e)77            {78                consoleTcs.TrySetResult(e.Message.Text);79                Page.Console -= EventHandler;80            }81            Page.Console += EventHandler;82            await Task.WhenAll(83                consoleTcs.Task,84                Page.EvaluateExpressionAsync("console.error(window)")85            );86            Assert.Equal("JSHandle@object", await consoleTcs.Task);87        }88        [Fact]89        public async Task ShouldTriggerCorrectLog()90        {91            await Page.GoToAsync(TestConstants.AboutBlank);92            var messageTask = new TaskCompletionSource<ConsoleMessage>();93            Page.Console += (sender, e) => messageTask.TrySetResult(e.Message);94            await Page.EvaluateFunctionAsync("async url => fetch(url).catch(e => {})", TestConstants.EmptyPage);95            var message = await messageTask.Task;96            Assert.Contains("No 'Access-Control-Allow-Origin'", message.Text);97            Assert.Equal(ConsoleType.Error, message.Type);98        }99        [Fact]100        public async Task ShouldHaveLocationWhenFetchFails()101        {102            await Page.GoToAsync(TestConstants.EmptyPage);103            var consoleTask = new TaskCompletionSource<ConsoleEventArgs>();104            Page.Console += (sender, e) => consoleTask.TrySetResult(e);105            await Task.WhenAll(106                consoleTask.Task,107                Page.SetContentAsync("<script>fetch('http://wat');</script>"));108            var args = await consoleTask.Task;109            Assert.Contains("ERR_NAME", args.Message.Text);110            Assert.Equal(ConsoleType.Error, args.Message.Type);111            Assert.Equal(new ConsoleMessageLocation112            {113                URL = "http://wat/",114            }, args.Message.Location);115        }116        [Fact]117        public async Task ShouldHaveLocationForConsoleAPICalls()118        {119            await Page.GoToAsync(TestConstants.EmptyPage);120            var consoleTask = new TaskCompletionSource<ConsoleEventArgs>();121            Page.Console += (sender, e) => consoleTask.TrySetResult(e);122            await Task.WhenAll(123                consoleTask.Task,124                Page.GoToAsync(TestConstants.ServerUrl + "/consolelog.html"));125            var args = await consoleTask.Task;126            Assert.Equal("yellow", args.Message.Text);127            Assert.Equal(ConsoleType.Log, args.Message.Type);128            Assert.Equal(new ConsoleMessageLocation129            {130                URL = TestConstants.ServerUrl + "/consolelog.html",131                LineNumber = 7,132                ColumnNumber = 14133            }, args.Message.Location);134        }135        [Fact]136        public async Task ShouldNotThrowWhenThereAreConsoleMessagesInDetachedIframes()137        {138            await Page.GoToAsync(TestConstants.EmptyPage);139            await Page.EvaluateFunctionAsync(@"async () =>140            {141                // 1. Create a popup that Puppeteer is not connected to.142                const win = window.open(window.location.href, 'Title', 'toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,resizable=yes,width=780,height=200,top=0,left=0');143                await new Promise(x => win.onload = x);144                // 2. In this popup, create an iframe that console.logs a message.145                win.document.body.innerHTML = `<iframe src='/consolelog.html'></iframe>`;146                const frame = win.document.querySelector('iframe');147                await new Promise(x => frame.onload = x);148                // 3. After that, remove the iframe.149                frame.remove();150            }");151            var popupTarget = Page.BrowserContext.Targets().First(target => target != Page.Target);152            // 4. Connect to the popup and make sure it doesn't throw.153            await popupTarget.PageAsync();154        }155    }156}...

AsyncMessageQueue.cs

Source:AsyncMessageQueue.cs

...12    /// async without risk callers causing a deadlock.13    /// </summary>14    internal class AsyncMessageQueue : IDisposable15    {16        private readonly List<MessageTask> _pendingTasks;17        private readonly bool _enqueueAsyncMessages;18        private readonly ILogger _logger;19        private bool _disposed;20        public AsyncMessageQueue(bool enqueueAsyncMessages, ILogger logger = null)21        {22            _enqueueAsyncMessages = enqueueAsyncMessages;23            _logger = logger ?? NullLogger.Instance;24            _pendingTasks = new List<MessageTask>();25        }26        public void Enqueue(MessageTask callback, ConnectionResponse obj)27        {28            if (_disposed)29            {30                throw new ObjectDisposedException(GetType().FullName);31            }32            if (!_enqueueAsyncMessages)33            {34                HandleAsyncMessage(callback, obj);35                return;36            }37            // Keep a ref to this task until it completes. If it can't finish by the time we dispose this queue,38            // then we'll find it and cancel it.39            lock (_pendingTasks)40            {41                _pendingTasks.Add(callback);42            }43            var task = Task.Run(() => HandleAsyncMessage(callback, obj));44            // Unhandled error handler45            task.ContinueWith(46                t =>47                {48                    _logger.LogError(t.Exception, "Failed to complete async handling of SendAsync for {callback}", callback.Method);49                    callback.TaskWrapper.TrySetException(t.Exception!); // t.Exception is available since this runs only on faulted50                },51                CancellationToken.None,52                TaskContinuationOptions.OnlyOnFaulted,53                TaskScheduler.Default);54            // Always remove from the queue when done, regardless of outcome.55            task.ContinueWith(56                _ =>57                {58                    lock (_pendingTasks)59                    {60                        _pendingTasks.Remove(callback);61                    }62                },63                TaskScheduler.Default);64        }65        public void Dispose()66        {67            if (_disposed)68            {69                return;70            }71            // Ensure all tasks are finished since we're disposing now. Any pending tasks will be canceled.72            MessageTask[] pendingTasks;73            lock (_pendingTasks)74            {75                pendingTasks = _pendingTasks.ToArray();76                _pendingTasks.Clear();77            }78            foreach (var pendingTask in pendingTasks)79            {80                pendingTask.TaskWrapper.TrySetCanceled();81            }82            _disposed = true;83        }84        private static void HandleAsyncMessage(MessageTask callback, ConnectionResponse obj)85        {86            if (obj.Error != null)87            {88                callback.TaskWrapper.TrySetException(new MessageException(callback, obj.Error));89            }90            else91            {92                callback.TaskWrapper.TrySetResult(obj.Result);93            }94        }95    }96}...

MessageException.cs

Source:MessageException.cs

...22        /// <param name="innerException">Inner exception.</param>23        public MessageException(string message, Exception innerException) : base(message, innerException)24        {25        }26        internal MessageException(MessageTask callback, JObject obj) : base(GetCallbackMessage(callback, obj))27        {28        }29        internal static string GetCallbackMessage(MessageTask callback, JObject obj)30        {31            var error = obj.SelectToken(MessageKeys.Error);32            var message = $"Protocol error ({callback.Method}): {error[MessageKeys.Message]}";33            if (error[MessageKeys.Data] != null)34            {35                message += $" {error[MessageKeys.Data]}";36            }37            return !string.IsNullOrEmpty(error[MessageKeys.Message].ToString()) ? RewriteErrorMeesage(message) : string.Empty;38        }39    }40}...

MessageTask.cs

Source:MessageTask.cs

1ï»¿using System;2using System.Threading.Tasks;3namespace PuppeteerSharp4{5    internal class MessageTask6    {7        internal MessageTask()8        {9        }10        #region public Properties11        internal TaskCompletionSource<dynamic> TaskWrapper { get; set; }12        internal string Method { get; set; }13        internal bool RawContent { get; set; }14        #endregion15    }16}...

MessageTask

Using AI Code Generation

1using PuppeteerSharp;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            var browserFetcher = new BrowserFetcher();9            await browserFetcher.DownloadAsync(BrowserFetcher.DefaultRevision);10            var browser = await Puppeteer.LaunchAsync(new LaunchOptions11            {12            });13            var page = await browser.NewPageAsync();14            var messageTask = new MessageTask(page);15            await messageTask.WaitForMessageAsync();16            Console.WriteLine("Message received");17        }18    }19}

MessageTask

Using AI Code Generation

1using System;2using PuppeteerSharp;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            var browser = await Puppeteer.LaunchAsync(new LaunchOptions9            {10                ExecutablePath = @"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"11            });12            var page = await browser.NewPageAsync();13            var title = await page.EvaluateExpressionAsync<string>("document.title");14            Console.WriteLine(title);15            await browser.CloseAsync();16        }17    }18}

MessageTask

Using AI Code Generation

1var message = new MessageTask();2message.Message = "Hello World";3message.Send();4var message = new MessageTask();5message.Message = "Hello World";6message.Send();7var message = new MessageTask();8message.Message = "Hello World";9message.Send();10var message = new MessageTask();11message.Message = "Hello World";12message.Send();13var message = new MessageTask();14message.Message = "Hello World";15message.Send();16var message = new MessageTask();17message.Message = "Hello World";18message.Send();19var message = new MessageTask();20message.Message = "Hello World";21message.Send();22var message = new MessageTask();23message.Message = "Hello World";24message.Send();25var message = new MessageTask();26message.Message = "Hello World";27message.Send();28var message = new MessageTask();29message.Message = "Hello World";30message.Send();31var message = new MessageTask();32message.Message = "Hello World";33message.Send();34var message = new MessageTask();35message.Message = "Hello World";36message.Send();37var message = new MessageTask();38message.Message = "Hello World";39message.Send();40var message = new MessageTask();41message.Message = "Hello World";42message.Send();

MessageTask

Using AI Code Generation

1using PuppeteerSharp;2using System;3using System.Threading.Tasks;4{5    {6        static void Main(string[] args)7        {8            string message = "Hello, This is a test message from C#";9            string number = "919876543210";10            SendWhatsAppMessage(message, number).Wait();11        }12        static async Task SendWhatsAppMessage(string message, string number)13        {14            var options = new LaunchOptions { Headless = false };15            using (var browser = await Puppeteer.LaunchAsync(options))16            using (var page = await browser.NewPageAsync())17            {18                await page.WaitForSelectorAsync("input[title='Search or start new chat']");19                await page.TypeAsync("input[title='Search or start new chat']", number);20                await page.WaitForSelectorAsync("span[title='" + number + "']");21                await page.ClickAsync("span[title='" + number + "']");22                await page.WaitForSelectorAsync("div[data-tab='1']");23                await page.TypeAsync("div[data-tab='1']", message);24                await page.Keyboard.PressAsync("Enter");25            }26        }27    }28}

MessageTask

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 messageTask = new MessageTask();12            await messageTask.Send(page, "919999999999", "Hello");13        }14    }15}16using System.Threading.Tasks;17using PuppeteerSharp;18{19    {20        public async Task Send(Page page, string number, string message)21        {22            await page.WaitForSelectorAsync("._2_1wd");23            await page.TypeAsync("._2_1wd", number);24            await page.WaitForSelectorAsync("._2UaNq");25            var elements = await page.QuerySelectorAllAsync("._2UaNq");26            await elements[1].ClickAsync();27            await page.WaitForSelectorAsync("._13mgZ");28            await page.TypeAsync("._13mgZ", message);29            await page.Keyboard.PressAsync("Enter");30        }31    }32}33{34  "scripts": {35  },36  "dependencies": {37  }38}

MessageTask

Using AI Code Generation

1using PuppeteerSharp;2using System.Threading.Tasks;3using System.Threading;4using System;5using System.Diagnostics;6using System.Text;7using System.IO;8{9    {10        static async Task Main(string[] args)11        {12            var options = new LaunchOptions { Headless = true };13            using (var browser = await Puppeteer.LaunchAsync(options))14            using (var page = await browser.NewPageAsync())15            {16                await page.ScreenshotAsync("google.png");17                var task = new MessageTask();18                task.ApplicationName = "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe";19                task.Arguments = "google.png";20                task.RegisterTask(true);21            }22        }23    }24}

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.