playwright-ruby-client 0.5.10 → 0.6.0

data/lib/playwright/download.rb

@@ -1,12 +1,13 @@
 module Playwright
   class Download
-    def initialize(url:, suggested_filename:, artifact:)
+    def initialize(page:, url:, suggested_filename:, artifact:)
+      @page = page
       @url = url
       @suggested_filename = suggested_filename
       @artifact = artifact
     end
 
-    attr_reader :url, :suggested_filename
+    attr_reader :page, :url, :suggested_filename
 
     def delete
       @artifact.delete

data/lib/playwright/events.rb

@@ -28,6 +28,10 @@ end
     Close: 'close',
     Page: 'page',
     ServiceWorker: 'serviceworker',
+    Request: 'request',
+    Response: 'response',
+    RequestFailed: 'requestfailed',
+    RequestFinished: 'requestfinished',
   },
 
   BrowserServer: {

data/lib/playwright/tracing_impl.rb

@@ -0,0 +1,31 @@
+module Playwright
+  define_api_implementation :TracingImpl do
+    def initialize(channel, context)
+      @channel = channel
+      @context = context
+    end
+
+    def start(name: nil, screenshots: nil, snapshots: nil)
+      params = {
+        name: name,
+        screenshots: screenshots,
+        snapshots: snapshots,
+      }.compact
+      @channel.send_message_to_server('tracingStart', params)
+    end
+
+    # Stop tracing.
+    def stop
+      @channel.send_message_to_server('tracingStop')
+    end
+
+    def export(path)
+      resp = @channel.send_message_to_server('tracingExport')
+      artifact = ChannelOwners::Artifact.from(resp)
+      # if self._context._browser:
+      #   artifact._is_remote = self._context._browser._is_remote
+      artifact.save_as(path)
+      artifact.delete
+    end
+  end
+end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.5.10'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.11.0'
+  VERSION = '0.6.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.12.0'
 end

data/lib/playwright_api/accessibility.rb

@@ -44,8 +44,8 @@ module Playwright
     # ```
     # 
     # ```csharp
-    # var accessibilitySnapshot = await Page.Accessibility.SnapshotAsync();
-    # Console.WriteLine(accessibilitySnapshot);
+    # var accessibilitySnapshot = await page.Accessibility.SnapshotAsync();
+    # Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(accessibilitySnapshot));
     # ```
     # 
     # An example of logging the focused node's name:
@@ -68,7 +68,7 @@ module Playwright
     # ```
     # 
     # ```csharp
-    # Func<AccessibilitySnapshotResult, AccessibilitySnapshotResult> findFocusedNode = root =>
+    # static AccessibilitySnapshotResult findFocusedNode(AccessibilitySnapshotResult root)
     # {
     #     var nodes = new Stack<AccessibilitySnapshotResult>(new[] { root });
     #     while (nodes.Count > 0)
@@ -82,12 +82,13 @@ module Playwright
     #     }
     # 
     #     return null;
-    # };
+    # }
     # 
-    # var accessibilitySnapshot = await Page.Accessibility.SnapshotAsync();
+    # var accessibilitySnapshot = await page.Accessibility.SnapshotAsync();
+    # Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(accessibilitySnapshot));
     # var focusedNode = findFocusedNode(accessibilitySnapshot);
-    # if(focusedNode != null)
-    #   Console.WriteLine(focusedNode.Name);
+    # if (focusedNode != null)
+    #     Console.WriteLine(focusedNode.Name);
     # ```
     # 
     # ```java

data/lib/playwright_api/android.rb

@@ -64,7 +64,7 @@ module Playwright
   # via setting the following environment variable when installing Playwright:
   # 
   # ```sh js
-  # $ PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm i -D playwright
+  # PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm i -D playwright
   # ```
   class Android < PlaywrightApi
 

data/lib/playwright_api/browser.rb

@@ -61,6 +61,24 @@ module Playwright
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
+  # 
+  # ```csharp
+  # using Microsoft.Playwright;
+  # using System.Threading.Tasks;
+  # 
+  # class BrowserExamples
+  # {
+  #     public static async Task Main()
+  #     {
+  #         using var playwright = await Playwright.CreateAsync();
+  #         var firefox = playwright.Firefox;
+  #         var browser = await firefox.LaunchAsync(headless: false);
+  #         var page = await browser.NewPageAsync();
+  #         await page.GotoAsync("https://www.bing.com");
+  #         await browser.CloseAsync();
+  #     }
+  # }
+  # ```
   class Browser < PlaywrightApi
 
     # In case this browser is obtained using [`method: BrowserType.launch`], closes the browser and all of its pages (if any
@@ -105,6 +123,14 @@ module Playwright
     # context = browser.new_context()
     # print(len(browser.contexts())) # prints `1`
     # ```
+    # 
+    # ```csharp
+    # using var playwright = await Playwright.CreateAsync();
+    # var browser = await playwright.Webkit.LaunchAsync();
+    # System.Console.WriteLine(browser.Contexts.Count); // prints "0"
+    # var context = await browser.NewContextAsync();
+    # System.Console.WriteLine(browser.Contexts.Count); // prints "1"
+    # ```
     def contexts
       wrap_impl(@impl.contexts)
     end
@@ -161,6 +187,16 @@ module Playwright
     # page = context.new_page()
     # page.goto("https://example.com")
     # ```
+    # 
+    # ```csharp
+    # using var playwright = await Playwright.CreateAsync();
+    # var browser = await playwright.Firefox.LaunchAsync();
+    # // Create a new incognito browser context.
+    # var context = await browser.NewContextAsync();
+    # // Create a new page in a pristine context.
+    # var page = await context.NewPageAsync(); ;
+    # await page.GotoAsync("https://www.bing.com");
+    # ```
     def new_context(
           acceptDownloads: nil,
           bypassCSP: nil,
@@ -237,6 +273,13 @@ module Playwright
     # await browser.stopTracing();
     # ```
     # 
+    # ```java
+    # browser.startTracing(page, new Browser.StartTracingOptions()
+    #   .setPath(Paths.get("trace.json")));
+    # page.goto('https://www.google.com');
+    # browser.stopTracing();
+    # ```
+    # 
     # ```python async
     # await browser.start_tracing(page, path="trace.json")
     # await page.goto("https://www.google.com")

data/lib/playwright_api/browser_context.rb

@@ -26,7 +26,7 @@ module Playwright
   # // Create a new page inside context.
   # Page page = context.newPage();
   # page.navigate("https://example.com");
-  # // Dispose context once it"s no longer needed.
+  # // Dispose context once it is no longer needed.
   # context.close();
   # ```
   # 
@@ -36,7 +36,7 @@ module Playwright
   # # create a new page inside context.
   # page = await context.new_page()
   # await page.goto("https://example.com")
-  # # dispose context once it"s no longer needed.
+  # # dispose context once it is no longer needed.
   # await context.close()
   # ```
   # 
@@ -46,11 +46,27 @@ module Playwright
   # # create a new page inside context.
   # page = context.new_page()
   # page.goto("https://example.com")
-  # # dispose context once it"s no longer needed.
+  # # dispose context once it is no longer needed.
   # context.close()
   # ```
+  # 
+  # ```csharp
+  # using var playwright = await Playwright.CreateAsync();
+  # var browser = await playwright.Firefox.LaunchAsync(headless: false);
+  # // Create a new incognito browser context
+  # var context = await browser.NewContextAsync();
+  # // Create a new page inside context.
+  # var page = await context.NewPageAsync();
+  # await page.GotoAsync("https://bing.com");
+  # // Dispose context once it is no longer needed.
+  # await context.CloseAsync();
+  # ```
   class BrowserContext < PlaywrightApi
 
+    def tracing # property
+      wrap_impl(@impl.tracing)
+    end
+
     # Adds cookies into this browser context. All pages within this context will have these cookies installed. Cookies can be
     # obtained via [`method: BrowserContext.cookies`].
     # 
@@ -70,6 +86,10 @@ module Playwright
     # ```python sync
     # browser_context.add_cookies([cookie_object1, cookie_object2])
     # ```
+    # 
+    # ```csharp
+    # await context.AddCookiesAsync(new[] { cookie1, cookie2 });
+    # ```
     def add_cookies(cookies)
       wrap_impl(@impl.add_cookies(unwrap_impl(cookies)))
     end
@@ -113,6 +133,10 @@ module Playwright
     # browser_context.add_init_script(path="preload.js")
     # ```
     # 
+    # ```csharp
+    # await context.AddInitScriptAsync(scriptPath: "preload.js");
+    # ```
+    # 
     # > NOTE: The order of evaluation of multiple scripts installed via [`method: BrowserContext.addInitScript`] and
     # [`method: Page.addInitScript`] is not defined.
     def add_init_script(path: nil, script: nil)
@@ -166,6 +190,15 @@ module Playwright
     # # do stuff ..
     # context.clear_permissions()
     # ```
+    # 
+    # ```csharp
+    # var context = await browser.NewContextAsync();
+    # await context.GrantPermissionsAsync(new[] { "clipboard-read" });
+    # // Alternatively, you can use the helper class ContextPermissions 
+    # //  to specify the permissions...
+    # // do stuff ...
+    # await context.ClearPermissionsAsync();
+    # ```
     def clear_permissions
       wrap_impl(@impl.clear_permissions)
     end
@@ -291,6 +324,32 @@ module Playwright
     #     run(playwright)
     # ```
     # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System.Threading.Tasks;
+    # 
+    # class Program
+    # {
+    #     public static async Task Main()
+    #     {
+    #         using var playwright = await Playwright.CreateAsync();
+    #         var browser = await playwright.Webkit.LaunchAsync(headless: false);
+    #         var context = await browser.NewContextAsync();
+    # 
+    #         await context.ExposeBindingAsync("pageURL", source => source.Page.Url);
+    #         var page = await context.NewPageAsync();
+    #         await page.SetContentAsync("<script>\n" +
+    #         "  async function onClick() {\n" +
+    #         "    document.querySelector('div').textContent = await window.pageURL();\n" +
+    #         "  }\n" +
+    #         "</script>\n" +
+    #         "<button onclick=\"onClick()\">Click me</button>\n" +
+    #         "<div></div>");
+    #         await page.ClickAsync("button");
+    #     }
+    # }
+    # ```
+    # 
     # An example of passing an element handle:
     # 
     #
@@ -348,6 +407,26 @@ module Playwright
     #   <div>Or click me</div>
     # """)
     # ```
+    # 
+    # ```csharp
+    # var result = new TaskCompletionSource<string>();
+    # var page = await Context.NewPageAsync();
+    # await Context.ExposeBindingAsync("clicked", async (BindingSource _, IJSHandle t) =>
+    # {
+    #     return result.TrySetResult(await t.AsElement.TextContentAsync());
+    # });
+    # 
+    # await page.SetContentAsync("<script>\n" +
+    #   "  document.addEventListener('click', event => window.clicked(event.target));\n" +
+    #   "</script>\n" +
+    #   "<div>Click me</div>\n" +
+    #   "<div>Or click me</div>\n");
+    # 
+    # await page.ClickAsync("div");
+    # // Note: it makes sense to await the result here, because otherwise, the context 
+    # //  gets closed and the binding function will throw an exception.
+    # Assert.Equal("Click me", await result.Task);
+    # ```
     def expose_binding(name, callback, handle: nil)
       wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback), handle: unwrap_impl(handle)))
     end
@@ -487,6 +566,43 @@ module Playwright
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
+    # 
+    # ```csharp
+    # using Microsoft.Playwright;
+    # using System;
+    # using System.Security.Cryptography;
+    # using System.Threading.Tasks;
+    # 
+    # class BrowserContextExamples
+    # {
+    #     public static async Task AddMd5FunctionToAllPagesInContext()
+    #     {
+    #         using var playwright = await Playwright.CreateAsync();
+    #         var browser = await playwright.Webkit.LaunchAsync(headless: false);
+    #         var context = await browser.NewContextAsync();
+    # 
+    #         // NOTE: md5 is inherently insecure, and we strongly discourage using
+    #         // this in production in any shape or form
+    #         await context.ExposeFunctionAsync("sha1", (string input) =>
+    #         {
+    #             return Convert.ToBase64String(
+    #                 MD5.Create().ComputeHash(System.Text.Encoding.UTF8.GetBytes(input)));
+    #         });
+    # 
+    #         var page = await context.NewPageAsync();
+    #         await page.SetContentAsync("<script>\n" +
+    #         "  async function onClick() {\n" +
+    #         "    document.querySelector('div').textContent = await window.sha1('PLAYWRIGHT');\n" +
+    #         "  }\n" +
+    #         "</script>\n" +
+    #         "<button onclick=\"onClick()\">Click me</button>\n" +
+    #         "<div></div>");
+    # 
+    #         await page.ClickAsync("button");
+    #         Console.WriteLine(await page.TextContentAsync("div"));
+    #     }
+    # }
+    # ```
     def expose_function(name, callback)
       wrap_impl(@impl.expose_function(unwrap_impl(name), unwrap_impl(callback)))
     end
@@ -552,6 +668,14 @@ module Playwright
     # browser.close()
     # ```
     # 
+    # ```csharp
+    # var context = await browser.NewContextAsync();
+    # var page = await context.NewPageAsync();
+    # await context.RouteAsync("**/*.{png,jpg,jpeg}", r => r.AbortAsync());
+    # await page.GotoAsync("https://theverge.com");
+    # await browser.CloseAsync();
+    # ```
+    # 
     # or the same snippet using a regex pattern instead:
     # 
     #
@@ -590,6 +714,64 @@ module Playwright
     # browser.close()
     # ```
     # 
+    # ```csharp
+    # var context = await browser.NewContextAsync();
+    # var page = await context.NewPageAsync();
+    # await context.RouteAsync(new Regex("(\\.png$)|(\\.jpg$)"), r => r.AbortAsync());
+    # await page.GotoAsync("https://theverge.com");
+    # await browser.CloseAsync();
+    # ```
+    # 
+    # It is possible to examine the request to decide the route action. For example, mocking all requests that contain some
+    # post data, and leaving all other requests as is:
+    # 
+    #
+    # ```js
+    # await context.route('/api/**', route => {
+    #   if (route.request().postData().includes('my-string'))
+    #     route.fulfill({ body: 'mocked-data' });
+    #   else
+    #     route.continue();
+    # });
+    # ```
+    # 
+    # ```java
+    # context.route("/api/**", route -> {
+    #   if (route.request().postData().contains("my-string"))
+    #     route.fulfill(new Route.FulfillOptions().setBody("mocked-data"));
+    #   else
+    #     route.resume();
+    # });
+    # ```
+    # 
+    # ```python async
+    # def handle_route(route):
+    #   if ("my-string" in route.request.post_data)
+    #     route.fulfill(body="mocked-data")
+    #   else
+    #     route.continue_()
+    # await context.route("/api/**", handle_route)
+    # ```
+    # 
+    # ```python sync
+    # def handle_route(route):
+    #   if ("my-string" in route.request.post_data)
+    #     route.fulfill(body="mocked-data")
+    #   else
+    #     route.continue_()
+    # context.route("/api/**", handle_route)
+    # ```
+    # 
+    # ```csharp
+    # await page.RouteAsync("/api/**", async r =>
+    # {
+    #     if (r.Request.PostData.Contains("my-string"))
+    #         await r.FulfillAsync(body: "mocked-data");
+    #     else
+    #         await r.ContinueAsync();
+    # });
+    # ```
+    # 
     # Page routes (set up with [`method: Page.route`]) take precedence over browser context routes when request matches both
     # handlers.
     # 
@@ -660,6 +842,14 @@ module Playwright
     # browser_context.set_geolocation({"latitude": 59.95, "longitude": 30.31667})
     # ```
     # 
+    # ```csharp
+    # await context.SetGeolocationAsync(new Geolocation()
+    # {
+    #     Latitude = 59.95f,
+    #     Longitude = 30.31667f
+    # });
+    # ```
+    # 
     # > NOTE: Consider using [`method: BrowserContext.grantPermissions`] to grant permissions for the browser context pages to
     # read its geolocation.
     def set_geolocation(geolocation)
@@ -709,6 +899,12 @@ module Playwright
     #     page.click("button")
     # page = event_info.value
     # ```
+    # 
+    # ```csharp
+    # var waitForPageEvent = context.WaitForPageAsync();
+    # await page.ClickAsync("button");
+    # var page = await waitForPageEvent;
+    # ```
     def expect_event(event, predicate: nil, timeout: nil, &block)
       wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end