How to use ShouldReturnNullIfWaitingToHideNonExistingElement method of PuppeteerSharp.Tests.WaitTaskTests.FrameWaitForSelectorTests class

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();

Try this:

public static async Task<string> ExportPdfASync(string url, string location)
{
 try
 {
   using (var browser = await Puppeteer.LaunchAsync(LaunchOptions))
   using (var page = await browser.NewPageAsync())
   {
    await page.SetViewportAsync(new ViewPortOptions() { Width = 1440, Height = 990, IsMobile = false, DeviceScaleFactor = 1.0 });

    await page.SetJavaScriptEnabledAsync(true);
    await page.GoToAsync(url);
    await page.WaitForTimeoutAsync(1500);

    var marginOptions = new MarginOptions()
    {
        Top = "10mm",
        Left = "10mm",
        Right = "10mm",
        Bottom = "10mm"
    };

    var pdfOptions = new PdfOptions()
    {
        PrintBackground = true,
        Format = PaperFormat.A4,
        MarginOptions = marginOptions,
        Landscape = landscape
    };
    await page.PdfAsync(location, pdfOptions);
  }
  }
  catch (Exception ex)
  {
  }
  finally {
    browser.CloseAsync();
    page.CloseAsync();
  }
  return "";
}

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",
    },
};

You don't need multiple browsers, you can use one browser with multiple Tabs (or Pages as Puppeteer calls them). Here's my sample code of that solves the same thing you do (convert HTML to PDF). It creates one browser instance which is handed down to four processes (could be more) which each create and remove their own Page.

public class PuppeteerSharpSample {

    public async Task CreatePdfBatch(IEnumerable<string> urlList)
    {
        await using var browser = await Puppeteer.LaunchAsync( new LaunchOptions { Headless = true, ExecutablePath ="PathToChromeOrChromium.exe"};).ConfigureAwait(false);

        await urlList.ForEachAsync(4, async url =>
            {
                await PrintPdf(url, browser).ConfigureAwait(false);
            })
            .ContinueWith(t =>
                {
                    if (t.Exception != null)
                    {
                        throw t.Exception;
                    }
                })
            .ConfigureAwait(false);
    }

    private async Task PrintPdf(Browser browser, string Url)
    {
        await using var page = await browser.NewPageAsync().ConfigureAwait(false);

        await page.GoToAsync(url).ConfigureAwait(false);

        await page.PdfAsync("pdfFileNameMustBeMadeUniqueOfCourse.pdf").ConfigureAwait(false);  
    }
}

public static class HelperClass
{
    //taken from https://scatteredcode.net/parallel-foreach-async-in-c/
    public static Task ForEachAsync<T>(this IEnumerable<T> source, int dop, Func<T, Task> body)
    {
        async Task AwaitPartition(IEnumerator<T> partition)
        {
            using (partition)
            {
                while (partition.MoveNext())
                {
                    await body(partition.Current).ContinueWith(t =>
                        {
                            if (t.IsFaulted && t.Exception != null)
                            {
                                throw t.Exception;
                            }
                        })
                        .ConfigureAwait(false);
                }
            }
        }

        return Task.WhenAll(
            Partitioner
                .Create(source)
                .GetPartitions(dop)
                .AsParallel()
                .Select(AwaitPartition));
    }
}

As a side note: you also don't need to use GetBrowser() if Chromium (can be Chrome, Chromium or the new Edge) is installed on your machine. Then you can just point to the .exe as is shown in the above code.

Technically speaking this a missing feature on the Linq methods. It's not so simple to code Async Linq functions.

On the other side, I find this much more simple to implement straight in javascript. Why? because you can test your script in your browser and then just move it to your C# code.

For instance, this method will find all li elements, find the li with a span with the text fire and then click the input.

await page.EvaluateFunctionAsync(@"() => {
     Array.from(document.querySelectorAll('li'))
         .find(l => l.querySelector('span').innerText === 'fire').querySelector('INPUT').click();
}");

If you are using CSS selector as a locator then you haven't provided correct locator.

You can try following CSS Selector which should work.

Using Type attribute

await page.ClickAsync("button[type='submit']");

OR Using name attribute

 await page.ClickAsync("button[name='login-submit']");

OR using class attribute

await page.ClickAsync("button.inline-btn-2");

OR Using multiple attribute such as

await page.ClickAsync("button[type='submit'][name='login-submit']");

If you want to get an element from the browser you should get an ElementHandle, which is a pointer to an element in the browser, using EvaluateExpressionHandleAsync:

var element = await page.EvaluateExpressionHandleAsync($"document.querySelectorAll('[{attributeName}=\"{attributeValue}\"]')[0];");

You can use the LaunchOptions.ExecutablePath property. If you use ExecutablePath you don't even need to call BrowserFetcher. It would look something like this:

var options = new LaunchOptions
{
    Headless = true,
    ExecutablePath = "<CHROME.EXE FULL PATH>"
};

using (var browser = await Puppeteer.LaunchAsync(options))
{
}

How to use PuppeteerSharp inside an UWP App?

PuppeteerSharp does not support in UWP, You could check PuppeteerSharp source code to verify this. This is DownloadsFolder = Path.Combine(Directory.GetCurrentDirectory(), ".local-chromium") and matched path is "{AppRoot}\bin\x86\Debug\AppX.local-chromium". In the following code we call Create method in it, but above path is read-only in UWP.

    public async Task<RevisionInfo> DownloadAsync(int revision)
    {
        var url = GetDownloadURL(Platform, DownloadHost, revision);
        var zipPath = Path.Combine(DownloadsFolder, $"download-{Platform.ToString()}-{revision}.zip");
        var folderPath = GetFolderPath(revision);

        if (new DirectoryInfo(folderPath).Exists)
        {
            return RevisionInfo(revision);
        }

        var downloadFolder = new DirectoryInfo(DownloadsFolder);
        if (!downloadFolder.Exists)
        {
            downloadFolder.Create();
        }

        if (DownloadProgressChanged != null)
        {
            _webClient.DownloadProgressChanged += DownloadProgressChanged;
        }
        await _webClient.DownloadFileTaskAsync(new Uri(url), zipPath).ConfigureAwait(false);

        if (Platform == Platform.MacOS)
        {
            //ZipFile and many others unzip libraries have issues extracting .app files
            //Until we have a clear solution we'll call the native unzip tool
            //https://github.com/dotnet/corefx/issues/15516
            NativeExtractToDirectory(zipPath, folderPath);
        }
        else
        {
            ZipFile.ExtractToDirectory(zipPath, folderPath);
        }

        new FileInfo(zipPath).Delete();

        var revisionInfo = RevisionInfo(revision);

        if (revisionInfo != null && GetCurrentPlatform() == Platform.Linux)
        {
            LinuxSysCall.Chmod(revisionInfo.ExecutablePath, LinuxSysCall.ExecutableFilePermissions);
        }
        return revisionInfo;
    }