playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright_api/android_device.rb

@@ -1,78 +1,229 @@
 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,
+          args: nil,
+          baseURL: nil,
+          bypassCSP: nil,
+          colorScheme: nil,
+          contrast: nil,
+          deviceScaleFactor: nil,
+          extraHTTPHeaders: nil,
+          forcedColors: nil,
+          geolocation: nil,
+          hasTouch: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          isMobile: nil,
+          javaScriptEnabled: nil,
+          locale: nil,
+          noViewport: nil,
+          offline: nil,
+          permissions: nil,
+          pkg: nil,
+          proxy: nil,
+          record_har_content: nil,
+          record_har_mode: nil,
+          record_har_omit_content: nil,
+          record_har_path: nil,
+          record_har_url_filter: nil,
+          record_video_dir: nil,
+          record_video_size: nil,
+          reducedMotion: nil,
+          screen: nil,
+          serviceWorkers: nil,
+          strictSelectors: nil,
+          timezoneId: nil,
+          userAgent: nil,
+          viewport: nil,
+          &block)
+      wrap_impl(@impl.launch_browser(acceptDownloads: unwrap_impl(acceptDownloads), args: unwrap_impl(args), baseURL: unwrap_impl(baseURL), bypassCSP: unwrap_impl(bypassCSP), colorScheme: unwrap_impl(colorScheme), contrast: unwrap_impl(contrast), deviceScaleFactor: unwrap_impl(deviceScaleFactor), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), forcedColors: unwrap_impl(forcedColors), 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), pkg: unwrap_impl(pkg), proxy: unwrap_impl(proxy), record_har_content: unwrap_impl(record_har_content), record_har_mode: unwrap_impl(record_har_mode), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_har_url_filter: unwrap_impl(record_har_url_filter), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), reducedMotion: unwrap_impl(reducedMotion), screen: unwrap_impl(screen), serviceWorkers: unwrap_impl(serviceWorkers), strictSelectors: unwrap_impl(strictSelectors), 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
+
+    #
+    # 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 info(selector)
-      wrap_impl(@impl.info(unwrap_impl(selector)))
+    def should_close_connection_on_close!
+      wrap_impl(@impl.should_close_connection_on_close!)
     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
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def model
-      wrap_impl(@impl.model)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+      event_emitter_proxy.on(event, callback)
     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)))
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/android_input.rb

@@ -1,25 +1,34 @@
 module Playwright
-  # @nodoc
   class AndroidInput < PlaywrightApi
 
-    # @nodoc
-    def type(text)
-      wrap_impl(@impl.type(unwrap_impl(text)))
-    end
-
-    # @nodoc
-    def tap_point(point)
-      wrap_impl(@impl.tap_point(unwrap_impl(point)))
+    #
+    # Performs a drag between `from` and `to` points.
+    def drag(from, to, steps)
+      wrap_impl(@impl.drag(unwrap_impl(from), unwrap_impl(to), unwrap_impl(steps)))
     end
 
-    # @nodoc
+    #
+    # Presses the `key`.
     def press(key)
       wrap_impl(@impl.press(unwrap_impl(key)))
     end
 
-    # @nodoc
-    def drag(from, to, steps)
-      wrap_impl(@impl.drag(unwrap_impl(from), unwrap_impl(to), unwrap_impl(steps)))
+    #
+    # Swipes following the path defined by `segments`.
+    def swipe(from, segments, steps)
+      raise NotImplementedError.new('swipe is not implemented yet.')
+    end
+
+    #
+    # Taps at the specified `point`.
+    def tap_point(point)
+      wrap_impl(@impl.tap_point(unwrap_impl(point)))
+    end
+
+    #
+    # Types `text` into currently focused widget.
+    def type(text)
+      wrap_impl(@impl.type(unwrap_impl(text)))
     end
   end
 end

data/lib/playwright_api/android_socket.rb

@@ -0,0 +1,18 @@
+module Playwright
+  #
+  # `AndroidSocket` is a way to communicate with a process launched on the `AndroidDevice`. Use [`method: AndroidDevice.open`] to open a socket.
+  class AndroidSocket < PlaywrightApi
+
+    #
+    # Closes the socket.
+    def close
+      raise NotImplementedError.new('close is not implemented yet.')
+    end
+
+    #
+    # Writes some `data` to the socket.
+    def write(data)
+      raise NotImplementedError.new('write is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/android_web_view.rb

@@ -0,0 +1,24 @@
+module Playwright
+  #
+  # `AndroidWebView` represents a WebView open on the `AndroidDevice`. WebView is usually obtained using [`method: AndroidDevice.webView`].
+  class AndroidWebView < PlaywrightApi
+
+    #
+    # Connects to the WebView and returns a regular Playwright `Page` to interact with.
+    def page
+      raise NotImplementedError.new('page is not implemented yet.')
+    end
+
+    #
+    # WebView process PID.
+    def pid
+      raise NotImplementedError.new('pid is not implemented yet.')
+    end
+
+    #
+    # WebView package identifier.
+    def pkg
+      raise NotImplementedError.new('pkg is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/api_request.rb

@@ -0,0 +1,26 @@
+module Playwright
+  #
+  # Exposes API that can be used for the Web API testing. This class is used for creating
+  # `APIRequestContext` instance which in turn can be used for sending web requests. An instance
+  # of this class can be obtained via [`property: Playwright.request`]. For more information
+  # see `APIRequestContext`.
+  class APIRequest < PlaywrightApi
+
+    #
+    # Creates new instances of `APIRequestContext`.
+    def new_context(
+          baseURL: nil,
+          clientCertificates: nil,
+          extraHTTPHeaders: nil,
+          failOnStatusCode: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          proxy: nil,
+          storageState: nil,
+          timeout: nil,
+          userAgent: nil)
+      raise NotImplementedError.new('new_context is not implemented yet.')
+    end
+  end
+end