How to use WaitForRequest method of PuppeteerSharp.TestServer.SimpleServer class

After reading this issue, it seems that we should use absolute path with UserDataDir, so this works fine:

browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
    Headless = true,
    UserDataDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ".local-chromium", "Win64-884014", "chrome-win", "UserData").Replace(@"\", @"\\")
});

But another problem appeared because browser doesn't save any cookie. Again, some issues on github said that the browser should be closed in order to save the cookies. I tried this:

await page.CloseAsync();
await browser.CloseAsync();

But it doesn't works as expected because the browser is still running in the background. The final solution for my was this:

var chromes = System.Diagnostics.Process.GetProcesses().Where(x => x.ProcessName == "chrome").ToList();

foreach (var ch in chromes)
{
    try
    {
        ch.Kill();
    }
    catch
    {
    }
}

The above code will close all chrome browsers, so it may need some changes in order to close the current browser only.

To use XPath based and not CSS selection use page.XPathAsync(xpath-expression) e.g.

var tds = page.XPathAsync(".//td[contains(., 'ABC-DEF-GHI')]");
await tds[0].ClickAsync();

Should be due to PuppeteerSharp requires to run on Linux system in Azure (which can download and install Chromium by coding). If want to test on Windows, need to pre-install Chrome/Chromium and add ExecutablePath in LaunchOptions

// DEBUG: for running on local
ExecutablePath = "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"

Please share if you have other solutions.

I found this is the most scalable way to implement this is by using a background process. This is one real-life example:

1. A WebClient request a PDF sending a signalR message.
2. The SignalR hub creates some kind of an ID, put the request in an Azure Queue, and adds the SignalR client to a SignalR group with that ID.
3. A console app would read that queue, process the HTML, and sends back the result to the server using a SignalR message.
4. The WebServer will get the message, and broadcast that message to all the clients in that group.

It might sound quite complicated, but it's not that much. You can make it simpler.

Try to disable some of the security features that can be disabled when launching puppeteer.

Check in puppeteer chrome://flags/ in case there's something blocking iframe access, maybe is insecure content or maybe you have to be explicit about isolation trial.

My 2 cents on this, it should allow it to access it from non secure

Args = new[]
    {
        "--disable-web-security",
        "--disable-features=IsolateOrigins,site-per-process,BlockInsecurePrivateNetworkRequests",
        "--disable-site-isolation-trials"
    }

This may be due to CORS.

Try the following code.

var options = new LaunchOptions
{
    Devtools = true,
    Args = new[]
    {
        "--disable-web-security",
        "--disable-features=IsolateOrigins,site-per-process",
    },
};

using below,

using var page = browser.NewPageAsync().Result;

page.TypeAsync("input[name='elementname']", valuetobeset).Wait();

So my problem was happening because errors are apparently not serializable in javascript land, so we need to get the browser to run a function to extract the message and any other details we need from the error and return that.

This is what's working for me right now:

_page.Console += async (sender, args) =>
{
    switch (args.Message.Type)
    {
        case ConsoleType.Error:
            try
            {
                var errorArgs = await Task.WhenAll(args.Message.Args.Select(arg => arg.ExecutionContext.EvaluateFunctionAsync("(arg) => arg instanceof Error ? arg.message : arg", arg)));
                _logger.LogError($"{args.Message.Text} args: [{string.Join<object>(", ", errorArgs)}]");
            }
            catch { }
            break;
        case ConsoleType.Warning:
            _logger.LogWarning(args.Message.Text);
            break;
        default:
            _logger.LogInformation(args.Message.Text);
            break;
    }
};

I got the idea from a comment from one of the puppeteer contributors here and ported it to pupeteer-sharp.

The way it's supposed to be done atm is like this:

page.on('console', async msg => {
  // serialize my args the way I want
  const args = await Promise.all(msg.args.map(arg => arg.executionContext().evaluate(arg => {
    // I'm in a page context now. If my arg is an error - get me its message.
    if (arg instanceof Error)
      return arg.message;
    // return arg right away. since we use `executionContext.evaluate`, it'll return JSON value of
    // the argument if possible, or `undefined` if it fails to stringify it.
    return arg;
  }, arg)));
  console.log(...args);
});

You should be able to do

await page.EvaluateExpressionAsync("window.scrollBy(0, window.innerHeight)");