playwright-ruby-client 1.17.1 → 1.18.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9407fc7093bb4cdb7539eec09b879e4bfd665626801594c764798ae41d3c7823
-  data.tar.gz: e6047ebe532d15fa5600986ae3fc9f42a23ea670923e1ec8fac6f6ecbb7f01c4
+  metadata.gz: 36a3c1f293b4d9a4a27ac780ebce4eb4098af2cefeba6d4e66f4ddb8c49490d7
+  data.tar.gz: 3520c8afc689c71a27d9af6516461cb1871a206bc6c416aee5f99742217191c8
 SHA512:
-  metadata.gz: 70b935777666f43236ec9df9b8462ebebf7fb883cde2d57e167d3342a18280a86e286e99e206f47e6ee2c739f23f6afe43daa2def9ea0a322b5e09f3b36bfc81
-  data.tar.gz: 3392ad01696c2c22ba411d7e4821e0bf0a2f641526481201927ff6510d7bb077c9fb6b20fcafabd55e5067ff7b1153b950d6b3c532c0bd14d77b9a0b3ac7c4c0
+  metadata.gz: 69a7ff8c2880d9ce5bad599f102e5a0c4e710eaa25f9d5c9323cbd579cfaac6a4252eef9321a0ee453f0200fb2ac985f79f00c5ddb5717549a8d78c5f3348afe
+  data.tar.gz: b589f69e462f5dfba205af8ee98cb58a6bcb35b4ea6742fa8bd3f3bc26e4783e9ee7cbed2fe8dced6272c64de144465d767b00859e32f602ecb08b28b2cfc399

data/documentation/docs/api/api_request_context.md

@@ -9,139 +9,51 @@ environment or the service to your e2e test. When used on [Page](./page) or a [B
 the cookies from the corresponding [BrowserContext](./browser_context). This means that if you log in using this API, your e2e test will be
 logged in and vice versa.
 
-## delete
+```python sync title=example_6db210740dd2dcb4551c2207b3204fde7127b24c7850226b273d15c0d6624ba5.py
+import os
+from playwright.sync_api import sync_playwright
+
+REPO = "test-repo-1"
+USER = "github-username"
+API_TOKEN = os.getenv("GITHUB_API_TOKEN")
+
+with sync_playwright() as p:
+    # This will launch a new browser, create a context and page. When making HTTP
+    # requests with the internal APIRequestContext (e.g. `context.request` or `page.request`)
+    # it will automatically set the cookies to the browser page and vise versa.
+    browser = playwright.chromium.launch()
+    context = browser.new_context(base_url="https://api.github.com")
+    api_request_context = context.request
+    page = context.new_page()
+
+    # Alternatively you can create a APIRequestContext manually without having a browser context attached:
+    # api_request_context = playwright.request.new_context(base_url="https://api.github.com")
+
+
+    # Create a repository.
+    response = api_request_context.post(
+        "/user/repos",
+        headers={
+            "Accept": "application/vnd.github.v3+json",
+            # Add GitHub personal access token.
+            "Authorization": f"token {API_TOKEN}",
+        },
+        data={"name": REPO},
+    )
+    assert response.ok
+    assert response.json()["name"] == REPO
+
+    # Delete a repository.
+    response = api_request_context.delete(
+        f"/repos/{USER}/{REPO}",
+        headers={
+            "Accept": "application/vnd.github.v3+json",
+            # Add GitHub personal access token.
+            "Authorization": f"token {API_TOKEN}",
+        },
+    )
+    assert response.ok
+    assert await response.body() == '{"status": "ok"}'
 
 ```
-def delete(
-      url,
-      data: nil,
-      failOnStatusCode: nil,
-      form: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      multipart: nil,
-      params: nil,
-      timeout: nil)
-```
-
-Sends HTTP(S) [DELETE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE) request and returns its
-response. The method will populate request cookies from the context and update context cookies from the response. The
-method will automatically follow redirects.
-
-## dispose
-
-```
-def dispose
-```
-
-All responses returned by [APIRequestContext#get](./api_request_context#get) and similar methods are stored in the memory, so that you
-can later call [APIResponse#body](./api_response#body). This method discards all stored responses, and makes
-[APIResponse#body](./api_response#body) throw "Response disposed" error.
-
-## fetch
-
-```
-def fetch(
-      urlOrRequest,
-      data: nil,
-      failOnStatusCode: nil,
-      form: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      method: nil,
-      multipart: nil,
-      params: nil,
-      timeout: nil)
-```
-
-Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and update
-context cookies from the response. The method will automatically follow redirects.
-
-## get
-
-```
-def get(
-      url,
-      failOnStatusCode: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      params: nil,
-      timeout: nil)
-```
-
-Sends HTTP(S) [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET) request and returns its response. The
-method will populate request cookies from the context and update context cookies from the response. The method will
-automatically follow redirects.
-
-## head
-
-```
-def head(
-      url,
-      failOnStatusCode: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      params: nil,
-      timeout: nil)
-```
-
-Sends HTTP(S) [HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) request and returns its response.
-The method will populate request cookies from the context and update context cookies from the response. The method will
-automatically follow redirects.
-
-## patch
-
-```
-def patch(
-      url,
-      data: nil,
-      failOnStatusCode: nil,
-      form: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      multipart: nil,
-      params: nil,
-      timeout: nil)
-```
-
-Sends HTTP(S) [PATCH](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) request and returns its response.
-The method will populate request cookies from the context and update context cookies from the response. The method will
-automatically follow redirects.
-
-## post
-
-```
-def post(
-      url,
-      data: nil,
-      failOnStatusCode: nil,
-      form: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      multipart: nil,
-      params: nil,
-      timeout: nil)
-```
-
-Sends HTTP(S) [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) request and returns its response.
-The method will populate request cookies from the context and update context cookies from the response. The method will
-automatically follow redirects.
-
-## put
-
-```
-def put(
-      url,
-      data: nil,
-      failOnStatusCode: nil,
-      form: nil,
-      headers: nil,
-      ignoreHTTPSErrors: nil,
-      multipart: nil,
-      params: nil,
-      timeout: nil)
-```
 
-Sends HTTP(S) [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) request and returns its response. The
-method will populate request cookies from the context and update context cookies from the response. The method will
-automatically follow redirects.

data/documentation/docs/api/browser_context.md

@@ -436,8 +436,4 @@ def expect_page(predicate: nil, timeout: nil)
 Performs action and waits for a new [Page](./page) to be created in the context. If predicate is provided, it passes [Page](./page) value into the `predicate` and waits for `predicate.call(page)` to return a truthy value. Will throw an error if
 the context closes before new [Page](./page) is created.
 
-## request
-
-API testing helper associated with this context. Requests made with this API will use context cookies.
-
 ## tracing

data/documentation/docs/api/download.md

@@ -19,9 +19,7 @@ end
 path = download.path
 ```
 
-> NOTE: Browser context **must** be created with the `acceptDownloads` set to `true` when user needs access to the
-downloaded content. If `acceptDownloads` is not set, download events are emitted, but the actual download is not
-performed and user has no access to the downloaded files.
+
 
 ## cancel
 

data/documentation/docs/api/frame.md

@@ -549,7 +549,7 @@ considered not visible.
 ## locator
 
 ```
-def locator(selector)
+def locator(selector, hasText: nil)
 ```
 
 The method returns an element locator that can be used to perform actions in the frame. Locator is resolved to the

data/documentation/docs/api/frame_locator.md

@@ -26,6 +26,15 @@ page.frame_locator('.result-frame').locator('button').click
 page.frame_locator('.result-frame').first.locator('button').click
 ```
 
+**Converting Locator to FrameLocator**
+
+If you have a [Locator](./locator) object pointing to an `iframe` it can be converted to [FrameLocator](./frame_locator) using
+[`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope) CSS selector:
+
+```ruby
+frame_locator = locator.frame_locator(':scope')
+```
+
 
 
 ## first
@@ -56,7 +65,7 @@ Returns locator to the last matching frame.
 ## locator
 
 ```
-def locator(selector)
+def locator(selector, hasText: nil)
 ```
 
 The method finds an element matching the specified selector in the FrameLocator's subtree.

data/documentation/docs/api/locator.md

@@ -4,53 +4,10 @@ sidebar_position: 10
 
 # Locator
 
-Locator represents a view to the element(s) on the page. It captures the logic sufficient to retrieve the element at any
-given moment. Locator can be created with the [Page#locator](./page#locator) method.
-
-```ruby
-locator = page.locator("text=Submit")
-locator.click
-```
-
-The difference between the Locator and [ElementHandle](./element_handle) is that the latter points to a particular element, while Locator
-captures the logic of how to retrieve that element.
-
-In the example below, handle points to a particular DOM element on page. If that element changes text or is used by
-React to render an entirely different component, handle is still pointing to that very DOM element. This can lead to
-unexpected behaviors.
-
-```ruby
-handle = page.query_selector("text=Submit")
-handle.hover
-handle.click
-```
-
-With the locator, every time the `element` is used, up-to-date DOM element is located in the page using the selector. So
-in the snippet below, underlying DOM element is going to be located twice.
-
-```ruby
-locator = page.locator("text=Submit")
-locator.hover
-locator.click
-```
-
-**Strictness**
-
-Locators are strict. This means that all operations on locators that imply some target DOM element will throw if more
-than one element matches given selector.
-
-```ruby
-# Throws if there are several buttons in DOM:
-page.locator('button').click
-
-# Works because we explicitly tell locator to pick the first element:
-page.locator('button').first.click
-
-# Works because count knows what to do with multiple matches:
-page.locator('button').count
-```
-
+Locators are the central piece of Playwright's auto-waiting and retry-ability. In a nutshell, locators represent a way
+to find element(s) on the page at any moment. Locator can be created with the [Page#locator](./page#locator) method.
 
+[Learn more about locators](https://playwright.dev/python/docs/locators).
 
 ## all_inner_texts
 
@@ -220,6 +177,21 @@ element.dispatch_event("dragstart", eventInit: { dataTransfer: data_transfer })
 
 
 
+## drag_to
+
+```
+def drag_to(
+      target,
+      force: nil,
+      noWaitAfter: nil,
+      sourcePosition: nil,
+      targetPosition: nil,
+      timeout: nil,
+      trial: nil)
+```
+
+
+
 ## element_handle
 
 ```
@@ -458,7 +430,7 @@ Returns locator to the last matching element.
 ## locator
 
 ```
-def locator(selector)
+def locator(selector, hasText: nil)
 ```
 
 The method finds an element matching the specified selector in the [Locator](./locator)'s subtree.

data/documentation/docs/api/page.md

@@ -774,7 +774,7 @@ considered not visible.
 ## locator
 
 ```
-def locator(selector)
+def locator(selector, hasText: nil)
 ```
 
 The method returns an element locator that can be used to perform actions on the page. Locator is resolved to the

data/documentation/docs/include/api_coverage.md

@@ -1,5 +1,17 @@
 # API coverages
 
+## APIRequestContext
+
+* ~~delete~~
+* ~~dispose~~
+* ~~fetch~~
+* ~~get~~
+* ~~head~~
+* ~~patch~~
+* ~~post~~
+* ~~put~~
+* ~~storage_state~~
+
 ## Request
 
 * all_headers
@@ -319,6 +331,7 @@
 * accessibility
 * keyboard
 * mouse
+* ~~request~~
 * touchscreen
 
 ## BrowserContext
@@ -349,7 +362,7 @@
 * expect_event
 * expect_page
 * ~~wait_for_event~~
-* request
+* ~~request~~
 * tracing
 
 ## CDPSession
@@ -405,6 +418,7 @@
 * count
 * dblclick
 * dispatch_event
+* drag_to
 * element_handle
 * element_handles
 * evaluate
@@ -449,34 +463,8 @@
 * locator
 * nth
 
-## APIResponse
-
-* body
-* dispose
-* headers
-* headers_array
-* json
-* ok
-* status
-* status_text
-* text
-* url
-
-## APIRequestContext
-
-* delete
-* dispose
-* fetch
-* get
-* head
-* patch
-* post
-* put
-* ~~storage_state~~
-
-## ~~APIRequest~~
+## LocalUtils
 
-* ~~new_context~~
 
 ## Android
 

data/lib/playwright/channel_owners/api_request_context.rb

@@ -1,236 +1,4 @@
-require 'base64'
-
 module Playwright
   define_channel_owner :APIRequestContext do
-    def dispose
-      @channel.send_message_to_server('dispose')
-    end
-
-    def delete(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'DELETE',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
-    end
-
-    def head(
-          url,
-          failOnStatusCode: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'HEAD',
-        failOnStatusCode: failOnStatusCode,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        params: params,
-        timeout: timeout,
-      )
-    end
-
-    def get(
-          url,
-          failOnStatusCode: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'GET',
-        failOnStatusCode: failOnStatusCode,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        params: params,
-        timeout: timeout,
-      )
-    end
-
-    def patch(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'PATCH',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
-    end
-
-    def put(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'PUT',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
-    end
-
-    def post(
-          url,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-      fetch(
-        url,
-        method: 'POST',
-        data: data,
-        failOnStatusCode: failOnStatusCode,
-        form: form,
-        headers: headers,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        multipart: multipart,
-        params: params,
-        timeout: timeout,
-      )
-    end
-
-    def fetch(
-          urlOrRequest,
-          data: nil,
-          failOnStatusCode: nil,
-          form: nil,
-          headers: nil,
-          ignoreHTTPSErrors: nil,
-          method: nil,
-          multipart: nil,
-          params: nil,
-          timeout: nil)
-
-      if [ChannelOwners::Request, String].none? { |type| urlOrRequest.is_a?(type) }
-        raise ArgumentError.new("First argument must be either URL string or Request")
-      end
-      if [data, form, multipart].compact.count > 1
-        raise ArgumentError.new("Only one of 'data', 'form' or 'multipart' can be specified")
-      end
-
-      request = urlOrRequest.is_a?(ChannelOwners::Request) ? urlOrRequest : nil
-      headers_obj = headers || request&.headers
-      fetch_params = {
-        url: request&.url || urlOrRequest,
-        params: object_to_array(params),
-        method: method || request&.method || 'GET',
-        headers: headers_obj ? HttpHeaders.new(headers_obj).as_serialized : nil,
-      }
-
-      json_data = nil
-      form_data = nil
-      multipart_data = nil
-      post_data_buffer = nil
-      if data
-        case data
-        when String
-          if headers_obj&.any? { |key, value| key.downcase == 'content-type' && value == 'application/json' }
-            json_data = data
-          else
-            post_data_buffer = data
-          end
-        when Hash, Array, Numeric, true, false
-          json_data = data
-        else
-          raise ArgumentError.new("Unsupported 'data' type: #{data.class}")
-        end
-      elsif form
-        form_data = object_to_array(form)
-      elsif multipart
-        multipart_data = multipart.map do |name, value|
-          if file_payload?(value)
-            { name: name, file: file_payload_to_json(value) }
-          else
-            { name: name, value: value.to_s }
-          end
-        end
-      end
-
-      if !json_data && !form_data && !multipart_data
-        post_data_buffer ||= request&.post_data_buffer
-      end
-      if post_data_buffer
-        fetch_params[:postData] = Base64.strict_encode64(post_data_buffer)
-      end
-
-      fetch_params[:jsonData] = json_data
-      fetch_params[:formData] = form_data
-      fetch_params[:multipartData] = multipart_data
-      fetch_params[:timeout] = timeout
-      fetch_params[:failOnStatusCode] = failOnStatusCode
-      fetch_params[:ignoreHTTPSErrors] = ignoreHTTPSErrors
-      fetch_params.compact!
-      response = @channel.send_message_to_server('fetch', fetch_params)
-
-      APIResponseImpl.new(self, response)
-    end
-
-    private def file_payload?(value)
-      value.is_a?(Hash) &&
-        %w(name mimeType buffer).all? { |key| value.has_key?(key) || value.has_key?(key.to_sym) }
-    end
-
-    private def file_payload_to_json(payload)
-      {
-        name: payload[:name] || payload['name'],
-        mimeType: payload[:mimeType] || payload['mimeType'],
-        buffer: Base64.strict_encode64(payload[:buffer] || payload['buffer'])
-      }
-    end
-
-    private def object_to_array(hash)
-      hash&.map do |key, value|
-        { name: key, value: value.to_s }
-      end
-    end
   end
 end

data/lib/playwright/channel_owners/browser_context.rb

@@ -4,7 +4,7 @@ module Playwright
     include Utils::Errors::SafeCloseError
     attr_accessor :browser
     attr_writer :owner_page, :options
-    attr_reader :tracing, :request
+    attr_reader :tracing
 
     private def after_initialize
       @pages = Set.new
@@ -15,8 +15,6 @@ module Playwright
       @background_pages = Set.new
 
       @tracing = TracingImpl.new(@channel, self)
-      @request = ChannelOwners::APIRequestContext.from(@initializer['APIRequestContext'])
-
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
       @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
@@ -360,5 +358,10 @@ module Playwright
     private def base_url
       @options[:baseURL]
     end
+
+    # called from Tracing
+    private def remote_connection?
+      @connection.remote?
+    end
   end
 end

data/lib/playwright/channel_owners/frame.rb

@@ -400,8 +400,8 @@ module Playwright
       nil
     end
 
-    def locator(selector)
-      LocatorImpl.new(frame: self, timeout_settings: @page.send(:timeout_settings), selector: selector)
+    def locator(selector, hasText: nil)
+      LocatorImpl.new(frame: self, timeout_settings: @page.send(:timeout_settings), selector: selector, hasText: hasText)
     end
 
     def frame_locator(selector)