capybara-httpx 1.0.0.preview1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46bee3c9c3076e589388e150cfd02f6f45d8ff11065b2072590e39f702bff1ba
+  data.tar.gz: 8d7855cd4fa44d789f58738a3b25acf934879538f1efacdda84b830fc6b11782
+SHA512:
+  metadata.gz: a6f652a7fa29d6e6f5e181e0adc628ebd4702ad3954cd406bd28b380fd1ea982ca56bbf1fcb6061c5ac8895f375d9078ffc2f1e325514402d1ca2f01b3b92aee
+  data.tar.gz: 7ffa6525764f05bb4a9e570e9d3104840c213b2d2c5b2125c130a8c5c71302b3e89701c3f365f05003a58e81ce7f7752961d4219a1cf1d0d907be090ceedf3a1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Tron Jonathan and HALTER Joseph
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+Capybara-HTTPX
+==============
+
+[![Build Status](https://github.com/TalentBox/capybara-httpx/actions/workflows/ci.yml/badge.svg)](https://github.com/TalentBox/capybara-httpx/actions)
+
+A [Capybara](https://github.com/teamcapybara/capybara) driver that uses
+[HTTPX](https://github.com/HoneyryderChuck/httpx) to make HTTP requests to a
+Rack application, including applications running on a remote host. This project
+is based on [TalentBox/capybara-typhoeus](https://github.com/TalentBox/capybara-typhoeus),
+with HTTPX replacing Typhoeus as its HTTP client.
+
+This driver is intended for testing APIs. It does not implement browser features
+such as JavaScript, clicking controls, or submitting forms through the DOM.
+
+## Installation
+
+```sh
+gem install capybara-httpx
+```
+
+Or add `capybara-httpx` to your Gemfile. HTTPX is installed as a runtime
+dependency.
+
+## Usage
+
+```ruby
+require "capybara/httpx"
+
+session = Capybara::Session.new(:httpx, app)
+session.get "/users"
+```
+
+For remote testing, configure the host as usual:
+
+```ruby
+Capybara.app_host = "https://api.example.com"
+```
+
+The driver can also be selected in Cucumber using the `@httpx` tag. Require
+`capybara/httpx/cucumber` from `env.rb`:
+
+```ruby
+require "capybara/httpx/cucumber"
+```
+
+```gherkin
+@httpx
+Scenario: request API data
+  When I send a GET request to /users
+```
+
+The driver provides `authenticate_with`, `request_body`, and `as=` helpers on
+its session. Request options set through `driver.with_options` are passed to
+HTTPX. The default request timeout is three seconds and can be customized when
+registering a driver:
+
+```ruby
+Capybara.register_driver :httpx_with_custom_timeout do |app|
+  Capybara::HTTPX::Driver.new(app, timeout: 1)
+end
+```
+
+Array query parameters use HTTPX-style bracket notation by default. The
+`params_encoding` driver setting can also be set to `:rack`, `:multi`, or
+`:none`.
+
+## Running tests
+
+```sh
+bundle install
+bundle exec rake
+```
+
+CI runs the test suite on currently supported Ruby release series: 3.4, 4.0,
+and 4.1.
+
+## License
+
+Copyright (c) 2010 Tron Jonathan and HALTER Joseph. See [LICENSE](LICENSE) for
+details.

data/lib/capybara/httpx/browser.rb

@@ -0,0 +1,250 @@
+require "base64"
+require "json"
+require "uri"
+
+class Capybara::HTTPX::Browser < Capybara::RackTest::Browser
+  LastRequest = Struct.new(:method, :url, :params, :headers) do
+    def path
+      URI.parse(url).path
+    end
+
+    def fullpath
+      URI.parse(url).request_uri
+    end
+
+    def request_method
+      method.to_s.upcase
+    end
+
+    def env
+      headers
+    end
+  end
+
+  class ResponseAdapter
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+
+    def status
+      response.status
+    end
+
+    def headers
+      response.headers
+    end
+
+    def body
+      response.body
+    end
+
+    def uri
+      response.uri
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def redirect?
+      [301, 302, 303, 307, 308].include?(status)
+    end
+  end
+
+  class TimeoutResponse
+    attr_reader :uri, :status, :headers, :body
+
+    def initialize(uri)
+      @uri = URI.parse(uri)
+      @status = 0
+      @headers = {}
+      @body = ""
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def redirect?
+      false
+    end
+  end
+
+  attr_accessor :request_body
+  attr_reader :last_request, :last_response
+
+  def reset_cache!
+    @xml = nil
+    @json = nil
+    super
+  end
+
+  def refresh
+    reset_cache!
+    send(last_request.method, last_request.url, last_request.params, last_request.headers)
+  end
+
+  def current_url
+    return "" unless last_response
+
+    uri = build_uri(last_response.uri.to_s)
+    uri.fragment = @current_fragment if @current_fragment
+    uri.to_s
+  end
+
+  def dom
+    @dom ||= begin
+      content_type = if last_response
+        last_response.headers["Content-Type"].to_s[/\A[^;]+/] || ""
+      else
+        ""
+      end
+      content_type.include?("/xml") ? xml : Capybara::HTML(html)
+    end
+  end
+
+  def html
+    last_response ? last_response.body.to_s : ""
+  end
+
+  def xml
+    @xml ||= Nokogiri::XML(html)
+  end
+
+  def json
+    @json ||= JSON.parse(html)
+  end
+
+  def timed_out?
+    @timed_out || false
+  end
+
+  %i[get post put delete head patch request].each do |method|
+    define_method(method) do |url, params = {}, headers = {}, &block|
+      @last_request = LastRequest.new(method, url, params.dup, headers.dup)
+      uri = URI.parse(url)
+      request_headers = driver.with_headers.merge(
+        { "Content-Type" => driver.as, "Accept" => driver.as }.merge(headers)
+      )
+      referer = request_headers.delete("HTTP_REFERER")
+      request_headers["Referer"] = referer if referer
+      request_headers["Cookie"] ||= cookie_jar.for(uri)
+
+      if driver.auth?
+        credentials = Base64.strict_encode64("#{driver.login}:#{driver.password}")
+        request_headers["Authorization"] ||= "Basic #{credentials}"
+      end
+
+      request_params = driver.with_params.merge(params)
+      request_params.delete(:params_encoding)
+      encoded_params = encode_params(request_params, params[:params_encoding] || driver.params_encoding)
+      unless encoded_params.empty?
+        uri.query = [uri.query, encoded_params].compact.reject(&:empty?).join("&")
+      end
+
+      options = {
+        timeout: { request_timeout: driver.options[:timeout] },
+        max_redirects: driver.follow_redirects? ? driver.redirect_limit : 0
+      }.merge(driver.with_options)
+      if options[:timeout].is_a?(Numeric)
+        options[:timeout] = { request_timeout: options[:timeout] }
+      end
+
+      http = ::HTTPX.plugin(:follow_redirects).with(options)
+      @timed_out = false
+      response = http.request(method.to_s.upcase, uri.to_s, headers: request_headers, body: request_body)
+      @request_body = nil
+      if response.is_a?(::HTTPX::ErrorResponse)
+        raise response.error unless response.error.is_a?(::HTTPX::TimeoutError)
+
+        @timed_out = true
+        @last_response = TimeoutResponse.new(uri.to_s)
+      else
+        cookie_jar.merge(response.headers["set-cookie"], uri)
+        @last_response = ResponseAdapter.new(response)
+      end
+    rescue ::HTTPX::TimeoutError
+      @timed_out = true
+      @request_body = nil
+      @last_response = TimeoutResponse.new(uri.to_s)
+    end
+  end
+
+  private
+
+  def encode_params(params, encoding)
+    pairs = case encoding
+    when :httpx
+      flatten_httpx_params(params)
+    when :rack
+      flatten_rack_params(params)
+    when :multi
+      flatten_multi_params(params)
+    when :none
+      params.map { |key, value| [key.to_s, value.to_s] }
+    end
+    URI.encode_www_form(pairs)
+  end
+
+  def flatten_httpx_params(params, prefix = nil, pairs = [])
+    params.each do |key, value|
+      name = prefix ? "#{prefix}[#{key}]" : key.to_s
+      case value
+      when Hash
+        flatten_httpx_params(value, name, pairs)
+      when Array
+        value.each { |entry| flatten_httpx_array(name, entry, pairs) }
+      else
+        pairs << [name, value]
+      end
+    end
+    pairs
+  end
+
+  def flatten_httpx_array(name, value, pairs)
+    case value
+    when Hash
+      value.each { |key, entry| flatten_httpx_array("#{name}[#{key}]", entry, pairs) }
+    when Array
+      value.each { |entry| flatten_httpx_array("#{name}[]", entry, pairs) }
+    else
+      pairs << ["#{name}[]", value]
+    end
+  end
+
+  def flatten_rack_params(params, prefix = nil, pairs = [])
+    params.each do |key, value|
+      name = prefix ? "#{prefix}[#{key}]" : key.to_s
+      case value
+      when Hash
+        flatten_rack_params(value, name, pairs)
+      when Array
+        value.each { |entry| pairs << ["#{name}[]", entry] }
+      else
+        pairs << [name, value]
+      end
+    end
+    pairs
+  end
+
+  def flatten_multi_params(params, prefix = nil, pairs = [])
+    params.each do |key, value|
+      name = prefix ? "#{prefix}[#{key}]" : key.to_s
+      case value
+      when Hash
+        flatten_multi_params(value, name, pairs)
+      when Array
+        value.each { |entry| pairs << [name, entry] }
+      else
+        pairs << [name, value]
+      end
+    end
+    pairs
+  end
+
+  def cookie_jar
+    @cookie_jar ||= Rack::Test::CookieJar.new [], current_host
+  end
+end

data/lib/capybara/httpx/cucumber.rb

@@ -0,0 +1,6 @@
+require "capybara/httpx"
+
+Before "@httpx" do
+  Capybara.current_driver = :httpx
+  page.driver.reset_with!
+end

data/lib/capybara/httpx/driver.rb

@@ -0,0 +1,102 @@
+class Capybara::HTTPX::Driver < Capybara::RackTest::Driver
+  attr_writer :as, :with_headers, :with_params, :with_options
+  attr_reader :login, :password, :params_encoding
+
+  def initialize(app, **options)
+    raise ArgumentError, "httpx requires a rack application, but none was given" unless app
+
+    super app, **{ timeout: 3 }.merge(options)
+    @params_encoding = :httpx
+  end
+
+  def browser
+    @browser ||= Capybara::HTTPX::Browser.new self
+  end
+
+  def needs_server?
+    true
+  end
+
+  PARAMS_ENCODING_ALLOWED_VALUES = %i[httpx rack multi none].freeze
+
+  def params_encoding=(value)
+    if PARAMS_ENCODING_ALLOWED_VALUES.include?(value)
+      @params_encoding = value
+    else
+      allowed = PARAMS_ENCODING_ALLOWED_VALUES.map(&:inspect).join(", ")
+      raise ArgumentError, "Allowed values are: #{allowed}"
+    end
+  end
+
+  %i[get post put delete head patch request].each do |method|
+    define_method(method) do |url, params = {}, headers = {}, &block|
+      browser.reset_host!
+      browser.process method, url, params, headers, &block
+    end
+  end
+
+  def reset!
+    @login = nil
+    @password = nil
+    super
+  end
+
+  def timed_out?
+    browser.timed_out?
+  end
+
+  def reset_with!
+    @with_headers = {}
+    @with_params = {}
+    @with_options = {}
+    @as = nil
+  end
+
+  def as
+    @as ||= "application/json"
+  end
+
+  def with_headers
+    @with_headers ||= {}
+  end
+
+  def with_params
+    @with_params ||= {}
+  end
+
+  def with_options
+    @with_options ||= {}
+  end
+
+  def authenticate_with(login, password)
+    @login, @password = login, password
+  end
+
+  def auth?
+    login && password
+  end
+
+  def status_code
+    response.status
+  end
+
+  def body
+    browser.html
+  end
+
+  def xml
+    browser.xml
+  end
+
+  def json
+    browser.json
+  end
+
+  def request_body
+    browser.request_body
+  end
+
+  def request_body=(value)
+    browser.request_body = value
+  end
+end

data/lib/capybara/httpx/session.rb

@@ -0,0 +1,50 @@
+class Capybara::HTTPX::Session < Capybara::Session
+  %i[get post put delete head patch request].each do |method|
+    define_method(method) do |url, params = {}, headers = {}, &block|
+      @touched = true
+      driver.public_send(method, host_url(url), params, headers, &block)
+    end
+  end
+
+  def authenticate_with(login, password)
+    driver.authenticate_with login, password
+  end
+
+  def timed_out?
+    driver.timed_out?
+  end
+
+  def host_url(url)
+    if url !~ /^http/ && Capybara.app_host
+      url = Capybara.app_host + url.to_s
+    end
+
+    if @server
+      url = "http://#{@server.host}:#{@server.port}" + url.to_s unless url =~ /^http/
+
+      if Capybara.always_include_port
+        uri = URI.parse(url)
+        uri.port = @server.port if uri.port == uri.default_port
+        url = uri.to_s
+      end
+    end
+
+    url
+  end
+
+  def timeout
+    driver.options[:timeout]
+  end
+
+  def request_body
+    driver.request_body
+  end
+
+  def request_body=(value)
+    driver.request_body = value
+  end
+
+  def as=(value)
+    driver.as = value
+  end
+end

data/lib/capybara/httpx.rb

@@ -0,0 +1,24 @@
+require "capybara"
+require "httpx"
+
+module Capybara
+  module HTTPX
+    autoload :Driver, "capybara/httpx/driver"
+    autoload :Browser, "capybara/httpx/browser"
+    autoload :Session, "capybara/httpx/session"
+  end
+
+  def self.session_pool
+    @session_pool ||= Hash.new do |hash, name|
+      hash[name] = if current_driver==:httpx
+        ::Capybara::HTTPX::Session.new(current_driver, app)
+      else
+        ::Capybara::Session.new(current_driver, app)
+      end
+    end
+  end
+end
+
+Capybara.register_driver :httpx do |app|
+  Capybara::HTTPX::Driver.new app
+end

data/spec/session/httpx_spec.rb

@@ -0,0 +1,237 @@
+require "spec_helper"
+
+Capybara.register_driver :httpx_with_custom_timeout do |app|
+  Capybara::HTTPX::Driver.new app, timeout: 1
+end
+
+module TestSessions
+  HTTPXTest = Capybara::Session.new(:httpx, TestApp)
+  HTTPXTestCustomTimeout = Capybara::Session.new(:httpx_with_custom_timeout, TestApp)
+end
+
+skipped_tests = %i[
+  js
+  modals
+  screenshot
+  frames
+  windows
+  send_keys
+  server
+  hover
+  about_scheme
+  download
+  css
+  scroll
+  active_element
+  html_validation
+  shadow_dom
+]
+Capybara::SpecHelper.run_specs TestSessions::HTTPXTest, 'HTTPX', capybara_skip: skipped_tests do |example|
+  case example.metadata[:full_description]
+  when /#attach_file/
+    skip "HTTPX driver doesn't support #attach_file"
+  when /#check/
+    skip "HTTPX driver doesn't support #check"
+  when /#uncheck/
+    skip "HTTPX driver doesn't support #uncheck"
+  when /#click/
+    skip "HTTPX driver doesn't support #click"
+  when /#select/
+    skip "HTTPX driver doesn't support #select"
+  when /#unselect/
+    skip "HTTPX driver doesn't support #unselect"
+  when /#has_css\? with spatial requirements/
+    skip "HTTPX driver doesn't support #has_css? with spatial requirements"
+  when /#find with spatial filters/
+    skip "HTTPX driver doesn't support #find with spatial filters"
+  when /can set cookie if a blank path is specified/
+    skip "HTTPX driver doesn't support cookie"
+  when /has_css\? should support case insensitive :class and :id options/
+    skip "Nokogiri doesn't support case insensitive CSS attribute matchers"
+  end
+end
+
+RSpec.describe Capybara::HTTPX::Session do
+
+  context "with httpx driver" do
+    before { Capybara.current_driver = :httpx }
+    let(:session) { TestSessions::HTTPXTest }
+
+    describe 'Capybara#current_session' do
+      it 'should be a httpx session' do
+        expect(Capybara.current_session).to be_an_instance_of(Capybara::HTTPX::Session)
+      end
+    end
+
+    describe '#driver' do
+      it 'should be a httpx driver' do
+        expect(session.driver).to be_an_instance_of(Capybara::HTTPX::Driver)
+      end
+    end
+
+    describe '#mode' do
+      it 'should remember the mode' do
+        expect( session.mode ).to eq(:httpx)
+      end
+    end
+
+    context "basic authentication" do
+      subject do
+        app = Sinatra.new do
+          use Rack::Auth::Basic do |username, password|
+            username=="admin" && password=="secret"
+          end
+          get("/"){ "Success!" }
+        end
+        described_class.new :httpx, app
+      end
+
+      it "allow access with right credentials" do
+        subject.authenticate_with "admin", "secret"
+        subject.get "/"
+        expect( subject.status_code ).to be 200
+        expect( subject.source ).to eq "Success!"
+      end
+
+      it "deny access with wrong credentials" do
+        subject.authenticate_with "admin", "admin"
+        subject.get "/"
+        expect( subject.status_code ).to be 401
+      end
+    end
+
+    context "params encoding" do
+      context "setting on driver" do
+        let(:driver) { session.driver }
+        it "defaults to :httpx" do
+          expect( driver.params_encoding ).to eq :httpx
+        end
+        it "can be set to :rack, :multi or :none" do
+          driver.params_encoding = :rack
+          expect( driver.params_encoding ).to eq :rack
+          driver.params_encoding = :multi
+          expect( driver.params_encoding ).to eq :multi
+          driver.params_encoding = :none
+          expect( driver.params_encoding ).to eq :none
+
+          expect do
+            driver.params_encoding = :unknown
+          end.to raise_error ArgumentError, "Allowed values are: :httpx, :rack, :multi, :none"
+        end
+      end
+      context "usage in requests" do
+        subject do
+          app = Sinatra.new do
+            get("/"){ params.inspect }
+          end
+          described_class.new :httpx, app
+        end
+        it "defaults to driver setting" do
+          subject.get "/", ids: [1, 2, 3]
+          expect( subject.body ).to eq({"ids" => ["1", "2", "3"]}.inspect)
+
+          subject.driver.params_encoding = :rack
+          subject.get "/", ids: [1, 2, 3]
+          expect( subject.body ).to eq({"ids" => ["1", "2", "3"]}.inspect)
+
+          subject.driver.params_encoding = :multi
+          subject.get "/", ids: [1, 2, 3]
+          expect( subject.body ).to eq({"ids" => "3"}.inspect)
+
+          subject.driver.params_encoding = :none
+          subject.get "/", ids: [1, 2, 3]
+          expect( subject.body ).to eq({"ids" => "[1, 2, 3]"}.inspect)
+        end
+        it "can be overriden per request" do
+          subject.driver.params_encoding = :none
+
+          subject.get "/", ids: [1, 2, 3], params_encoding: :httpx
+          expect( subject.body ).to eq({"ids" => ["1", "2", "3"]}.inspect)
+
+          subject.get "/", ids: [1, 2, 3], params_encoding: :rack
+          expect( subject.body ).to eq({"ids" => ["1", "2", "3"]}.inspect)
+
+          subject.get "/", ids: [1, 2, 3], params_encoding: :multi
+          expect( subject.body ).to eq({"ids" => "3"}.inspect)
+
+          subject.driver.params_encoding = :httpx
+
+          subject.get "/", ids: [1, 2, 3], params_encoding: :none
+          expect( subject.body ).to eq({"ids" => "[1, 2, 3]"}.inspect)
+        end
+      end
+    end
+
+    context "timeout" do
+      subject{ described_class.new :httpx, TestApp }
+
+      context "default" do
+        it "is 3 seconds" do
+          expect( subject.timeout ).to eq 3
+        end
+
+        it "is used during request" do
+          subject.get "/slow_response"
+          expect( subject ).not_to be_timed_out
+        end
+      end
+
+      context "accepts custom timeout" do
+        subject{ described_class.new :httpx_with_custom_timeout, TestApp }
+
+        it "is stored in options" do
+          expect( subject.timeout ).to eq 1
+        end
+
+        it "is used during request" do
+          subject.get "/slow_response"
+          expect( subject ).to be_timed_out
+        end
+      end
+    end
+
+    context "#host_url returns url with scheme, host, port and path" do
+      subject{ described_class.new :httpx, TestApp }
+
+      it "with empty url" do
+        expect( subject.host_url("") ).to match /\A#{Regexp.escape("http://127.0.0.1")}:\d+\z/
+      end
+
+      it "with relative url" do
+        expect( subject.host_url("/demo/test") ).to match /\A#{Regexp.escape("http://127.0.0.1")}:\d+\/demo\/test\z/
+      end
+
+      it "with absolute url" do
+        expect(
+          subject.host_url("http://www.example.com:443/demo/test")
+        ).to eq "http://www.example.com:443/demo/test"
+      end
+    end
+
+    context "can upload file by setting the body per request" do
+      subject do
+        app = Sinatra.new do
+          post("/"){ request.body }
+        end
+        described_class.new :httpx, app
+      end
+
+      it "body is nil be default" do
+        expect( subject.request_body ).to be_nil
+        subject.post "/"
+        expect( subject.status_code ).to be 200
+        expect( subject.source ).to eq ""
+      end
+
+      it "I can send data by setting the body" do
+        body = "**raw file content**"
+        subject.request_body = body
+        expect( subject.request_body ).to eq body
+        subject.post "/"
+        expect( subject.status_code ).to be 200
+        expect( subject.source ).to eq body
+        expect( subject.request_body ).to be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "bundler/setup"
+require "capybara/httpx"
+require "capybara/spec/spec_helper"
+require 'pry'
+
+RSpec.configure do |config|
+  Capybara::SpecHelper.configure config
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: capybara-httpx
+version: !ruby/object:Gem::Version
+  version: 1.0.0.preview1
+platform: ruby
+authors:
+- Joseph HALTER
+- Jonathan TRON
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: HTTPX driver for Capybara, allowing testing of REST APIs
+email:
+- jonathan.tron@metrilio.com
+- joseph.halter@metrilio.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/capybara/httpx.rb
+- lib/capybara/httpx/browser.rb
+- lib/capybara/httpx/cucumber.rb
+- lib/capybara/httpx/driver.rb
+- lib/capybara/httpx/session.rb
+- spec/session/httpx_spec.rb
+- spec/spec_helper.rb
+homepage: https://forgejo.home.tron.name/metrilio/capybara-httpx
+licenses:
+- MIT
+metadata: {}
+rdoc_options:
+- "--main"
+- README.md
+- "--inline-source"
+- "--line-numbers"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: HTTPX driver for Capybara
+test_files:
+- spec/session/httpx_spec.rb
+- spec/spec_helper.rb