playwright-ruby-client 0.0.8 → 0.3.0

data/lib/playwright/route_handler_entry.rb

@@ -0,0 +1,36 @@
+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_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
+
+    private def url_match?(request_url)
+      if @url_value.is_a?(Regexp)
+        @url_matcher.match?(request_url)
+      else
+        @url_matcher.match?(request_url) || File.fnmatch?(@url_value, request_url)
+      end
+    end
+  end
+end

data/lib/playwright/select_option_values.rb

@@ -1,7 +1,18 @@
 module Playwright
   class SelectOptionValues
-    def initialize(values)
-      @params = convert(values)
+    def initialize(element: nil, index: nil, value: nil, label: nil)
+      @params =
+        if element
+          convert(elmeent)
+        elsif index
+          convert(index)
+        elsif value
+          convert(value)
+        elsif label
+          convert(label)
+        else
+          {}
+        end
     end
 
     # @return [Hash]
@@ -10,8 +21,7 @@ module Playwright
     end
 
     private def convert(values)
-      return {} unless values
-      return convert([values]) unless values.is_a?('Array')
+      return convert([values]) unless values.is_a?(Enumerable)
       return {} if values.empty?
       values.each_with_index do |value, index|
         unless values

data/lib/playwright/touchscreen_impl.rb

@@ -0,0 +1,7 @@
+module Playwright
+  define_api_implementation :TouchscreenImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+  end
+end

data/lib/playwright/utils.rb

@@ -3,12 +3,13 @@ module Playwright
     module PrepareBrowserContextOptions
       # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
       private def prepare_browser_context_options(params)
-        if params[:viewport] == 0
-          params.delete(:viewport)
+        params[:sdkLanguage] = 'ruby'
+        if params[:noViewport] == 0
+          params.delete(:noViewport)
           params[:noDefaultViewport] = true
         end
         if params[:extraHTTPHeaders]
-          # TODO
+          params[:extraHTTPHeaders] = ::Playwright::HttpHeaders.new(params[:extraHTTPHeaders]).as_serialized
         end
         if params[:storageState].is_a?(String)
           params[:storageState] = JSON.parse(File.read(params[:storageState]))

data/lib/playwright/version.rb

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

data/lib/playwright/wait_helper.rb

@@ -23,7 +23,7 @@ module Playwright
       return if timeout_ms <= 0
 
       Concurrent::Promises.schedule(timeout_ms / 1000.0) {
-        reject(TimeoutError.new(message))
+        reject(TimeoutError.new(message: message))
       }
 
       self

data/lib/playwright_api/android.rb

@@ -1,33 +1,104 @@
 module Playwright
-  # @nodoc
+  # Playwright has **experimental** support for Android automation. You can access android namespace via:
+  # 
+  #
+  # ```js
+  # const { _android } = require('playwright');
+  # ```
+  # 
+  # An example of the Android automation script would be:
+  # 
+  #
+  # ```js
+  # const { _android } = require('playwright');
+  # 
+  # (async () => {
+  #   // Connect to the device.
+  #   const [device] = await playwright._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.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
 
-    # @nodoc
-    def after_initialize
-      wrap_impl(@impl.after_initialize)
+    # 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 on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    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/android_device.rb

@@ -1,78 +1,194 @@
 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 after_initialize
-      wrap_impl(@impl.after_initialize)
+    # 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
-    def tap_on(selector, duration: nil, timeout: nil)
-      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    # Fills the specific `selector` input box with `text`.
+    def fill(selector, text)
+      raise NotImplementedError.new('fill is not implemented yet.')
     end
 
-    # @nodoc
+    # 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,
+          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), 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, logger: nil, offline: nil, permissions: nil, proxy: nil, recordHar: nil, recordVideo: nil, storageState: nil, timezoneId: nil, userAgent: nil, videoSize: nil, videosPath: 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), logger: unwrap_impl(logger), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), proxy: unwrap_impl(proxy), recordHar: unwrap_impl(recordHar), recordVideo: unwrap_impl(recordVideo), storageState: unwrap_impl(storageState), timezoneId: unwrap_impl(timezoneId), userAgent: unwrap_impl(userAgent), videoSize: unwrap_impl(videoSize), videosPath: unwrap_impl(videosPath), 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
 
-    # @nodoc
-    def serial
-      wrap_impl(@impl.serial)
+    # 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 model
-      wrap_impl(@impl.model)
+    def tree
+      wrap_impl(@impl.tree)
     end
 
-    # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    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
 
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(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