http-fake 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f068555328be1d8bab977bd4ada2cbfbc67691714681cbf0065a6cdb5ae797bf
+  data.tar.gz: c28eecb527f8d7588036974c6af8bc87015b4aea516c36c59f5a6a4e5e46789e
+SHA512:
+  metadata.gz: c175d8a7f3c1d910bf4fdb05189bdf509db4f1a6542a678edf521f7ff889378938214408eee380fc8b00e749e8e030a93d2717b69de50c26e54cdf35912402cd
+  data.tar.gz: 7a9e1828ee3f847caedae2d2f7d73b8ccd7adfba6fa3ec837057ed5fec5c7d64b7c68bcfac854d8822ed33e92e614eebd92f799989e290d4a59be2be3a12f661

data/LICENSE.adoc

@@ -0,0 +1,134 @@
+= Hippocratic License
+
+Version: 2.1.0.
+
+Purpose. The purpose of this License is for the Licensor named above to
+permit the Licensee (as defined below) broad permission, if consistent
+with Human Rights Laws and Human Rights Principles (as each is defined
+below), to use and work with the Software (as defined below) within the
+full scope of Licensor’s copyright and patent rights, if any, in the
+Software, while ensuring attribution and protecting the Licensor from
+liability.
+
+Permission and Conditions. The Licensor grants permission by this
+license ("License"), free of charge, to the extent of Licensor’s
+rights under applicable copyright and patent law, to any person or
+entity (the "Licensee") obtaining a copy of this software and
+associated documentation files (the "Software"), to do everything with
+the Software that would otherwise infringe (i) the Licensor’s copyright
+in the Software or (ii) any patent claims to the Software that the
+Licensor can license or becomes able to license, subject to all of the
+following terms and conditions:
+
+* Acceptance. This License is automatically offered to every person and
+entity subject to its terms and conditions. Licensee accepts this
+License and agrees to its terms and conditions by taking any action with
+the Software that, absent this License, would infringe any intellectual
+property right held by Licensor.
+* Notice. Licensee must ensure that everyone who gets a copy of any part
+of this Software from Licensee, with or without changes, also receives
+the License and the above copyright notice (and if included by the
+Licensor, patent, trademark and attribution notice). Licensee must cause
+any modified versions of the Software to carry prominent notices stating
+that Licensee changed the Software. For clarity, although Licensee is
+free to create modifications of the Software and distribute only the
+modified portion created by Licensee with additional or different terms,
+the portion of the Software not modified must be distributed pursuant to
+this License. If anyone notifies Licensee in writing that Licensee has
+not complied with this Notice section, Licensee can keep this License by
+taking all practical steps to comply within 30 days after the notice. If
+Licensee does not do so, Licensee’s License (and all rights licensed
+hereunder) shall end immediately.
+* Compliance with Human Rights Principles and Human Rights Laws.
+[arabic]
+. Human Rights Principles.
+[loweralpha]
+.. Licensee is advised to consult the articles of the United Nations
+Universal Declaration of Human Rights and the United Nations Global
+Compact that define recognized principles of international human rights
+(the "Human Rights Principles"). Licensee shall use the Software in a
+manner consistent with Human Rights Principles.
+.. Unless the Licensor and Licensee agree otherwise, any dispute,
+controversy, or claim arising out of or relating to (i) Section 1(a)
+regarding Human Rights Principles, including the breach of Section 1(a),
+termination of this License for breach of the Human Rights Principles,
+or invalidity of Section 1(a) or (ii) a determination of whether any Law
+is consistent or in conflict with Human Rights Principles pursuant to
+Section 2, below, shall be settled by arbitration in accordance with the
+Hague Rules on Business and Human Rights Arbitration (the "Rules");
+provided, however, that Licensee may elect not to participate in such
+arbitration, in which event this License (and all rights licensed
+hereunder) shall end immediately. The number of arbitrators shall be one
+unless the Rules require otherwise.
++
+Unless both the Licensor and Licensee agree to the contrary: (1) All
+documents and information concerning the arbitration shall be public and
+may be disclosed by any party; (2) The repository referred to under
+Article 43 of the Rules shall make available to the public in a timely
+manner all documents concerning the arbitration which are communicated
+to it, including all submissions of the parties, all evidence admitted
+into the record of the proceedings, all transcripts or other recordings
+of hearings and all orders, decisions and awards of the arbitral
+tribunal, subject only to the arbitral tribunal’s powers to take such
+measures as may be necessary to safeguard the integrity of the arbitral
+process pursuant to Articles 18, 33, 41 and 42 of the Rules; and (3)
+Article 26(6) of the Rules shall not apply.
+. Human Rights Laws. The Software shall not be used by any person or
+entity for any systems, activities, or other uses that violate any Human
+Rights Laws. "Human Rights Laws" means any applicable laws,
+regulations, or rules (collectively, "Laws") that protect human,
+civil, labor, privacy, political, environmental, security, economic, due
+process, or similar rights; provided, however, that such Laws are
+consistent and not in conflict with Human Rights Principles (a dispute
+over the consistency or a conflict between Laws and Human Rights
+Principles shall be determined by arbitration as stated above). Where
+the Human Rights Laws of more than one jurisdiction are applicable or in
+conflict with respect to the use of the Software, the Human Rights Laws
+that are most protective of the individuals or groups harmed shall
+apply.
+. Indemnity. Licensee shall hold harmless and indemnify Licensor (and
+any other contributor) against all losses, damages, liabilities,
+deficiencies, claims, actions, judgments, settlements, interest, awards,
+penalties, fines, costs, or expenses of whatever kind, including
+Licensor’s reasonable attorneys’ fees, arising out of or relating to
+Licensee’s use of the Software in violation of Human Rights Laws or
+Human Rights Principles.
+* Failure to Comply. Any failure of Licensee to act according to the
+terms and conditions of this License is both a breach of the License and
+an infringement of the intellectual property rights of the Licensor
+(subject to exceptions under Laws, e.g., fair use). In the event of a
+breach or infringement, the terms and conditions of this License may be
+enforced by Licensor under the Laws of any jurisdiction to which
+Licensee is subject. Licensee also agrees that the Licensor may enforce
+the terms and conditions of this License against Licensee through
+specific performance (or similar remedy under Laws) to the extent
+permitted by Laws. For clarity, except in the event of a breach of this
+License, infringement, or as otherwise stated in this License, Licensor
+may not terminate this License with Licensee.
+* Enforceability and Interpretation. If any term or provision of this
+License is determined to be invalid, illegal, or unenforceable by a
+court of competent jurisdiction, then such invalidity, illegality, or
+unenforceability shall not affect any other term or provision of this
+License or invalidate or render unenforceable such term or provision in
+any other jurisdiction; provided, however, subject to a court
+modification pursuant to the immediately following sentence, if any term
+or provision of this License pertaining to Human Rights Laws or Human
+Rights Principles is deemed invalid, illegal, or unenforceable against
+Licensee by a court of competent jurisdiction, all rights in the
+Software granted to Licensee shall be deemed null and void as between
+Licensor and Licensee. Upon a determination that any term or provision
+is invalid, illegal, or unenforceable, to the extent permitted by Laws,
+the court may modify this License to affect the original purpose that
+the Software be used in compliance with Human Rights Principles and
+Human Rights Laws as closely as possible. The language in this License
+shall be interpreted as to its fair meaning and not strictly for or
+against any party.
+* Disclaimer. TO THE FULL EXTENT ALLOWED BY LAW, THIS SOFTWARE COMES
+"AS IS," WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED, AND LICENSOR AND
+ANY OTHER CONTRIBUTOR SHALL NOT BE LIABLE TO ANYONE FOR ANY DAMAGES OR
+OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE
+OR THIS LICENSE, UNDER ANY KIND OF LEGAL CLAIM.
+
+This Hippocratic License is an link:https://ethicalsource.dev[Ethical Source license] and is offered
+for use by licensors and licensees at their own risk, on an "AS IS" basis, and with no warranties
+express or implied, to the maximum extent permitted by Laws.

data/README.adoc

@@ -0,0 +1,214 @@
+:http_link: link:https://github.com/httprb/http[HTTP]
+
+:toc: macro
+:toclevels: 5
+:figure-caption!:
+
+= HTTP Fake
+
+HTTP Fake is a companion to the {http_link} gem when you want a convenient way to test HTTP requests
+by swapping out your _real_ HTTP client with this _fake_ HTTP client. Using a fake allows you to
+speed up and simplify your test suite by answering fake responses without hitting a live API. You'll
+still want to test against a live API, eventually, within your integration tests but at a lower
+level, like your unit tests, you can use this gem instead. This gem is particularly useful when
+using _Dependency Injection_, especially when coupled with the
+link:https://www.alchemists.io/projects/auto_injector[Auto Injector] gem.
+
+toc::[]
+
+== Features
+
+* Provides a fake HTTP client as a testing companion to the {http_link} gem.
+* Supports the following HTTP verbs: CONNECT, DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT, and
+  TRACE.
+* Uses a simple DSL for defining HTTP endpoints, headers, bodies, and statuses.
+* Works well with objects that use _Dependency Injection_.
+* Speeds up your test suite when you don't need a live API.
+
+== Requirements
+
+. link:https://www.ruby-lang.org[Ruby].
+. {http_link}.
+
+== Setup
+
+To install within an existing project, run:
+
+[source,bash]
+----
+bundle add http-fake
+----
+
+You'll want to ensure this gem is part of your _test_ group since it's
+only meant to aid in writing specs.
+
+== Usage
+
+This gem works with any test framework and, for demonstration purposes, we'll assume you're using
+link:https://rspec.info[RSpec]. You can adapt these examples to your test framework of choice. A
+simple spec might look the this:
+
+[source,ruby]
+----
+RSpec.describe Endpoint do
+  subject(:endpoint) { described_class.new http: }
+
+  let :http do
+    HTTP::Fake::Client.new do
+      get "/customers" do
+        headers["Content-Type"] = "application/json"
+        status 200
+
+        <<~JSON
+          {
+            "customers": [
+              {"name": "Jill Smith"}
+            ]
+          }
+        JSON
+      end
+    end
+  end
+
+  describe "#customers" do
+    it "answers customers array when successful" do
+      response = endpoint.customers
+      expect(response.parse).to eq(customers: [{name: "Jill Smith"}])
+    end
+  end
+end
+----
+
+As you can see, our _fake_ `http` client has been defined and injected into our `endpoint` subject.
+When the fake is defined, the path, headers, status, and body are registered as well. This
+allows the fake to match against your real implementation's URL path and swap out making a real HTTP
+call with the canned response defined by the fake. When asking the endpoint for its customers, we
+get back the response as defined by the fake with all of the normal capabilities as if we were using
+the real HTTP client. This works because this gem uses
+link:https://github.com/sinatra/mustermann[Mustermann] for pattern matching against the routes you
+define. This means you can defined routes that are explicit -- as shown above -- or fuzzy based on
+your testing needs. You can also define multiple endpoints for the same fake in case your
+implementation needs to test multiple endpoints at once. Example:
+
+[source,ruby]
+----
+let :http do
+  HTTP::Fake::Client.new do
+    connect("/") { status 200 }
+
+    head("/") { status 200 }
+    options("/") { status 204 }
+
+    get "/customers" do
+      headers["Content-Type"] = "application/json"
+      status 200
+
+      <<~JSON
+        {
+          "customers": [
+            {"name": "Jill Smith"}
+          ]
+        }
+      JSON
+    end
+
+    post "/customers" do
+      headers["Content-Type"] = "application/json"
+      status 201
+      {}
+    end
+
+    put "/customers/1" do
+      headers["Content-Type"] = "application/json"
+      status 200
+    end
+
+    patch "/customers/1" do
+      headers["Content-Type"] = "application/json"
+      status 200
+    end
+
+    delete("/customers/1") { status 204 }
+    trace("/") { status 200 }
+  end
+end
+----
+
+Lastly, in the examples above, I've been showing how you can work with JSON responses but you might
+want to use other MIME types. For example, XML:
+
+[source,ruby]
+----
+HTTP::Fake::Client.new do
+  get "/customers" do
+    headers["Content-Type"] = "application/xml"
+    status 200
+
+    <<~XML
+      <customer>
+        <id>1</id>
+        <name>Jill Smith</name>
+      </customer>
+    XML
+  end
+end
+----
+
+Plain text would work too:
+
+[source,ruby]
+----
+HTTP::Fake::Client.new do
+  get "/customers" do
+    headers["Content-Type"] = "text/plain"
+    status 200
+
+    "1 - Jill Smith"
+  end
+end
+----
+
+Since you have the ability to define your own headers and status codes, you can also test failure
+response behavior as well. I'll leave that up to you to explore and experiment with further.
+
+== Development
+
+Clone the repository and then run:
+
+[source,bash]
+----
+bin/setup
+----
+
+You can also use the IRB console for direct access to all objects:
+
+[source,bash]
+----
+bin/console
+----
+
+== Tests
+
+To test, run:
+
+[source,bash]
+----
+bundle exec rake
+----
+
+== link:https://www.alchemists.io/policies/license[License]
+
+== link:https://www.alchemists.io/policies/security[Security]
+
+== link:https://www.alchemists.io/policies/code_of_conduct[Code of Conduct]
+
+== link:https://www.alchemists.io/policies/contributions[Contributions]
+
+== link:https://www.alchemists.io/projects/http-fake/versions[Versions]
+
+== link:https://www.alchemists.io/community[Community]
+
+== Credits
+
+* Built with link:https://www.alchemists.io/projects/gemsmith[Gemsmith].
+* Engineered by link:https://www.alchemists.io/team/brooke_kuhlmann[Brooke Kuhlmann].

data/http-fake.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "http-fake"
+  spec.version = "0.0.0"
+  spec.authors = ["Brooke Kuhlmann"]
+  spec.email = ["brooke@alchemists.io"]
+  spec.homepage = "https://www.alchemists.io/projects/http-fake"
+  spec.summary = "Provides a fake but equivalent implementation of the HTTP gem for test suites."
+  spec.license = "Hippocratic-2.1"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/bkuhlmann/http-fake/issues",
+    "changelog_uri" => "https://www.alchemists.io/projects/http-fake/versions",
+    "documentation_uri" => "https://www.alchemists.io/projects/http-fake",
+    "funding_uri" => "https://github.com/sponsors/bkuhlmann",
+    "label" => "HTTP Fake",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/bkuhlmann/http-fake"
+  }
+
+  spec.signing_key = Gem.default_key_path
+  spec.cert_chain = [Gem.default_cert_path]
+
+  spec.required_ruby_version = "~> 3.1"
+  spec.add_dependency "http", "~> 5.0"
+  spec.add_dependency "mustermann", "~> 1.1"
+  spec.add_dependency "refinements", "~> 9.4"
+  spec.add_dependency "zeitwerk", "~> 2.5"
+
+  spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
+  spec.files = Dir["*.gemspec", "lib/**/*"]
+end

data/lib/http/fake/builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "uri"
+require "refinements/hashes"
+
+module HTTP
+  module Fake
+    # Builds the response for a request.
+    class Builder
+      using Refinements::Hashes
+
+      ALLOWED_VERBS = /\A(connect|delete|get|head|options|patch|post|put|trace)\z/
+
+      attr_reader :requests
+
+      # :reek:DuplicateMethodCall
+      def initialize verbs: ALLOWED_VERBS, responder: Responder
+        @verbs = verbs
+        @responder = responder
+        @requests ||= Hash.with_default Hash.with_default([])
+        @responders = Hash.with_default []
+      end
+
+      def request verb, uri, arguments = {}
+        responder = responders[verb].find { |fake| fake.match? verb, URI(uri).path }
+        missing_route_error verb, uri unless responder
+        requests[uri][verb] << arguments
+        responder.call uri, arguments
+      end
+
+      def method_missing(verb, *arguments, &)
+        respond_to_missing?(verb) ? add_responder(verb, *arguments, &) : super
+      end
+
+      private
+
+      attr_reader :verbs, :responder, :responders
+
+      def respond_to_missing?(verb, include_private = false) = verbs.match?(verb) || super
+
+      def add_responder verb, pattern, &block
+        responder.new(verb, pattern, block).then do |instance|
+          responders[[verb, pattern]].append instance
+        end
+      end
+
+      def missing_route_error verb, uri
+        fail StandardError, "No route for #{verb.upcase} #{uri} in responders: #{responders}."
+      end
+    end
+  end
+end

data/lib/http/fake/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTP
+  module Fake
+    # Provides the primary client for dealing with fake requests and responses.
+    class Client
+      include Chainable
+      extend Forwardable
+
+      delegate %i[requests] => :builder
+
+      def initialize builder: Builder.new, requester: Requester, &block
+        @builder = builder
+        @requester = requester
+        @builder.instance_eval(&block)
+      end
+
+      private
+
+      attr_reader :builder, :requester
+
+      def branch(arguments) = requester.new arguments, builder:
+    end
+  end
+end

data/lib/http/fake/connector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Fake
+    # Connects an HTTP request and response together.
+    class Connector
+      def initialize version: Connection::HTTP_1_1, request: Request, response: Response
+        @version = version
+        @request = request
+        @response = response
+      end
+
+      def call **arguments
+        response.new defaults.merge(
+          request: build_request(**arguments),
+          **arguments.slice(:headers, :version, :body, :status)
+        )
+      end
+
+      private
+
+      attr_reader :version, :request, :response
+
+      def defaults = {headers: {}, version:, status: 200}
+
+      def build_request(**arguments) = request.new arguments.slice :verb, :uri
+    end
+  end
+end

data/lib/http/fake/requester.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Fake
+    # Handles an incoming request.
+    class Requester
+      include Chainable
+
+      def initialize defaults = {}, builder: Builder.new
+        @defaults = defaults
+        @builder = builder
+      end
+
+      def request(verb, uri, arguments = {}) = builder.request verb, uri, defaults.merge(arguments)
+
+      private
+
+      attr_reader :defaults, :builder
+
+      def branch(arguments) = self.class.new defaults.merge(arguments), builder:
+    end
+  end
+end

data/lib/http/fake/responder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "mustermann"
+require "refinements/strings"
+
+module HTTP
+  module Fake
+    # Handles an outgoing response.
+    class Responder
+      using Refinements::Strings
+
+      attr_reader :headers
+
+      def initialize verb, pattern, function
+        @verb = verb
+        @pattern = Mustermann.new pattern
+        @function = function
+        @headers = {}
+      end
+
+      def match?(verb, path) = !String(pattern.match(path)).blank? && verb == self.verb
+
+      def call path, arguments = {}
+        pattern.params(path)
+               .then { |params| instance_exec(params, arguments, &function) }
+               .then { |data| connect path, data }
+      end
+
+      def status(code = nil) = @status ||= code
+
+      private
+
+      attr_reader :verb, :pattern, :function
+
+      def connect path, data
+        Connector.new.call verb:,
+                           uri: "https://example.com/#{path}",
+                           headers:,
+                           body: body(data),
+                           status:
+      end
+
+      def body(data) = data == status ? "" : data
+    end
+  end
+end

data/lib/http/fake.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "http"
+
+Zeitwerk::Loader.new.then do |loader|
+  loader.push_dir "#{__dir__}/.."
+  loader.inflector.inflect "http" => "HTTP"
+  loader.setup
+end
+
+module HTTP
+  # Main namespace.
+  module Fake
+  end
+end

data.tar.gz.sig

@@ -0,0 +1 @@
+���@Fp.�S锡���!���`�)5�[��a�{�o�a�0Ƒ��uwj;WH�49G~t	��d�n~�#]<�A�ރ-l�v���³k��+�
b9*��]�qg>��%�}W�8���U6.X����4�(�{��j�;

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: http-fake
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Brooke Kuhlmann
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIC/jCCAeagAwIBAgIBBTANBgkqhkiG9w0BAQsFADAlMSMwIQYDVQQDDBpicm9v
+  a2UvREM9YWxjaGVtaXN0cy9EQz1pbzAeFw0yMjAzMTkxNzI0MzJaFw0yMzAzMTkx
+  NzI0MzJaMCUxIzAhBgNVBAMMGmJyb29rZS9EQz1hbGNoZW1pc3RzL0RDPWlvMIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6l1qpXTiomH1RfMRloyw7MiE
+  xyVx/x8Yc3EupdH7uhNaTXQGyORN6aOY//1QXXMHIZ9tW74nZLhesWMSUMYy0XhB
+  brs+KkurHnc9FnEJAbG7ebGvl/ncqZt72nQvaxpDxvuCBHgJAz+8i5wl6FhLw+oT
+  9z0A8KcGhz67SdcoQiD7qiCjL/2NTeWHOzkpPrdGlt088+VerEEGf5I13QCvaftP
+  D5vkU0YlAm1r98BymuJlcQ1qdkVEI1d48ph4kcS0S0nv1RiuyVb6TCAR3Nu3VaVq
+  3fPzZKJLZBx67UvXdbdicWPiUR75elI4PXpLIic3xytaF52ZJYyKZCNZJhNwfQID
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU0nzow9vc
+  2CdikiiE3fJhP/gY4ggwDQYJKoZIhvcNAQELBQADggEBAJbbNyWzFjqUNVPPCUCo
+  IMrhDa9xf1xkORXNYYbmXgoxRy/KyNbUr+jgEEoWJAm9GXlcqxxWAUI6pK/i4/Qi
+  X6rPFEFmeObDOHNvuqy8Hd6AYsu+kP94U/KJhe9wnWGMmGoNKJNU3EkW3jM/osSl
+  +JRxiH5t4WtnDiVyoYl5nYC02rYdjJkG6VMxDymXTqn7u6HhYgZkGujq1UPar8x2
+  hNIWJblDKKSu7hA2d6+kUthuYo13o1sg1Da/AEDg0hoZSUvhqDEF5Hy232qb3pDt
+  CxDe2+VuChj4I1nvIHdu+E6XoEVlanUPKmSg6nddhkKn2gC45Kyzh6FZqnzH/CRp
+  RFE=
+  -----END CERTIFICATE-----
+date: 2022-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: refinements
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.4'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description:
+email:
+- brooke@alchemists.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.adoc
+- LICENSE.adoc
+files:
+- LICENSE.adoc
+- README.adoc
+- http-fake.gemspec
+- lib/http/fake.rb
+- lib/http/fake/builder.rb
+- lib/http/fake/client.rb
+- lib/http/fake/connector.rb
+- lib/http/fake/requester.rb
+- lib/http/fake/responder.rb
+homepage: https://www.alchemists.io/projects/http-fake
+licenses:
+- Hippocratic-2.1
+metadata:
+  bug_tracker_uri: https://github.com/bkuhlmann/http-fake/issues
+  changelog_uri: https://www.alchemists.io/projects/http-fake/versions
+  documentation_uri: https://www.alchemists.io/projects/http-fake
+  funding_uri: https://github.com/sponsors/bkuhlmann
+  label: HTTP Fake
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/bkuhlmann/http-fake
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.13
+signing_key:
+specification_version: 4
+summary: Provides a fake but equivalent implementation of the HTTP gem for test suites.
+test_files: []