playwright-ruby-client 0.2.0 → 0.5.2

data/lib/playwright/mouse_impl.rb

@@ -3,5 +3,46 @@ module Playwright
     def initialize(channel)
       @channel = channel
     end
+
+    def move(x, y, steps: nil)
+      params = { x: x, y: y, steps: steps }.compact
+      @channel.send_message_to_server('mouseMove', params)
+      nil
+    end
+
+    def down(button: nil, clickCount: nil)
+      params = { button: button, clickCount: clickCount }.compact
+      @channel.send_message_to_server('mouseDown', params)
+      nil
+    end
+
+    def up(button: nil, clickCount: nil)
+      params = { button: button, clickCount: clickCount }.compact
+      @channel.send_message_to_server('mouseUp', params)
+      nil
+    end
+
+    def click(
+      x,
+      y,
+      button: nil,
+      clickCount: nil,
+      delay: nil)
+
+      params = {
+        x: x,
+        y: y,
+        button: button,
+        clickCount: clickCount,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('mouseClick', params)
+
+      nil
+    end
+
+    def dblclick(x, y, button: nil, delay: nil)
+      click(x, y, button: button, clickCount: 2, delay: delay)
+    end
   end
 end

data/lib/playwright/route_handler_entry.rb

@@ -0,0 +1,28 @@
+module Playwright
+  class RouteHandlerEntry
+    # @param url [String]
+    # @param handler [Proc]
+    def initialize(url, handler)
+      @url_value = url
+      @url_matcher = UrlMatcher.new(url)
+      @handler = handler
+    end
+
+    def handle(route, request)
+      if @url_matcher.match?(request.url)
+        @handler.call(route, request)
+        true
+      else
+        false
+      end
+    end
+
+    def same_value?(url:, handler: nil)
+      if handler
+        @url_value == url && @handler == handler
+      else
+        @url_value == url
+      end
+    end
+  end
+end

data/lib/playwright/transport.rb

@@ -12,20 +12,27 @@ module Playwright
     def initialize(playwright_cli_executable_path:)
       @driver_executable_path = playwright_cli_executable_path
       @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+      @mutex = Mutex.new
     end
 
     def on_message_received(&block)
       @on_message = block
     end
 
+    def on_driver_crashed(&block)
+      @on_driver_crashed = block
+    end
+
     class AlreadyDisconnectedError < StandardError ; end
 
     # @param message [Hash]
     def send_message(message)
       debug_send_message(message) if @debug
       msg = JSON.dump(message)
-      @stdin.write([msg.size].pack('V')) # unsigned 32bit, little endian
-      @stdin.write(msg)
+      @mutex.synchronize {
+        @stdin.write([msg.size].pack('V')) # unsigned 32bit, little endian
+        @stdin.write(msg)
+      }
     rescue Errno::EPIPE
       raise AlreadyDisconnectedError.new('send_message failed')
     end
@@ -33,18 +40,17 @@ module Playwright
     # Terminate playwright-cli driver.
     def stop
       [@stdin, @stdout, @stderr].each { |io| io.close unless io.closed? }
+      @thread&.terminate
     end
 
     # Start `playwright-cli run-driver`
     #
     # @note This method blocks until playwright-cli exited. Consider using Thread or Future.
-    def run
-      @stdin, @stdout, @stderr, @thread = Open3.popen3(@driver_executable_path, 'run-driver')
+    def async_run
+      @stdin, @stdout, @stderr, @thread = Open3.popen3("#{@driver_executable_path} run-driver")
 
       Thread.new { handle_stdout }
       Thread.new { handle_stderr }
-
-      @thread.join
     end
 
     private
@@ -69,6 +75,21 @@ module Playwright
 
     def handle_stderr
       while err = @stderr.read
+        # sometimed driver crashes with the error below.
+        # --------
+        # undefined:1
+        # �
+        # ^
+
+        # SyntaxError: Unexpected token � in JSON at position 0
+        #     at JSON.parse (<anonymous>)
+        #     at Transport.transport.onmessage (/home/runner/work/playwright-ruby-client/playwright-ruby-client/node_modules/playwright/lib/cli/driver.js:42:73)
+        #     at Immediate.<anonymous> (/home/runner/work/playwright-ruby-client/playwright-ruby-client/node_modules/playwright/lib/protocol/transport.js:74:26)
+        #     at processImmediate (internal/timers.js:461:21)
+        if err.include?('undefined:1')
+          @on_driver_crashed&.call
+          break
+        end
         $stderr.write(err)
       end
     rescue IOError

data/lib/playwright/url_matcher.rb

@@ -8,7 +8,7 @@ module Playwright
     def match?(target_url)
       case @url
       when String
-        @url == target_url
+        @url == target_url || File.fnmatch?(@url, target_url)
       when Regexp
         @url.match?(target_url)
       else

data/lib/playwright/utils.rb

@@ -3,6 +3,7 @@ module Playwright
     module PrepareBrowserContextOptions
       # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
       private def prepare_browser_context_options(params)
+        params[:sdkLanguage] = 'ruby'
         if params[:noViewport] == 0
           params.delete(:noViewport)
           params[:noDefaultViewport] = true
@@ -10,6 +11,14 @@ module Playwright
         if params[:extraHTTPHeaders]
           params[:extraHTTPHeaders] = ::Playwright::HttpHeaders.new(params[:extraHTTPHeaders]).as_serialized
         end
+        if params[:record_video_dir]
+          params[:recordVideo] = {
+            dir: params.delete(:record_video_dir)
+          }
+          if params[:record_video_size]
+            params[:recordVideo][:size] = params.delete(:record_video_size)
+          end
+        end
         if params[:storageState].is_a?(String)
           params[:storageState] = JSON.parse(File.read(params[:storageState]))
         end

data/lib/playwright/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.2.0'
+  VERSION = '0.5.2'
 end

data/lib/playwright/video.rb

@@ -0,0 +1,51 @@
+module Playwright
+  class Video
+    def initialize(page)
+      @page = page
+      @artifact = Concurrent::Promises.resolvable_future
+      if @page.closed?
+        on_page_closed
+      else
+        page.once('close', -> { on_page_closed })
+      end
+    end
+
+    private def on_page_closed
+      unless @artifact.resolved?
+        @artifact.reject('Page closed')
+      end
+    end
+
+    # called only from Page#on_video via send(:set_artifact, artifact)
+    private def set_artifact(artifact)
+      @artifact.fulfill(artifact)
+    end
+
+    def path
+      wait_for_artifact_and do |artifact|
+        artifact.absolute_path
+      end
+    end
+
+    def save_as(path)
+      wait_for_artifact_and do |artifact|
+        artifact.save_as(path)
+      end
+    end
+
+    def delete
+      wait_for_artifact_and do |artifact|
+        artifact.delete
+      end
+    end
+
+    private def wait_for_artifact_and(&block)
+      artifact = @artifact.value!
+      unless artifact
+        raise 'Page did not produce any video frames'
+      end
+
+      block.call(artifact)
+    end
+  end
+end

data/lib/playwright/wait_helper.rb

@@ -22,9 +22,9 @@ module Playwright
     def reject_on_timeout(timeout_ms, message)
       return if timeout_ms <= 0
 
-      Concurrent::Promises.schedule(timeout_ms / 1000.0) {
+      Concurrent::Promises.schedule(timeout_ms / 1000.0) do
         reject(TimeoutError.new(message: message))
-      }
+      end
 
       self
     end

data/lib/playwright_api/accessibility.rb

@@ -6,7 +6,7 @@ module Playwright
   # Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that might
   # have wildly different output.
   # 
-  # Rendering engines of Chromium, Firefox and Webkit have a concept of "accessibility tree", which is then translated into
+  # Rendering engines of Chromium, Firefox and WebKit have a concept of "accessibility tree", which is then translated into
   # different platform-specific APIs. Accessibility namespace gives access to this Accessibility Tree.
   # 
   # Most of the accessibility tree gets filtered out when converting from internal browser AX Tree to Platform-specific
@@ -28,6 +28,11 @@ module Playwright
     # console.log(snapshot);
     # ```
     # 
+    # ```java
+    # String snapshot = page.accessibility().snapshot();
+    # System.out.println(snapshot);
+    # ```
+    # 
     # ```python async
     # snapshot = await page.accessibility.snapshot()
     # print(snapshot)
@@ -38,6 +43,11 @@ module Playwright
     # print(snapshot)
     # ```
     # 
+    # ```csharp
+    # var accessibilitySnapshot = await Page.Accessibility.SnapshotAsync();
+    # Console.WriteLine(accessibilitySnapshot);
+    # ```
+    # 
     # An example of logging the focused node's name:
     # 
     #
@@ -57,6 +67,34 @@ module Playwright
     # }
     # ```
     # 
+    # ```csharp
+    # Func<AccessibilitySnapshotResult, AccessibilitySnapshotResult> findFocusedNode = root =>
+    # {
+    #     var nodes = new Stack<AccessibilitySnapshotResult>(new[] { root });
+    #     while (nodes.Count > 0)
+    #     {
+    #         var node = nodes.Pop();
+    #         if (node.Focused) return node;
+    #         foreach (var innerNode in node.Children)
+    #         {
+    #             nodes.Push(innerNode);
+    #         }
+    #     }
+    # 
+    #     return null;
+    # };
+    # 
+    # var accessibilitySnapshot = await Page.Accessibility.SnapshotAsync();
+    # var focusedNode = findFocusedNode(accessibilitySnapshot);
+    # if(focusedNode != null)
+    #   Console.WriteLine(focusedNode.Name);
+    # ```
+    # 
+    # ```java
+    # // FIXME
+    # String snapshot = page.accessibility().snapshot();
+    # ```
+    # 
     # ```python async
     # def find_focused_node(node):
     #     if (node.get("focused"))

data/lib/playwright_api/android.rb

@@ -1,12 +1,84 @@
 module Playwright
-  # @nodoc
+  # Playwright has **experimental** support for Android automation. You can access android namespace via:
+  # 
+  #
+  # ```js
+  # const { _android: android } = require('playwright');
+  # ```
+  # 
+  # An example of the Android automation script would be:
+  # 
+  #
+  # ```js
+  # const { _android: android } = require('playwright');
+  # 
+  # (async () => {
+  #   // Connect to the device.
+  #   const [device] = await android.devices();
+  #   console.log(`Model: ${device.model()}`);
+  #   console.log(`Serial: ${device.serial()}`);
+  #   // Take screenshot of the whole device.
+  #   await device.screenshot({ path: 'device.png' });
+  # 
+  #   {
+  #     // --------------------- WebView -----------------------
+  # 
+  #     // Launch an application with WebView.
+  #     await device.shell('am force-stop org.chromium.webview_shell');
+  #     await device.shell('am start org.chromium.webview_shell/.WebViewBrowserActivity');
+  #     // Get the WebView.
+  #     const webview = await device.webView({ pkg: 'org.chromium.webview_shell' });
+  # 
+  #     // Fill the input box.
+  #     await device.fill({ res: 'org.chromium.webview_shell:id/url_field' }, 'github.com/microsoft/playwright');
+  #     await device.press({ res: 'org.chromium.webview_shell:id/url_field' }, 'Enter');
+  # 
+  #     // Work with WebView's page as usual.
+  #     const page = await webview.page();
+  #     await page.waitForNavigation({ url: /.*microsoft\/playwright.*/ });
+  #     console.log(await page.title());
+  #   }
+  # 
+  #   {
+  #     // --------------------- Browser -----------------------
+  # 
+  #     // Launch Chrome browser.
+  #     await device.shell('am force-stop com.android.chrome');
+  #     const context = await device.launchBrowser();
+  # 
+  #     // Use BrowserContext as usual.
+  #     const page = await context.newPage();
+  #     await page.goto('https://webkit.org/');
+  #     console.log(await page.evaluate(() => window.location.href));
+  #     await page.screenshot({ path: 'page.png' });
+  # 
+  #     await context.close();
+  #   }
+  # 
+  #   // Close the device.
+  #   await device.close();
+  # })();
+  # ```
+  # 
+  # Note that since you don't need Playwright to install web browsers when testing Android, you can omit browser download
+  # via setting the following environment variable when installing Playwright:
+  # 
+  # ```sh js
+  # $ PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm i -D playwright
+  # ```
   class Android < PlaywrightApi
 
-    # @nodoc
+    # Returns the list of detected Android devices.
     def devices
       wrap_impl(@impl.devices)
     end
 
+    # This setting will change the default maximum time for all the methods accepting `timeout` option.
+    def set_default_timeout(timeout)
+      raise NotImplementedError.new('set_default_timeout is not implemented yet.')
+    end
+    alias_method :default_timeout=, :set_default_timeout
+
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)

data/lib/playwright_api/android_device.rb

@@ -1,55 +1,173 @@
 module Playwright
-  # @nodoc
+  # `AndroidDevice` represents a connected device, either real hardware or emulated. Devices can be obtained using
+  # [`method: Android.devices`].
   class AndroidDevice < PlaywrightApi
 
-    # @nodoc
-    def tree
-      wrap_impl(@impl.tree)
+    def input # property
+      wrap_impl(@impl.input)
     end
 
-    # @nodoc
+    # Disconnects from the device.
     def close
       wrap_impl(@impl.close)
     end
 
-    # @nodoc
-    def tap_on(selector, duration: nil, timeout: nil)
-      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    # Drags the widget defined by `selector` towards `dest` point.
+    def drag(selector, dest, speed: nil)
+      raise NotImplementedError.new('drag is not implemented yet.')
     end
 
-    # @nodoc
+    # Fills the specific `selector` input box with `text`.
+    def fill(selector, text)
+      raise NotImplementedError.new('fill is not implemented yet.')
+    end
+
+    # Flings the widget defined by `selector` in  the specified `direction`.
+    def fling(selector, direction, speed: nil)
+      raise NotImplementedError.new('fling is not implemented yet.')
+    end
+
+    # Returns information about a widget defined by `selector`.
+    def info(selector)
+      wrap_impl(@impl.info(unwrap_impl(selector)))
+    end
+
+    # Installs an apk on the device.
+    def install_apk(file, args: nil)
+      raise NotImplementedError.new('install_apk is not implemented yet.')
+    end
+
+    # Launches Chrome browser on the device, and returns its persistent context.
+    def launch_browser(
+          acceptDownloads: nil,
+          bypassCSP: nil,
+          colorScheme: nil,
+          command: nil,
+          deviceScaleFactor: nil,
+          extraHTTPHeaders: nil,
+          geolocation: nil,
+          hasTouch: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          isMobile: nil,
+          javaScriptEnabled: nil,
+          locale: nil,
+          noViewport: nil,
+          offline: nil,
+          permissions: nil,
+          record_har_omit_content: nil,
+          record_har_path: nil,
+          record_video_dir: nil,
+          record_video_size: nil,
+          screen: nil,
+          timezoneId: nil,
+          userAgent: nil,
+          viewport: nil,
+          &block)
+      wrap_impl(@impl.launch_browser(acceptDownloads: unwrap_impl(acceptDownloads), bypassCSP: unwrap_impl(bypassCSP), colorScheme: unwrap_impl(colorScheme), command: unwrap_impl(command), deviceScaleFactor: unwrap_impl(deviceScaleFactor), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), geolocation: unwrap_impl(geolocation), hasTouch: unwrap_impl(hasTouch), httpCredentials: unwrap_impl(httpCredentials), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), isMobile: unwrap_impl(isMobile), javaScriptEnabled: unwrap_impl(javaScriptEnabled), locale: unwrap_impl(locale), noViewport: unwrap_impl(noViewport), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), screen: unwrap_impl(screen), timezoneId: unwrap_impl(timezoneId), userAgent: unwrap_impl(userAgent), viewport: unwrap_impl(viewport), &wrap_block_call(block)))
+    end
+
+    # Performs a long tap on the widget defined by `selector`.
+    def long_tap(selector)
+      raise NotImplementedError.new('long_tap is not implemented yet.')
+    end
+
+    # Device model.
+    def model
+      wrap_impl(@impl.model)
+    end
+
+    # Launches a process in the shell on the device and returns a socket to communicate with the launched process.
+    def open(command)
+      raise NotImplementedError.new('open is not implemented yet.')
+    end
+
+    # Pinches the widget defined by `selector` in the closing direction.
+    def pinch_close(selector, percent, speed: nil)
+      raise NotImplementedError.new('pinch_close is not implemented yet.')
+    end
+
+    # Pinches the widget defined by `selector` in the open direction.
+    def pinch_open(selector, percent, speed: nil)
+      raise NotImplementedError.new('pinch_open is not implemented yet.')
+    end
+
+    # Presses the specific `key` in the widget defined by `selector`.
+    def press(selector, key)
+      raise NotImplementedError.new('press is not implemented yet.')
+    end
+
+    # Copies a file to the device.
+    def push(file, path, mode: nil)
+      raise NotImplementedError.new('push is not implemented yet.')
+    end
+
+    # Returns the buffer with the captured screenshot of the device.
     def screenshot(path: nil)
       wrap_impl(@impl.screenshot(path: unwrap_impl(path)))
     end
 
-    # @nodoc
+    # Scrolls the widget defined by `selector` in  the specified `direction`.
+    def scroll(selector, direction, percent, speed: nil)
+      raise NotImplementedError.new('scroll is not implemented yet.')
+    end
+
+    # Device serial number.
+    def serial
+      wrap_impl(@impl.serial)
+    end
+
+    # This setting will change the default maximum time for all the methods accepting `timeout` option.
+    def set_default_timeout(timeout)
+      raise NotImplementedError.new('set_default_timeout is not implemented yet.')
+    end
+    alias_method :default_timeout=, :set_default_timeout
+
+    # Executes a shell command on the device and returns its output.
     def shell(command)
       wrap_impl(@impl.shell(unwrap_impl(command)))
     end
 
-    # @nodoc
-    def input
-      wrap_impl(@impl.input)
+    # Swipes the widget defined by `selector` in  the specified `direction`.
+    def swipe(selector, direction, percent, speed: nil)
+      raise NotImplementedError.new('swipe is not implemented yet.')
     end
 
-    # @nodoc
-    def launch_browser(pkg: nil, acceptDownloads: nil, bypassCSP: nil, colorScheme: nil, deviceScaleFactor: nil, extraHTTPHeaders: nil, geolocation: nil, hasTouch: nil, httpCredentials: nil, ignoreHTTPSErrors: nil, isMobile: nil, javaScriptEnabled: nil, locale: nil, noViewport: nil, offline: nil, permissions: nil, proxy: nil, record_har_omit_content: nil, record_har_path: nil, record_video_dir: nil, record_video_size: nil, storageState: nil, timezoneId: nil, userAgent: nil, viewport: nil, &block)
-      wrap_impl(@impl.launch_browser(pkg: unwrap_impl(pkg), acceptDownloads: unwrap_impl(acceptDownloads), bypassCSP: unwrap_impl(bypassCSP), colorScheme: unwrap_impl(colorScheme), deviceScaleFactor: unwrap_impl(deviceScaleFactor), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), geolocation: unwrap_impl(geolocation), hasTouch: unwrap_impl(hasTouch), httpCredentials: unwrap_impl(httpCredentials), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), isMobile: unwrap_impl(isMobile), javaScriptEnabled: unwrap_impl(javaScriptEnabled), locale: unwrap_impl(locale), noViewport: unwrap_impl(noViewport), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), proxy: unwrap_impl(proxy), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), storageState: unwrap_impl(storageState), timezoneId: unwrap_impl(timezoneId), userAgent: unwrap_impl(userAgent), viewport: unwrap_impl(viewport), &wrap_block_call(block)))
+    # Taps on the widget defined by `selector`.
+    def tap_point(selector, duration: nil)
+      raise NotImplementedError.new('tap_point is not implemented yet.')
     end
 
-    # @nodoc
-    def info(selector)
-      wrap_impl(@impl.info(unwrap_impl(selector)))
+    # Waits for the specific `selector` to either appear or disappear, depending on the `state`.
+    def wait(selector, state: nil)
+      raise NotImplementedError.new('wait is not implemented yet.')
+    end
+
+    # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
+    # value.
+    def wait_for_event(event, optionsOrPredicate: nil)
+      raise NotImplementedError.new('wait_for_event is not implemented yet.')
+    end
+
+    # This method waits until `AndroidWebView` matching the `selector` is opened and returns it. If there is already an open
+    # `AndroidWebView` matching the `selector`, returns immediately.
+    def web_view(selector)
+      raise NotImplementedError.new('web_view is not implemented yet.')
+    end
+
+    # Currently open WebViews.
+    def web_views
+      raise NotImplementedError.new('web_views is not implemented yet.')
     end
 
     # @nodoc
-    def serial
-      wrap_impl(@impl.serial)
+    def tap_on(selector, duration: nil, timeout: nil)
+      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
     end
 
     # @nodoc
-    def model
-      wrap_impl(@impl.model)
+    def tree
+      wrap_impl(@impl.tree)
     end
 
     # -- inherited from EventEmitter --