async-webdriver 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fab04165eba20d959a8d0016d33475e838f0b3d30f54ddc15827f9153cbbfecb
-  data.tar.gz: dc3933f0abe24f936993eb13e1531ab74e3b94642c8c1e8f35e4570d4a2574ea
+  metadata.gz: 8a6324ffc2dfcde7982396b2dbda22df843948de94ba4e61811a777b64156a05
+  data.tar.gz: 25cc350a2093f0bc1651500139bb654c5ed0af2f8ac553ecbc5d3544691e9999
 SHA512:
-  metadata.gz: b3b3ba2ab5a423e5935643ed2d579f62ad5b20b571bc0364e65d72b37cc6820d5f14a3df00eb103b99ce2b2a02cb10ecdf8ee5767304658bf30b746dd768b105
-  data.tar.gz: b6466ab0b8b85d0b5b270789aa414c8d34d609d5f9c7e25a89b6986aa00c48bad6587b4c22f7d7a3a9893c8d416de560994e35f1f3786fe58945b3d78b18c1ae
+  metadata.gz: 4a39e3446f54eeb665252c3cb7f76bcdf5b6dc8ba0fcc8e67f0570d5e93f783e77e833cb499211562e26f922fbe14f507a6e7645cbe45c5f7c9af921e3c4f9b7
+  data.tar.gz: 0205a411504dac570476a891f849542d337f9cf1d44b4462811e3bfdc006b24f3eddd338c27822f7119a9467676cad6f17efdb30c57ddd14ceaf4e15537066d6

data/lib/async/webdriver/bridge/chrome.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+require_relative 'process_group'
+
+module Async
+	module WebDriver
+		module Bridge
+			# A bridge to the Chrome browser using `chromedriver`.
+			#
+			# ``` ruby
+			# begin
+			# 	bridge = Async::WebDriver::Bridge::Chrome.start
+			# 	client = Async::WebDriver::Client.open(bridge.endpoint)
+			# ensure
+			# 	bridge&.close
+			# end
+			# ```
+			class Chrome < Generic
+				# Create a new bridge to Chrome.
+				# @parameter path [String] The path to the `chromedriver` executable.
+				def initialize(path: "chromedriver")
+					super()
+					
+					@path = path
+					@process = nil
+				end
+				
+				# @returns [String] The version of the `chromedriver` executable.
+				def version
+					::IO.popen([@path, "--version"]) do |io|
+						return io.read
+					end
+				rescue Errno::ENOENT
+					return nil
+				end
+				
+				# @returns [Array(String)] The arguments to pass to the `chromedriver` executable.
+				def arguments
+					[
+						"--port=#{self.port}",
+					].compact
+				end
+				
+				# Start the driver.
+				def start
+					@process ||= ProcessGroup.spawn(@path, *arguments)
+					
+					super
+				end
+				
+				# Close the driver.
+				def close
+					super
+					
+					if @process
+						@process.close
+						@process = nil
+					end
+				end
+				
+				# The default capabilities for the Chrome browser which need to be provided when requesting a new session.
+				# @parameter headless [Boolean] Whether to run the browser in headless mode.
+				# @returns [Hash] The default capabilities for the Chrome browser.
+				def default_capabilities(headless: true)
+					{
+						alwaysMatch: {
+							browserName: "chrome",
+							"goog:chromeOptions": {
+								args: [headless ? "--headless" : nil].compact,
+							}
+						},
+					}
+				end
+			end
+		end
+	end
+end

data/lib/async/webdriver/bridge/firefox.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'generic'
+require_relative 'process_group'
+
+module Async
+	module WebDriver
+		module Bridge
+			# A bridge to the Firefox browser using `geckodriver`.
+			#
+			# ``` ruby
+			# begin
+			# 	bridge = Async::WebDriver::Bridge::Firefox.start
+			# 	client = Async::WebDriver::Client.open(bridge.endpoint)
+			# ensure
+			# 	bridge&.close
+			# end
+			class Firefox < Generic
+				# Create a new bridge to Firefox.
+				# @parameter path [String] The path to the `geckodriver` executable.
+				def initialize(path: "geckodriver")
+					super()
+					
+					@path = path
+					@process = nil
+				end
+				
+				# @returns [String] The version of the `geckodriver` executable.
+				def version
+					::IO.popen([@path, "--version"]) do |io|
+						return io.read
+					end
+				rescue Errno::ENOENT
+					return nil
+				end
+				
+				# @returns [Array(String)] The arguments to pass to the `geckodriver` executable.
+				def arguments
+					[
+						"--port", self.port.to_s,
+					].compact
+				end
+				
+				# Start the driver.
+				def start
+					@process ||= ProcessGroup.spawn(@path, *arguments)
+					
+					super
+				end
+				
+				# Close the driver.
+				def close
+					super
+					
+					if @process
+						@process.close
+						@process = nil
+					end
+				end
+				
+				# The default capabilities for the Firefox browser which need to be provided when requesting a new session.
+				# @parameter headless [Boolean] Whether to run the browser in headless mode.
+				# @returns [Hash] The default capabilities for the Firefox browser.
+				def default_capabilities(headless: true)
+					{
+						alwaysMatch: {
+							browserName: "firefox",
+							"moz:firefoxOptions": {
+								"args": [headless ? "-headless" : nil].compact,
+							}
+						}
+					}
+				end
+			end
+		end
+	end
+end

data/lib/async/webdriver/bridge/generic.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require 'socket'
+require 'async/http/endpoint'
+require 'async/http/client'
+
+module Async
+	module WebDriver
+		module Bridge
+			# Generic W3C WebDriver implementation.
+			class Generic
+				# Start the driver and return a new instance.
+				def self.start(**options)
+					self.new(**options).tap do |bridge|
+						bridge.start
+					end
+				end
+				
+				# Initialize the driver.
+				# @parameter port [Integer] The port to listen on.
+				def initialize(port: nil)
+					@port = port
+					@status = nil
+				end
+				
+				# @attribute [String] The status of the driver after a connection has been established.
+				attr :status
+				
+				# @returns [String | Nil] The version of the driver.
+				def version
+					nil
+				end
+				
+				# @returns [Boolean] Is the driver supported/working?
+				def supported?
+					version != nil
+				end
+				
+				# Start the driver.
+				# @parameter retries [Integer] The number of times to retry before giving up.
+				def start(retries: 100)
+					Console.debug(self, "Waiting for driver to start...")
+					count = 0
+					
+					Async::HTTP::Client.open(endpoint) do |client|
+						begin
+							response = client.get("/status")
+							@status = JSON.parse(response.read)["value"]
+							Console.debug(self, "Successfully connected to driver.", status: @status)
+						rescue Errno::ECONNREFUSED
+							if count < retries
+								count += 1
+								sleep(0.001 * count)
+								Console.debug(self, "Driver not ready, retrying...")
+								retry
+							else
+								raise
+							end
+						end
+					end
+				end
+				
+				# Close the driver and any associated resources.
+				def close
+				end
+				
+				# Generate a port number for the driver to listen on if it was not specified.
+				# @returns [Integer] The port the driver is listening on.
+				def port
+					unless @port
+						address = ::Addrinfo.tcp("localhost", 0)
+						address.bind do |socket|
+							# We assume that it's unlikely the port will be reused any time soon...
+							@port = socket.local_address.ip_port
+						end
+					end
+					
+					return @port
+				end
+				
+				# @returns [Async::HTTP::Endpoint] The endpoint the driver is listening on.
+				def endpoint
+					Async::HTTP::Endpoint.parse("http://localhost:#{port}")
+				end
+			end
+		end
+	end
+end

data/lib/async/webdriver/bridge/pool.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+module Async
+	module WebDriver
+		module Bridge
+			# A pool of sessions.
+			#
+			# ``` ruby
+			# begin
+			# 	bridge = Async::WebDriver::Bridge::Pool.start(Async::WebDriver::Bridge::Chrome.new)
+			# 	session = bridge.session
+			# ensure
+			# 	bridge&.close
+			# end
+			# ```
+			class Pool
+				# Create a new session pool and start it.
+				# @parameter bridge [Bridge] The bridge to use to create sessions.
+				# @parameter capabilities [Hash] The capabilities to use when creating sessions.
+				# @returns [Pool] The pool.
+				def self.start(bridge, **options)
+					self.new(bridge, **options).tap do |pool|
+						pool.start
+					end
+				end
+				
+				# Initialize the session pool.
+				# @parameter bridge [Bridge] The bridge to use to create sessions.
+				# @parameter capabilities [Hash] The capabilities to use when creating sessions.
+				# @parameter minimum [Integer] The minimum number of sessions to keep open.
+				def initialize(bridge, capabilities: bridge.default_capabilities, minimum: 2)
+					@bridge = bridge
+					@capabilities = capabilities
+					@minimum = minimum
+					
+					@thread = nil
+					
+					@waiting = Thread::Queue.new
+					@sessions = Thread::Queue.new
+				end
+				
+				# Close the session pool.
+				def close
+					if @waiting
+						@waiting.close
+					end
+					
+					if @thread
+						@thread.join
+						@thread = nil
+					end
+					
+					if @sessions
+						@sessions.close
+					end
+				end
+				
+				private def prepare_session(client)
+					client.post("session", {capabilities: @capabilities})
+				end
+				
+				# Start the session pool.
+				def start
+					@thread ||= Thread.new do
+						Sync do
+							@bridge.start
+							
+							client = Client.open(@bridge.endpoint)
+							
+							@minimum.times do
+								@waiting << true
+							end
+							
+							while @waiting.pop
+								session = prepare_session(client)
+								@sessions << session
+							end
+						ensure
+							client&.close
+							@bridge.close
+						end
+					end
+				end
+				
+				# Open a session.
+				def session(&block)
+					@waiting << true
+					
+					reply = @sessions.pop
+					
+					session = Session.open(@bridge.endpoint, reply["sessionId"], reply["capabilities"])
+					
+					return session unless block_given?
+					
+					begin
+						yield session
+						
+						# Try to reuse the session for extreme performance:
+						reuse(session)
+						session = nil
+					ensure
+						session&.close
+					end
+				end
+				
+				def reuse(session)
+					session.reset!
+					
+					@sessions << {"sessionId" => session.id, "capabilities" => session.capabilities}
+				end
+			end
+		end
+	end
+end

data/lib/async/webdriver/bridge/process_group.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+module Async
+	module WebDriver
+		module Bridge
+			# A group of processes that are all killed when the group is closed.
+			class ProcessGroup
+				# Spawn a new process group with a given command.
+				# @parameter arguments [Array] The command to execute.
+				def self.spawn(*arguments)
+					# This might be problematic...
+					self.new(
+						::Process.spawn(*arguments, pgroup: true, out: File::NULL, err: File::NULL)
+					)
+				end
+				
+				# Create a new process group from an existing process id.
+				# @parameter pid [Integer] The process id.
+				def initialize(pid)
+					@pid = pid
+					
+					@status_task = Async(transient: true) do
+						@status = ::Process.wait(@pid)
+						
+						unless @status.success?
+							Console.error(self, "Process exited unexpectedly: #{@status}")
+						end
+					ensure
+						self.close
+					end
+				end
+				
+				# Close the process group.
+				def close
+					if @status_task
+						@status_task.stop
+						@status_task = nil
+					end
+					
+					if @pid
+						::Process.kill("INT", -@pid)
+						
+						Async do |task|
+							task.with_timeout(1) do
+								::Process.wait(@pid)
+							rescue Errno::ECHILD
+								# Done.
+							rescue Async::TimeoutError
+								Console.info(self, "Killing pid #{@pid}...")
+								::Process.kill("KILL", -@pid)
+							end
+						end.wait
+						
+						wait_all(-@pid)
+						@pid = nil
+					end
+				end
+				
+				protected
+				
+				# Wait for all processes in the group to exit.
+				def wait_all(pgid)
+					while true
+						pid, status = ::Process.wait2(pgid, ::Process::WNOHANG)
+						
+						break unless pid
+					end
+				rescue Errno::ECHILD
+					# Done.
+				end
+			end
+		end
+	end
+end

data/lib/async/webdriver/bridge.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
+
+require_relative 'bridge/chrome'
+require_relative 'bridge/firefox'
+
+module Async
+	module WebDriver
+		# A bridge is a process that can be used to communicate with a browser.
+		# It is not needed in all cases, but is useful when you want to run integration tests without any external drivers/dependencies.
+		# As starting a bridge can be slow, it is recommended to use a shared bridge when possible.
+		module Bridge
+			ALL = [
+				Bridge::Chrome,
+				Bridge::Firefox,
+			]
+			
+			def self.each(&block)
+				return enum_for(:each) unless block_given?
+				
+				ALL.each do |klass|
+					next unless klass.new.supported?
+					yield klass
+				end
+			end
+		end
+	end
+end

data/lib/async/webdriver/client.rb

@@ -1,30 +1,75 @@
-require "async/queue"
+# frozen_string_literal: true
 
-module Async
-  module Webdriver
-    class Client
-      def initialize(endpoint:, desired_capabilities: {})
-        @connection = Connection.new endpoint: endpoint
-        @desired_capabilities = desired_capabilities
-      end
-
-      def session
-        SessionCreator.new connection: @connection, desired_capabilities: @desired_capabilities
-      end
+# Released under the MIT License.
+# Copyright, 2023, by Samuel Williams.
 
-      def status
-        @connection.call method: :get, path: "status"
-      end
+require_relative 'request_helper'
+require_relative 'session'
 
-      def sessions
-        value = @connection.call method: :get, path: "sessions"
-        list = []
-        for json in value do
-          list << Session.new(json: json, connection: @connection)
-        end
-        list
-      end
-
-    end
-  end
+module Async
+	module WebDriver
+		# A client for the WebDriver protocol.
+		#
+		# If you have a running web driver server, you can connect to it like so (assuming it is running on port 4444):
+		#
+		# ``` ruby
+		# begin
+		# 	client = Async::WebDriver::Client.open(Async::HTTP::Endpoint.parse("http://localhost:4444"))
+		# 	session = client.session
+		# ensure
+		# 	client&.close
+		# end
+		# ```
+		class Client
+			include RequestHelper
+			
+			# Open a new session.
+			# @parameter endpoint [Async::HTTP::Endpoint] The endpoint to connect to.
+			# @yields {|client| ...} The client will be closed automatically if you provide a block.
+			# 	@parameter client [Client] The client.
+			# @returns [Client] The client if no block is given.
+			def self.open(endpoint, **options)
+				client = self.new(
+					Async::HTTP::Client.open(endpoint, **options)
+				)
+				
+				return client unless block_given?
+				
+				begin
+					yield client
+				ensure
+					client.close
+				end
+			end
+			
+			# Initialize the client.
+			# @parameter delegate [Protocol::HTTP::Middleware] The underlying HTTP client (or wrapper).
+			def initialize(delegate)
+				@delegate = delegate
+			end
+			
+			# Close the client.
+			def close
+				@delegate.close
+			end
+			
+			# Request a new session.
+			# @returns [Session] The session if no block is given.
+			# @yields {|session| ...} The session will be closed automatically if you provide a block.
+			# 	@parameter session [Session] The session.
+			def session(capabilities, &block)
+				reply = post("session", {capabilities: capabilities})
+				
+				session = Session.new(@delegate, reply["sessionId"], reply["value"])
+				
+				return session unless block_given?
+				
+				begin
+					yield session
+				ensure
+					session.close
+				end
+			end
+		end
+	end
 end