notebooks/playwright.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "[1. Install Playwright CLI](#1-install-playwright-cli)<br>\n",
    "[2. Save session state](#2-save-session-state)<br>\n",
    "[3. Configuring screenshots](#3-configuring-screenshots)<br>\n",
    "[4. Playwright Extension methods](#4-playwright-extension-methods)<br>\n",
    "[5. Running Playwright](#5-running-playwright)<br>\n",
    "[6. Generate screenshot documentation](#6-generate-screenshot-documentation)<br>\n",
    "[7. Example 1: Retrieve Solution rows and display the ](#7-example-1-retrieve-solution-rows-and-display-the-solutionid-of-default-solution)<br>\n",
    "[8. Example 2 - Create new Opportunity record](#8-example-2---create-new-opportunity-record)<br>\n",
    "[9. More about Playwright](#9-more-about-playwright)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Install Playwright CLI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can install [Playwright](https://playwright.dev/) as a dotnet global tool or as a npm global package. In this example we will install Playwright as a global tool using .NET CLI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!powershell\n",
    "dotnet tool install --global Microsoft.Playwright.CLI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Save session state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any application that requires login, still saves the state (logged in or not) using cookies. If you start a new session with the previously captured session state, the application consideres you as having \"logged in\", even though you did not enter your credentials.\n",
    "\n",
    "The code block below creates an empty project, installs the browsers (Chromium, Firefox and Webkit) and opens Chromium in \"automation\" mode. In this new browser window, navigate to the Power Apps application, login with you credentials, and close the window after you have logged in.\n",
    "\n",
    "Run this code below only if you need to re-record your Power Apps login to create `auth.json`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#!powershell\n",
    "\n",
    "Get-Location;\n",
    "\n",
    "# Create project\n",
    "dotnet new console -n PlaywrightDemo\n",
    "cd PlaywrightDemo\n",
    "\n",
    "# Install dependencies, build project and download necessary browsers.\n",
    "dotnet add package Microsoft.Playwright\n",
    "dotnet build\n",
    "playwright install\n",
    "\n",
    "#start recording the browser\n",
    "playwright codegen --save-storage=../../auth.json\n",
    "\n",
    "cd..\n",
    "Remove-Item ./PlaywrightDemo -Force -Recurse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "After running the commands the session state will be captured in a file called `auth.json`. There are only two cookies needed for Power Apps to consider you as \"logged in\". They are\n",
    "\n",
    "1. _CrmOwinAuth_\n",
    "2. _ESTSAUTHPERSISTENT_\n",
    "\n",
    "You can remove all the other information except these two. Below is a sample for `auth.json`. If you want to leave this file as it is, it is OK was well.\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"cookies\": [\n",
    "    {\n",
    "      \"sameSite\": \"None\",\n",
    "      \"name\": \"CrmOwinAuth\",\n",
    "      \"value\": \"REMOVED\",\n",
    "      \"domain\": \".crm.dynamics.com\",\n",
    "      \"path\": \"/\",\n",
    "      \"expires\": 1953359538.945023,\n",
    "      \"httpOnly\": true,\n",
    "      \"secure\": true\n",
    "    },\n",
    "    {\n",
    "      \"sameSite\": \"None\",\n",
    "      \"name\": \"ESTSAUTHPERSISTENT\",\n",
    "      \"value\": \"REMOVED\",\n",
    "      \"path\": \"/\",\n",
    "      \"expires\": 1645602747.992615,\n",
    "      \"httpOnly\": true,\n",
    "      \"secure\": true\n",
    "    }\n",
    "  ]\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to install the Playwright package on the Notebook, so that we can run some automation from this Notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "#r \"nuget:Microsoft.Playwright\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Configuring screenshots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[screenshots.config.json](screenshots.config.json) is where you specify the title of the screeshot, file name of the screenshot and URL to navigate to. Below is an example config.\n",
    "\n",
    "```json\n",
    "[\n",
    "    {\n",
    "        \"title\": \"Home\",\n",
    "        \"fileName\": \"Home\",\n",
    "        \"url\": \"https://make.powerapps.com\",\n",
    "        \"description\": \"This is the Maker portal.\"\n",
    "    },\n",
    "    {\n",
    "        \"title\": \"Customer Service App\",\n",
    "        \"fileName\": \"Model Driven App\",\n",
    "        \"url\": \"https://org.crm6.dynamics.com/main.aspx?appid=fc4884b2-6119-e811-a94f-000d3ae060f6\",\n",
    "        \"description\": \"This is the customer service app used by all agents.\"\n",
    "    }\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The snippet below reads code from the config file and prompts the user for the URL of the model-driven app. This URL will be used in [Example 1](#7-example-1-retrieve-solution-rows-and-display-the-solutionid-of-default-solution) and [Example 2](#8-example-2---create-new-opportunity-record)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.Playwright;\n",
    "using System.Threading.Tasks;\n",
    "using System.IO;\n",
    "using System.Text.Json;\n",
    "using static Microsoft.DotNet.Interactive.Formatting.PocketViewTags;\n",
    "\n",
    "record Config(string fileName, string url, string title, string description);\n",
    "var config = JsonSerializer.Deserialize<Config[]>(File.ReadAllText(\"screenshots.config.json\"));\n",
    "\n",
    "var url = await GetInputAsync(\"Enter model driven app URL\");\n",
    "// var url = \"https://env.crm6.dynamics.com/main.aspx?appid=f55f77d7-e05d-e911-a866-000d3ae0eb8e&forceUCI=1\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Playwright Extension methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's setup some extension methods, to make it easy to use Playwright along with model-driven apps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using Microsoft.Playwright;\n",
    "using static System.Text.Json.JsonElement;\n",
    "using System;\n",
    "using System.Threading.Tasks;\n",
    "using System.Diagnostics;\n",
    "\n",
    "\n",
    "public static async Task<ArrayEnumerator> RetrieveMultiple(this IPage page, RetrieveMultipleOptions options)\n",
    "{\n",
    "    var records = await page.EvaluateAsync(@\"async(options) => {\n",
    "        var records = await Xrm.WebApi.online.retrieveMultipleRecords(options.entity, options.query);\n",
    "        return records; \n",
    "    }\", options);\n",
    "    var result = records.Value.GetProperty(\"entities\").EnumerateArray();\n",
    "\n",
    "    return result;\n",
    "}\n",
    "\n",
    "public static async Task<ObjectEnumerator> Retrieve(this IPage page, RetrieveOptions options)\n",
    "{\n",
    "    var records = await page.EvaluateAsync(@\"async(options) => {\n",
    "        var record = await Xrm.WebApi.online.retrieveRecord(options.entity, options.id, options.query);\n",
    "        return record; \n",
    "    }\", options);\n",
    "    var result = records.GetValueOrDefault().EnumerateObject();\n",
    "\n",
    "    return result;\n",
    "}\n",
    "\n",
    "public static async Task<Guid> Create(this IPage page, CreateOptions options)\n",
    "{\n",
    "    var records = await page.EvaluateAsync(@\"async(options) => {\n",
    "        var record = await Xrm.WebApi.online.createRecord(options.entity, options.data);\n",
    "        return record; \n",
    "    }\", options);\n",
    "    var result = records.GetValueOrDefault().GetProperty(\"id\").GetGuid();\n",
    "\n",
    "    return result;\n",
    "}\n",
    "\n",
    "public static async Task<Guid> Update(this IPage page, UpdateOptions options)\n",
    "{\n",
    "    var records = await page.EvaluateAsync(@\"async(options) => {\n",
    "        var record = await Xrm.WebApi.online.updateRecord(options.entity, options.id, options.data);\n",
    "        return record; \n",
    "    }\", options);\n",
    "    var result = records.GetValueOrDefault().GetProperty(\"id\").GetGuid();\n",
    "\n",
    "    return result;\n",
    "}\n",
    "\n",
    "public static async Task<Guid> Delete(this IPage page, DeleteOptions options)\n",
    "{\n",
    "    var records = await page.EvaluateAsync(@\"async(options) => {\n",
    "        var record = await Xrm.WebApi.online.deleteRecord(options.entity, options.id);\n",
    "        return record; \n",
    "    }\", options);\n",
    "    var result = records.GetValueOrDefault().GetProperty(\"id\").GetGuid();\n",
    "\n",
    "    return result;\n",
    "}\n",
    "\n",
    "public static async Task<PowerAppsPage> OpenView(this IPage page, OpenOptions options)\n",
    "{\n",
    "    await page.WaitForFunctionAsync(\"window.Xrm !== undefined\");\n",
    "\n",
    "    await page.RunAndWaitForNavigationAsync(async () =>\n",
    "    {\n",
    "            await page.EvaluateAsync(@\"async(options) => {\n",
    "            await Xrm.Navigation.navigateTo({\n",
    "                pageType: 'entitylist',\n",
    "                entityName: options.entity\n",
    "            })\n",
    "        }\", options);\n",
    "    });\n",
    "\n",
    "    await page.Locator($\"div[data-id^=\\\"data-set-body-container\\\"]\").WaitForAsync();\n",
    "    return new PowerAppsPage(page, PageType.View);\n",
    "}\n",
    "\n",
    "public static async Task<PowerAppsFormPage> OpenRecord(this IPage page, OpenOptions options)\n",
    "{\n",
    "    await page.WaitForFunctionAsync(\"window.Xrm !== undefined\");\n",
    "\n",
    "    await page.RunAndWaitForNavigationAsync(async () =>\n",
    "    {\n",
    "        if (options.id != null)\n",
    "        {\n",
    "            await page.EvaluateAsync(@$\"async(options) => {{\n",
    "            await Xrm.Navigation.navigateTo({{\n",
    "                pageType: 'entityrecord',\n",
    "                entityName: options.entity,\n",
    "                entityId: '{options.id.ToString().ToLower()}'\n",
    "            }})\n",
    "        }}\", options);\n",
    "        }\n",
    "        else\n",
    "        {\n",
    "            await page.EvaluateAsync(@\"async(options) => {\n",
    "            await Xrm.Navigation.navigateTo({\n",
    "                pageType: 'entityrecord',\n",
    "                entityName: options.entity\n",
    "            })\n",
    "        }\", options);\n",
    "        }\n",
    "    });\n",
    "\n",
    "    await page.Locator($\"div[id^=\\\"tab-section\\\"]\").WaitForAsync();\n",
    "    return new PowerAppsFormPage(page, PageType.Form);\n",
    "}\n",
    "\n",
    "public enum PageType\n",
    "{\n",
    "    View,\n",
    "    Form\n",
    "}\n",
    "\n",
    "public class PowerAppsPage\n",
    "{\n",
    "    protected IPage _page;\n",
    "    private PageType _pageType;\n",
    "    public PowerAppsPage(IPage page, PageType pageType)\n",
    "    {\n",
    "        _page = page;\n",
    "        _pageType = pageType;\n",
    "    }\n",
    "    public async Task<PowerAppsFormPage> NewRecord() {\n",
    "        await _page.RunAndWaitForNavigationAsync(async () => await _page.ClickAsync(\"[aria-label=\\\"New\\\"]\"));\n",
    "        return new PowerAppsFormPage(_page, PageType.Form);\n",
    "    }\n",
    "}\n",
    "\n",
    "public class PowerAppsFormPage : PowerAppsPage\n",
    "{\n",
    "    public PowerAppsFormPage(IPage page, PageType pageType) : base(page, pageType)\n",
    "    {\n",
    "    }\n",
    "\n",
    "    public async void SetFieldValue(string field, string text) {\n",
    "        await _page.ClickAsync($\"input[id*=\\\"{field}\\\"]\");\n",
    "        await _page.FillAsync($\"input[id*=\\\"{field}\\\"]\", text);\n",
    "    }    \n",
    "\n",
    "    public async Task<IResponse> Save() => await _page.RunAndWaitForNavigationAsync(async () => await _page.ClickAsync(\"[aria-label=\\\"Save (CTRL+S)\\\"]\"));\n",
    "\n",
    "    public async Task<IResponse> SaveAndClose() => await _page.RunAndWaitForNavigationAsync(async () => await _page.ClickAsync(\"[aria-label=\\\"Save & Close\\\"]\"));\n",
    "\n",
    "    public async Task<Guid> GetRecordId()\n",
    "    {\n",
    "        await _page.WaitForFunctionAsync(\"window.Xrm !== undefined\");\n",
    "        var recordId = await _page.EvaluateAsync(@\"()=>Xrm.Utility.getPageContext().input.entityId\");\n",
    "        var result = recordId.GetValueOrDefault().GetProperty(\"entityId\").GetGuid();\n",
    "        return result;\n",
    "    }    \n",
    "}\n",
    "\n",
    "public record RetrieveOptions(string entity, Guid id, string query);\n",
    "public record RetrieveMultipleOptions(string entity, string query);\n",
    "public record CreateOptions(string entity, string data);\n",
    "public record UpdateOptions(string entity, Guid id, string data);\n",
    "public record DeleteOptions(string entity, Guid id);\n",
    "public record OpenOptions(string entity, Guid? id = null);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Running Playwright"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we now have the `auth.json` file with the persisted cookies we can start a new browser session with the pre-save cookie information. It will navigate us straight to the URLs mentioned in the config file, with no login screen at all. The cookies are valid for approximately 2 weeks. So, you might get error after the cookie expires. If that is the case, you need to run [Save Session State](#2-save-session-state) step again, to create a new `auth.json`. \n",
    "\n",
    "`auth.json` contains sensitive information, so it is ignored on `.gitignore`, so <ins>do not</ins> commit this to source control."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using (var playwright = await Playwright.CreateAsync())\n",
    "{\n",
    "        //Use this if you are behind a proxy\n",
    "        // var browser = await playwright.Firefox.LaunchAsync(new BrowserTypeLaunchOptions\n",
    "        // {\n",
    "        //     Headless = false,\n",
    "        //     Proxy = new Proxy{Server=\"\"}\n",
    "        // });\n",
    "        var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions{ Timeout=60000, Headless = false });        \n",
    "        var context = await browser.NewContextAsync(new BrowserNewContextOptions { \n",
    "            StorageStatePath = \"../auth.json\",\n",
    "            RecordVideoDir = \"../videos\",\n",
    "            RecordVideoSize = new RecordVideoSize() { Width = 1920, Height = 1080 }\n",
    "        });\n",
    "        var page = await context.NewPageAsync();\n",
    "        await page.SetViewportSizeAsync(1920, 1080);\n",
    "        foreach (var c in config)\n",
    "        {\n",
    "            await page.GotoAsync(c.url);\n",
    "            await page.WaitForLoadStateAsync(LoadState.NetworkIdle);\n",
    "            await page.ScreenshotAsync(new PageScreenshotOptions { Path = $\"../screenshots/{c.fileName}.png\" });            \n",
    "        }\n",
    "        await context.CloseAsync();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the above code has finished running you would also find a video of the recorded session inside the [videos](../videos/) folder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Generate screenshot documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can dynamically add the screenshot document and text using the Notebook itself by running the snippet below. The whole interaction is also recorded and a recording can be found in the [videos](./videos) folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using static Microsoft.DotNet.Interactive.Formatting.PocketViewTags;\n",
    "\n",
    "var screenshot = div(\n",
    "    h1(summary($\"Screenshots as of {DateTime.Now.ToString()}\")),\n",
    "    details(\n",
    "        config.Select(c => \n",
    "            div(\n",
    "                h2(c.title),\n",
    "                div(c.description),\n",
    "                br,\n",
    "                img[src:$\"../screenshots/{c.fileName}.png\",width:960, height: 540]\n",
    "            )\n",
    "        )\n",
    "    )\n",
    ");\n",
    "display(screenshot);\n",
    "\n",
    "//START: Remove this if you don't want the screenshot HTML to be saved into a file\n",
    "if(!Directory.Exists(\"../documentation\")) Directory.CreateDirectory(\"../documentation\");\n",
    "\n",
    "File.WriteAllText($\"../documentation/{DateTime.Now.ToString(\"yyyy_MM_dd_HH_mm\")}.html\", @$\"<!DOCTYPE html>\n",
    "<html lang=\"\"en\"\">\n",
    "<head>\n",
    "    <meta charset=\"\"UTF-8\"\">\n",
    "    <meta http-equiv=\"\"X-UA-Compatible\"\" content=\"\"IE=edge\"\">\n",
    "    <meta name=\"\"viewport\"\" content=\"\"width=device-width, initial-scale=1.0\"\">\n",
    "</head>\n",
    "<body>\n",
    "    {screenshot}\n",
    "</body>\n",
    "</html>\");\n",
    "//END"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Example 1: Retrieve Solution rows and display the `solutionid` of _Default Solution_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `EvaluateAsync` to execute arbitary JavaScript in the context of a page. The result from JavaScript can be utilised in C#."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using (var playwright = await Playwright.CreateAsync())\n",
    "{\n",
    "    //Use this if you are behind a proxy\n",
    "    // var browser = await playwright.Firefox.LaunchAsync(new BrowserTypeLaunchOptions\n",
    "    // {\n",
    "    //     Headless = false,\n",
    "    //     Proxy = new Proxy{Server=\"\"}\n",
    "    // });\n",
    "    var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions{Timeout=60000, Headless=false});        \n",
    "    var context = await browser.NewContextAsync(new BrowserNewContextOptions { \n",
    "        StorageStatePath = \"../auth.json\"\n",
    "    });\n",
    "    var page = await context.NewPageAsync();\n",
    "    await page.SetViewportSizeAsync(1920, 1080);\n",
    "    await page.GotoAsync(url);\n",
    "    await page.WaitForFunctionAsync(\"window.Xrm !== undefined\");\n",
    "\n",
    "    var appName = await page.EvaluateAsync(\"Xrm.Utility.getGlobalContext().getCurrentAppName()\");\n",
    "\n",
    "    var solutionName = \"Default Solution\";\n",
    "    var solutions = await page.RetrieveMultiple(new RetrieveMultipleOptions(\"solution\", $@\"?$select=friendlyname&$filter=isvisible eq true and friendlyname eq '{solutionName}'\"));    \n",
    "    display(div(h3(\"Result\"),div(ol(li($\"The current app name: \", i(appName.Value.GetString())), li($\"Solution Guid: \", i(solutions.First().GetProperty(\"solutionid\").GetString()))))));\n",
    "    await context.CloseAsync();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Example 2 - Create new Opportunity record"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    }
   },
   "outputs": [],
   "source": [
    "using (var playwright = await Playwright.CreateAsync())\n",
    "{\n",
    "    //Use this if you are behind a proxy\n",
    "    // var browser = await playwright.Firefox.LaunchAsync(new BrowserTypeLaunchOptions\n",
    "    // {\n",
    "    //     Headless = false,\n",
    "    //     Proxy = new Proxy{Server=\"\"}\n",
    "    // });\n",
    "    var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions{Timeout=60000, Headless=false}); \n",
    "    try\n",
    "    {               \n",
    "        var context = await browser.NewContextAsync(new BrowserNewContextOptions { \n",
    "            StorageStatePath = \"../auth.json\"     \n",
    "        });\n",
    "        var page = await context.NewPageAsync();\n",
    "        await page.SetViewportSizeAsync(1920, 1080);\n",
    "        await page.GotoAsync(url);\n",
    "\n",
    "        var view = await page.OpenView(new OpenOptions(\"opportunity\"));\n",
    "\n",
    "        var record = await view.NewRecord();\n",
    "        record.SetFieldValue(\"name\", \"Interactive Notebook\");\n",
    "        await record.Save();\n",
    "        await page.WaitForFunctionAsync(\"Xrm.Utility.getPageContext().input.entityId != undefined\");\n",
    "        var recordId = await page.EvaluateAsync(\"Xrm.Utility.getPageContext().input.entityId\");\n",
    "        var appUrl = await page.EvaluateAsync(\"Xrm.Utility.getGlobalContext().getCurrentAppUrl()\");\n",
    "        display(div(span(\"New Opportunity record created -> \"),a[href:$\"{appUrl}&pagetype=entityrecord&etn=opportunity&id={recordId}\"](\"New Opportunity\")));\n",
    "    }\n",
    "    catch (Exception ex)\n",
    "    {\n",
    "        Console.WriteLine(ex.Message);\n",
    "    }\n",
    "    finally\n",
    "    {\n",
    "        await browser.CloseAsync();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. More about Playwright"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Playwright documentation](https://playwright.dev/dotnet/docs/api/class-playwright)\n",
    "2. [Playwright YouTube](https://www.youtube.com/channel/UC46Zj8pDH5tDosqm1gd7WTg)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "name": "C#"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}