playwright-ruby-client 1.16.beta1 → 1.17.0

data/lib/playwright/channel_owners/request.rb

@@ -84,39 +84,27 @@ module Playwright
 
     # @return [RawHeaders|nil]
     private def actual_headers
-      @actual_headers ||= response&.send(:raw_request_headers)
+      @actual_headers ||= raw_request_headers
+    end
+
+    private def raw_request_headers
+      RawHeaders.new(@channel.send_message_to_server('rawRequestHeaders'))
     end
 
     def all_headers
-      if actual_headers
-        actual_headers.headers
-      else
-        @provisional_headers.headers
-      end
+      actual_headers.headers
     end
 
     def headers_array
-      if actual_headers
-        actual_headers.headers_array
-      else
-        @provisional_headers.headers_array
-      end
+      actual_headers.headers_array
     end
 
     def header_value(name)
-      if actual_headers
-        actual_headers.get(name)
-      else
-        @provisional_headers.get(name)
-      end
+      actual_headers.get(name)
     end
 
     def header_values(name)
-      if actual_headers
-        actual_headers.get_all(name)
-      else
-        @provisional_headers.get_all(name)
-      end
+      actual_headers.get_all(name)
     end
 
     def sizes

data/lib/playwright/channel_owners/response.rb

@@ -48,10 +48,6 @@ module Playwright
       @actual_headers ||= raw_response_headers
     end
 
-    private def raw_request_headers
-      RawHeaders.new(@channel.send_message_to_server('rawRequestHeaders'))
-    end
-
     private def raw_response_headers
       RawHeaders.new(@channel.send_message_to_server('rawResponseHeaders'))
     end

data/lib/playwright/connection.rb

@@ -21,6 +21,15 @@ module Playwright
       @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
       @callbacks = {} # Hash [ guid => Promise<ChannelOwner> ]
       @root_object = RootChannelOwner.new(self)
+      @remote = false
+    end
+
+    def mark_as_remote
+      @remote = true
+    end
+
+    def remote?
+      @remote
     end
 
     def async_run

data/lib/playwright/frame_locator_impl.rb

@@ -0,0 +1,49 @@
+module Playwright
+  define_api_implementation :FrameLocatorImpl do
+    def initialize(frame:, timeout_settings:, frame_selector:)
+      @frame = frame
+      @timeout_settings = timeout_settings
+      @frame_selector = frame_selector
+    end
+
+    def locator(selector)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@frame_selector} >> control=enter-frame >> #{selector}",
+      )
+    end
+
+    def frame_locator(selector)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> control=enter-frame >> #{selector}",
+      )
+    end
+
+    def first
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> nth=0",
+      )
+    end
+
+    def last
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> nth=-1",
+      )
+    end
+
+    def nth(index)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> nth=#{index}",
+      )
+    end
+  end
+end

data/lib/playwright/locator_impl.rb

@@ -11,17 +11,17 @@ module Playwright
     end
 
     private def with_element(timeout: nil, &block)
+      timeout_or_default = @timeout_settings.timeout(timeout)
       start_time = Time.now
 
-      handle = @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
+      handle = @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout_or_default)
       unless handle
         raise "Could not resolve #{@selector} to DOM Element"
       end
 
-      call_options = {}
-      if timeout
-        call_options[:timeout] = (timeout - (Time.now - start_time) * 1000).to_i
-      end
+      call_options = {
+        timeout: (timeout_or_default - (Time.now - start_time) * 1000).to_i,
+      }
 
       begin
         block.call(handle, call_options)
@@ -130,6 +130,14 @@ module Playwright
       )
     end
 
+    def frame_locator(selector)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@selector} >> #{selector}",
+      )
+    end
+
     def element_handle(timeout: nil)
       @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
     end

data/lib/playwright/route_handler.rb

@@ -6,17 +6,25 @@ module Playwright
       end
 
       def handle
-        return false if @count <= 0
+        return false if expired?
 
         @count = @count - 1
         true
       end
+
+      def expired?
+        @count <= 0
+      end
     end
 
     class StubCounter
       def handle
         true
       end
+
+      def expired?
+        false
+      end
     end
 
     # @param url [String]
@@ -46,6 +54,10 @@ module Playwright
       end
     end
 
+    def expired?
+      @counter.expired?
+    end
+
     def same_value?(url:, handler: nil)
       if handler
         @url_value == url && @handler == handler

data/lib/playwright/tracing_impl.rb

@@ -5,18 +5,18 @@ module Playwright
       @context = context
     end
 
-    def start(name: nil, screenshots: nil, snapshots: nil)
+    def start(name: nil, title: nil, screenshots: nil, snapshots: nil)
       params = {
         name: name,
         screenshots: screenshots,
         snapshots: snapshots,
       }.compact
       @channel.send_message_to_server('tracingStart', params)
-      @channel.send_message_to_server('tracingStartChunk')
+      @channel.send_message_to_server('tracingStartChunk', { title: title }.compact)
     end
 
-    def start_chunk
-      @channel.send_message_to_server('tracingStartChunk')
+    def start_chunk(title: nil)
+      @channel.send_message_to_server('tracingStartChunk', { title: title }.compact)
     end
 
     def stop_chunk(path: nil)
@@ -29,13 +29,10 @@ module Playwright
     end
 
     private def do_stop_chunk(path:)
-      resp = @channel.send_message_to_server('tracingStopChunk', save: !path.nil?)
-      artifact = ChannelOwners::Artifact.from_nullable(resp)
+      result = @channel.send_message_to_server_result('tracingStopChunk', save: !path.nil?, skipCompress: false)
+      artifact = ChannelOwners::Artifact.from_nullable(result['artifact'])
       return unless artifact
 
-      if @context.browser.send(:remote?)
-        artifact.update_as_remote
-      end
       artifact.save_as(path)
       artifact.delete
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.16.beta1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.16.0'
+  VERSION = '1.17.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.17.0'
 end

data/lib/playwright/video.rb

@@ -22,6 +22,9 @@ module Playwright
     end
 
     def path
+      if @page.send(:remote_connection?)
+        raise 'Path is not available when using browserType.connect(). Use save_as() to save a local copy.'
+      end
       wait_for_artifact_and do |artifact|
         artifact.absolute_path
       end

data/lib/playwright.rb

@@ -135,13 +135,14 @@ module Playwright
 
     transport = WebSocketTransport.new(ws_endpoint: ws_endpoint)
     connection = Connection.new(transport)
+    connection.mark_as_remote
     connection.async_run
 
     execution =
       begin
         playwright = connection.initialize_playwright
         browser = playwright.send(:pre_launched_browser)
-        browser.send(:update_as_remote)
+        browser.should_close_connection_on_close!
         Execution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(browser))
       rescue
         connection.stop

data/lib/playwright_api/api_request_context.rb

@@ -0,0 +1,149 @@
+module Playwright
+  # This API is used for the Web API testing. You can use it to trigger API endpoints, configure micro-services, prepare
+  # environment or the service to your e2e test. When used on `Page` or a `BrowserContext`, this API will automatically use
+  # the cookies from the corresponding `BrowserContext`. This means that if you log in using this API, your e2e test will be
+  # logged in and vice versa.
+  class APIRequestContext < PlaywrightApi
+
+    # 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.
+    def delete(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('delete is not implemented yet.')
+    end
+
+    # All responses returned by [`method: APIRequestContext.get`] and similar methods are stored in the memory, so that you
+    # can later call [`method: APIResponse.body`]. This method discards all stored responses, and makes
+    # [`method: APIResponse.body`] throw "Response disposed" error.
+    def dispose
+      raise NotImplementedError.new('dispose is not implemented yet.')
+    end
+
+    # 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.
+    def fetch(
+          urlOrRequest,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          method: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('fetch is not implemented yet.')
+    end
+
+    # 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.
+    def get(
+          url,
+          failOnStatusCode: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('get is not implemented yet.')
+    end
+
+    # 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.
+    def head(
+          url,
+          failOnStatusCode: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('head is not implemented yet.')
+    end
+
+    # 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.
+    def patch(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('patch is not implemented yet.')
+    end
+
+    # 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.
+    def post(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('post is not implemented yet.')
+    end
+
+    # 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.
+    def put(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('put is not implemented yet.')
+    end
+
+    # Returns storage state for this request context, contains current cookies and local storage snapshot if it was passed to
+    # the constructor.
+    def storage_state(path: nil)
+      raise NotImplementedError.new('storage_state is not implemented yet.')
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
+    end
+  end
+end

data/lib/playwright_api/browser_context.rb

@@ -6,7 +6,7 @@ module Playwright
   # If a page opens another page, e.g. with a `window.open` call, the popup will belong to the parent page's browser
   # context.
   #
-  # Playwright allows creation of "incognito" browser contexts with `browser.newContext()` method. "Incognito" browser
+  # Playwright allows creating "incognito" browser contexts with [`method: Browser.newContext`] method. "Incognito" browser
   # contexts don't write any browsing data to disk.
   #
   # ```python sync
@@ -20,6 +20,11 @@ module Playwright
   # ```
   class BrowserContext < PlaywrightApi
 
+    # API testing helper associated with this context. Requests made with this API will use context cookies.
+    def request # property
+      raise NotImplementedError.new('request is not implemented yet.')
+    end
+
     def tracing # property
       wrap_impl(@impl.tracing)
     end

data/lib/playwright_api/element_handle.rb

@@ -6,6 +6,8 @@ module Playwright
   # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.querySelector`]
   # method.
   #
+  # > NOTE: The use of ElementHandle is discouraged, use `Locator` objects and web-first assertions instead.
+  #
   # ```python sync
   # href_element = page.query_selector("a")
   # href_element.click()
@@ -17,9 +19,6 @@ module Playwright
   # ElementHandle instances can be used as an argument in [`method: Page.evalOnSelector`] and [`method: Page.evaluate`]
   # methods.
   #
-  # > NOTE: In most cases, you would want to use the `Locator` object instead. You should only use `ElementHandle` if you
-  # want to retain a handle to a particular DOM Node that you intend to pass into [`method: Page.evaluate`] as an argument.
-  #
   # The difference between the `Locator` and ElementHandle is that the ElementHandle points to a particular element, while
   # `Locator` captures the logic of how to retrieve an element.
   #

data/lib/playwright_api/frame.rb

@@ -183,6 +183,9 @@ module Playwright
 
     # Returns the return value of `expression`.
     #
+    # > NOTE: This method does not wait for the element to pass actionability checks and therefore can lead to the flaky
+    # tests. Use [`method: Locator.evaluate`], other `Locator` helper methods or web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the frame and passes it as a first argument to
     # `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the selector, the
     # method throws an error.
@@ -203,6 +206,9 @@ module Playwright
 
     # Returns the return value of `expression`.
     #
+    # > NOTE: In most cases, [`method: Locator.evaluateAll`], other `Locator` helper methods and web-first assertions do a
+    # better job.
+    #
     # The method finds all elements matching the specified selector within the frame and passes an array of matched elements
     # as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
     #
@@ -243,7 +249,7 @@ module Playwright
     # `ElementHandle` instances can be passed as an argument to the [`method: Frame.evaluate`]:
     #
     # ```python sync
-    # body_handle = frame.query_selector("body")
+    # body_handle = frame.evaluate("document.body")
     # html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", [body_handle, "hello"])
     # body_handle.dispose()
     # ```
@@ -324,6 +330,18 @@ module Playwright
       wrap_impl(@impl.frame_element)
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe. Following snippet locates element with text "Submit" in the iframe with id `my-frame`, like `<iframe
+    # id="my-frame">`:
+    #
+    # ```python sync
+    # locator = frame.frame_locator("#my-iframe").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # Returns element attribute value.
     def get_attribute(selector, name, strict: nil, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(selector), unwrap_impl(name), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
@@ -478,6 +496,8 @@ module Playwright
 
     # Returns the ElementHandle pointing to the frame element.
     #
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects and web-first assertions instead.
+    #
     # The method finds an element matching the specified selector within the frame. See
     # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns `null`.
     def query_selector(selector, strict: nil)
@@ -486,6 +506,8 @@ module Playwright
 
     # Returns the ElementHandles pointing to the frame elements.
     #
+    # > NOTE: The use of `ElementHandle` is discouraged, use `Locator` objects instead.
+    #
     # The method finds all elements matching the specified selector within the frame. See
     # [Working with selectors](./selectors.md) for more details. If no elements match the selector, returns empty array.
     def query_selector_all(selector)
@@ -714,6 +736,9 @@ module Playwright
     # Returns when element specified by selector satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
     #
+    # > NOTE: Playwright automatically waits for element to be ready before performing an action. Using `Locator` objects and
+    # web-first assertions make the code wait-for-selector-free.
+    #
     # Wait for the `selector` to satisfy `state` option (either appear/disappear from dom, or become visible/hidden). If at
     # the moment of calling the method `selector` already satisfies the condition, the method will return immediately. If the
     # selector doesn't satisfy the condition for the `timeout` milliseconds, the function will throw.

data/lib/playwright_api/frame_locator.rb

@@ -0,0 +1,51 @@
+module Playwright
+  # FrameLocator represents a view to the `iframe` on the page. It captures the logic sufficient to retrieve the `iframe`
+  # and locate elements in that iframe. FrameLocator can be created with either [`method: Page.frameLocator`] or
+  # [`method: Locator.frameLocator`] method.
+  #
+  # ```python sync
+  # locator = page.frame_locator("my-frame").locator("text=Submit")
+  # locator.click()
+  # ```
+  #
+  # **Strictness**
+  #
+  # Frame locators are strict. This means that all operations on frame locators will throw if more than one element matches
+  # given selector.
+  #
+  # ```python sync
+  # # Throws if there are several frames in DOM:
+  # page.frame_locator('.result-frame').locator('button').click()
+  #
+  # # Works because we explicitly tell locator to pick the first frame:
+  # page.frame_locator('.result-frame').first.locator('button').click()
+  # ```
+  class FrameLocator < PlaywrightApi
+
+    # Returns locator to the first matching frame.
+    def first
+      wrap_impl(@impl.first)
+    end
+
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe.
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
+    # Returns locator to the last matching frame.
+    def last
+      wrap_impl(@impl.last)
+    end
+
+    # The method finds an element matching the specified selector in the FrameLocator's subtree.
+    def locator(selector)
+      wrap_impl(@impl.locator(unwrap_impl(selector)))
+    end
+
+    # Returns locator to the n-th matching frame.
+    def nth(index)
+      wrap_impl(@impl.nth(unwrap_impl(index)))
+    end
+  end
+end

data/lib/playwright_api/locator.rb

@@ -264,6 +264,17 @@ module Playwright
       wrap_impl(@impl.focus(timeout: unwrap_impl(timeout)))
     end
 
+    # When working with iframes, you can create a frame locator that will enter the iframe and allow selecting elements in
+    # that iframe:
+    #
+    # ```python sync
+    # locator = page.frame_locator("text=Submit").locator("text=Submit")
+    # locator.click()
+    # ```
+    def frame_locator(selector)
+      wrap_impl(@impl.frame_locator(unwrap_impl(selector)))
+    end
+
     # Returns element attribute value.
     def get_attribute(name, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(name), timeout: unwrap_impl(timeout)))
@@ -338,8 +349,7 @@ module Playwright
       wrap_impl(@impl.last)
     end
 
-    # The method finds an element matching the specified selector in the `Locator`'s subtree. See
-    # [Working with selectors](./selectors.md) for more details.
+    # The method finds an element matching the specified selector in the `Locator`'s subtree.
     def locator(selector)
       wrap_impl(@impl.locator(unwrap_impl(selector)))
     end