fakeweb-fi 1.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 742a936bc6d1a455aca033093a1e4bd14fff4f061fd2ceb03a9459d16eafaa15
+  data.tar.gz: 9691ac5c32afbd62d81b5ca4dd6ee290925874ed2834276a6afaf52049448025
+SHA512:
+  metadata.gz: 9d3eee80f16fe00194e90f408c65a9b0db584cf5c10abb5b253d8964edf67b97ec093487c0fa1350bf7ad4919532e2401182c66287b69a6473be8e2e1107927e
+  data.tar.gz: b1df647b979d76fbdebdbd2a54ffe5d56016847f6ed564583fb65d2ed046ee737af2f5463dd1d48bf884e2cd9a9ad9582434f50f4376cc9559f1af8a6ef52d5f

data/CHANGELOG

@@ -0,0 +1,248 @@
+fakeweb (master branch pending release)
+
+* fix a variety of NoMethodErrors when Net::HTTP#read_timeout= or
+  Net::HTTP#continue_timeout= is called after a Net::HTTP object has handled a
+  first fake request under newer versions of Ruby and/or some gems (Mechanize,
+  aws-sdk, etc.) [Marcel Massana, Trevor Rowe, Chris Kampmeier]
+
+* add ability to accept a StringIO as a fake response body
+  [Larry Diehl, Andy Delcambre, Chris Kampmeier]
+
+* fix an exception when an IO is passed in as a fake response body
+  [Chris Kampmeier]
+
+* stub responses with no bodies (e.g. to a HEAD request) now return nil for
+  #body, not an empty string, to match Net::HTTP's behavior [Myron Marston]
+
+* fix warnings on post-1.8 versions of Ruby [Peter Hellberg, Kenichi Kamiya]
+
+* fix that the options hash passed to FakeWeb.register_uri would sometimes be
+  modified [Chris Kampmeier]
+
+* raise an ArgumentError when FakeWeb.register_uri's third argument can't be
+  handled as an options hash [David Cornu, Josef Strzibny, Chris Kampmeier]
+
+* raise the more-specific ArgumentError instead of StandardError when the object
+  passed to FakeWeb.register_uri's :response option can't be handled; this
+  should be relatively backwards-compatible because ArgumentError descends from
+  StandardError [Chris Kampmeier]
+
+* deprecation warnings now detect the caller more robustly to work with JRuby's
+  backtraces [Chris Kampmeier]
+
+
+fakeweb (1.3.0)
+
+* improve response header registration so you can pass an array to set a header
+  more than once [Myron Marston]
+
+* fix an exception when the response's :body option was set to nil [Chris Zingel]
+
+* fix that stubbed requests weren't mutating the Net::HTTP request object to set
+  the body and content-length, like real requests do [Chris Kampmeier]
+
+* add FakeWeb.last_request [Chris Kampmeier]
+
+* assigning a String or Regexp to FakeWeb.allow_net_connect= sets a whitelist
+  for outbound requests [Dan Dofter, Tim Carey-Smith, Ben Woosley]
+
+
+fakeweb (1.2.8)
+
+* support Pathname objects where a filename is expected [Chris Kampmeier]
+
+* fix compatibility with Ruby 1.9.2 [Chris Kampmeier]
+
+* simplify storage of FakeWeb::VERSION [Josh Peek, Woody Peterson, Ben Woosley]
+
+
+fakeweb (1.2.7)
+
+* revert to sorting query params before matching requests against regexps,
+  instead of the 1.2.6 behavior that tried every possible order combination;
+  that was factorial-time, which made matching hang for requests with long query
+  strings [Jason Wadsworth, David Dollar, Blaine Cook]
+
+* print a warning when FakeWeb is loaded before RightHttpConnection or after
+  Samuel, other libs that patch Net::HTTP [Chris Kampmeier, Ben Brinckerhoff]
+
+
+fakeweb (1.2.6)
+
+* fix that query params in a regex would have to be sorted for it to ever match
+  a request URI [Chris Kampmeier, Ben Hall]
+
+* improve regex handling so registration with an explicit port (like
+  /example.com:80/) matches a request that uses an implied port
+  (like "http://example.com/") [Chris Kampmeier, Dan Dofter]
+
+* refactor URI registry to reduce duplication; now about twice as fast at
+  handling requests [Chris Kampmeier]
+
+* Add FakeWeb::VERSION so you can programmatically determine what version of
+  FakeWeb is loaded without using RubyGems [Chris Kampmeier, Chris Wanstrath]
+
+
+fakeweb (1.2.5)
+
+* fix handling of userinfo strings that contain percent-encoded unsafe
+  characters [Chris Kampmeier, Ken Mayer]
+
+* fix that exact matches against strings/URIs with the :any method had a lower
+  precedence than regex matches using a real HTTP method (exact matches now
+  always take precedence) [Chris Kampmeier]
+
+* change request handling to raise an exception when more than one registered
+  regex matches a request URI [Chris Kampmeier]
+
+
+fakeweb (1.2.4)
+
+* add experimental support for matching URIs via regular expressions
+  [Jacqui Maher, Tiago Albineli Motta, Peter Wagene]
+
+* fix an exception when registering with the :response option and a string that
+  is the same as the name of a directory in the current path [Chris Kampmeier]
+
+* DEPRECATION: Calling FakeWeb.register_uri with a :string or :file option is
+  now deprecated. Both options have been replaced with a unified :body option,
+  since they supply the response body (as opposed to :response, which supplies
+  the full response including headers) [Chris Kampmeier]
+
+* add support for specifying HTTP headers as options to FakeWeb.register_uri
+  when using the :string or :file response types, since those methods only
+  specify a response body [David Michael, Chris Kampmeier]
+
+* DEPRECATION: Calling FakeWeb.register_uri and FakeWeb.registered_uri? without
+  an HTTP method as the first argument is now deprecated. To match against any
+  HTTP method (the pre-1.2.0 behavior), use :any [Chris Kampmeier]
+
+
+fakeweb (1.2.3)
+
+* fix the #http_version of :file and :string responses, which was returning the
+  request URI instead of something sensible like "1.0" [Chris Kampmeier]
+
+* add method aliases in the Net::HTTP patch to eliminate warnings when running
+  with -w [Joshua Clingenpeel]
+
+* fix that removing the redefinition of OpenURI::HTTPError in 1.2.0 caused
+  :exception responses to raise when OpenURI isn't available [Chris Kampmeier]
+
+* fix registering an :exception response with classes that require arguments for
+  instantiation, like Interrupt's subclasses [Chris Kampmeier]
+
+
+fakeweb (1.2.2)
+
+* fix that HTTP Digest and OAuth requests could raise URI::InvalidURIErrors
+  [Bill Kocik, Chris Kampmeier]
+
+
+fakeweb (1.2.1)
+
+* fix that query parameters are handled correctly when registering with a URI
+  object [Anselmo Alves, Chris Kampmeier]
+
+* fix an exception when registering with the :response option and a string
+  containing "\0" [Jonathan Baudanza, Chris Kampmeier]
+
+* fix that trailing slashes were considered significant for requests to the root
+  of a domain [Chris Kampmeier]
+
+* add support for HTTP basic authentication via userinfo strings in URIs
+  [Michael Bleigh]
+
+
+fakeweb (1.2.0)
+
+* add lib/fakeweb.rb so you can require "fakeweb" as well [Chris Kampmeier]
+
+* fix compatibility with Ruby 1.9.1 [Chris Kampmeier]
+
+* fix that newlines in file-based responses could be doubled in the response
+  object's body [Mark Menard, Chris Kampmeier]
+
+* fix unnecessary munging of the transfer-encoding header, which improves
+  compatibility with mechanize [Mark Menard]
+
+* fix a test and the RCov dependency to be compatible with JRuby [Mark Menard]
+
+* remove an unnecessary redefinition of OpenURI::HTTPError [Josh Nichols]
+
+* rearrange implementation code into separate files, one per class [Josh Nichols]
+
+* fix a bug where FakeWeb.response_for would raise if the request wasn't
+  registered [Chris Kampmeier]
+
+* add HTTP method support, so FakeWeb takes both the URI and method into
+  account for registration, requests, and responses. Backwards-compatible with
+  the old method signatures, which didn't have a method param. [Chris Kampmeier]
+
+* start work on Ruby 1.9 compatibility [Chris Kampmeier]
+
+* add FakeWeb.allow_net_connect= to enable/disable the pass-through to
+  Net::HTTP for unregistered URIs [Mislav Marohnić, Chris Kampmeier]
+
+* remove setup.rb, since most people use RubyGems [Mislav Marohnić]
+
+* fix that 'http://example.com/?' (empty query) matches a registered
+  'http://example.com/', and vice-versa [Mislav Marohnić]
+
+* improve the test suite to not rely on an internet connection [Chris Kampmeier]
+
+* use `rake test` instead of `rake tests` [Josh Nichols]
+
+* fix an incompatibility with Ruby 1.8.6 p36 where you'd get "Errno::EINTR:
+  Interrupted system call" exceptions in Socket#sysread for any non-faked
+  request [Chris Kampmeier]
+
+* response rotation: you can now optionally call FakeWeb.register_uri with an
+  array of options hashes; these are used, in order, to respond to
+  repeated requests (to repeat a response more than once before rotating, use
+  the :times option). Once you run out of responses, further requests always
+  receive the last response. [Michael Shapiro]
+
+* add support for Net::HTTP's undocumented full-URI request style (fixes
+  URI::InvalidURIErrors that you might see in older libraries) [Chris Kampmeier]
+
+* sort query params before storing internally, so that
+  http://example.com/?a=1&b=2 and http://example.com/?b=2&a=1 are considered the
+  same URL (although this is technically incorrect, it's much more
+  convenient--most web apps work that way, and Net::HTTP's use of a hash to pass
+  query params means that the order in which FakeWeb stores them can be
+  unpredictable) [Chris Kampmeier]
+
+* add support for ports in URLs, so that http://example.com/ and
+  http://example.com:3000/ are not the same [Chris Kampmeier]
+
+* fix for non-faked SSL requests failing with "Unable to create local socket"
+  [Chris Kampmeier]
+
+* update Rakefile to fix warning about deprecated code [Chris Kampmeier]
+
+
+fakeweb (1.1.2)
+
+* add required dependencies to GemSpec to ensure that tests pass in firebrigade
+  (http://firebrigade.seattlerb.org/) [Blaine Cook]
+
+
+fakeweb (1.1.1)
+
+* fix for non-existence of :string method on File as presented by open-uri
+  [Blaine Cook]
+
+* fix for curl example test - google redirects to ccTLDs for those outside US
+  [Blaine Cook]
+
+
+fakeweb (1.1.0)
+
+* update code to correspond to ruby 1.8.4 (breaks compatibility with ruby 1.8.2)
+  [Blaine Cook]
+
+
+fakeweb (1.0.0)
+
+  * initial import [Blaine Cook]

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2006-2010 Blaine Cook, Chris Kampmeier, and other contributors
+
+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.rdoc

@@ -0,0 +1,203 @@
+= FakeWeb
+
+FakeWeb is a helper for faking web requests in Ruby. It works at a global
+level, without modifying code or writing extensive stubs.
+
+
+== Installation
+
+* You can install the latest release from RubyGems:
+
+    gem install fakeweb
+
+  Note that the gem was previously registered as +FakeWeb+, switching
+  to +fakeweb+ in 2009. All releases are available under the new name.
+
+* If your application uses Bundler, add a line like this to your Gemfile:
+
+    gem "fakeweb", "~> 1.3"
+
+  You may want to specify <tt>:group => :test</tt> and/or
+  <tt>:require => false</tt>, depending on how you use Bundler.
+
+* If you're developing a gem, add a line like this to your gemspec:
+
+    spec.add_development_dependency "fakeweb", ["~> 1.3"]
+
+
+== Help and discussion
+
+RDocs for the current release are available at http://fakeweb.rubyforge.org.
+
+There's a mailing list for questions and discussion at
+https://groups.google.com/d/forum/fakeweb-users.
+
+The main source repository is https://github.com/chrisk/fakeweb.
+
+{<img src="https://travis-ci.org/chrisk/fakeweb.png?branch=master" alt="Build Status" style="vertical-align: text-top" />}[https://travis-ci.org/chrisk/fakeweb] FakeWeb's tests run at https://travis-ci.org/chrisk/fakeweb.
+
+== Examples
+
+Start by requiring FakeWeb:
+
+  require 'fakeweb'
+
+=== Registering basic string responses
+
+  FakeWeb.register_uri(:get, "http://example.com/test1", :body => "Hello World!")
+
+  Net::HTTP.get(URI.parse("http://example.com/test1"))
+  => "Hello World!"
+
+  Net::HTTP.get(URI.parse("http://example.com/test2"))
+  => FakeWeb is bypassed and the response from a real request is returned
+
+You can also call <tt>register_uri</tt> with a regular expression, to match
+more than one URI.
+
+  FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "Hello World!")
+
+  Net::HTTP.get(URI.parse("http://example.com/test3"))
+  => "Hello World!"
+
+=== Replaying a recorded response
+
+  page = `curl -is http://www.google.com/`
+  FakeWeb.register_uri(:get, "http://www.google.com/", :response => page)
+
+  Net::HTTP.get(URI.parse("http://www.google.com/"))
+  # => Full response, including headers
+
+=== Adding a custom status to the response
+
+  FakeWeb.register_uri(:get, "http://example.com/", :body => "Nothing to be found 'round here",
+                                                    :status => ["404", "Not Found"])
+
+  Net::HTTP.start("example.com") do |req|
+    response = req.get("/")
+    response.code     # => "404"
+    response.message  # => "Not Found"
+    response.body     # => "Nothing to be found 'round here"
+  end
+
+=== Responding to any HTTP method
+
+  FakeWeb.register_uri(:any, "http://example.com", :body => "response for any HTTP method")
+
+If you use the <tt>:any</tt> symbol, the URI you specify will be completely
+stubbed out (regardless of the HTTP method of the request). This can be useful
+for RPC-style services, where the HTTP method isn't significant. (Older
+versions of FakeWeb always behaved like this, and didn't accept the first
++method+ argument above; this syntax is now deprecated.)
+
+=== Rotating responses
+
+You can optionally call <tt>FakeWeb.register_uri</tt> with an array of options
+hashes; these are used, in order, to respond to repeated requests. Once you run
+out of responses, further requests always receive the last response. (You can
+also send a response more than once before rotating, by specifying a
+<tt>:times</tt> option for that response.)
+
+  FakeWeb.register_uri(:delete, "http://example.com/posts/1",
+                       [{:body => "Post 1 deleted.", :status => ["200", "OK"]},
+                        {:body => "Post not found",  :status => ["404", "Not Found"]}])
+
+  Net::HTTP.start("example.com") do |req|
+    req.delete("/posts/1").body  # => "Post 1 deleted"
+    req.delete("/posts/1").body  # => "Post not found"
+    req.delete("/posts/1").body  # => "Post not found"
+  end
+
+=== Using HTTP basic authentication
+
+You can fake requests that use basic authentication by adding +userinfo+ strings
+to your URIs:
+
+  FakeWeb.register_uri(:get, "http://example.com/secret", :body => "Unauthorized", :status => ["401", "Unauthorized"])
+  FakeWeb.register_uri(:get, "http://user:pass@example.com/secret", :body => "Authorized")
+
+  Net::HTTP.start("example.com") do |http|
+    req = Net::HTTP::Get.new("/secret")
+    http.request(req)  # => "Unauthorized"
+    req.basic_auth("user", "pass")
+    http.request(req)  # => "Authorized"
+  end
+
+=== Clearing registered URIs
+
+The FakeWeb registry is a singleton that lasts for the duration of your program,
+maintaining every fake response you register. If needed, you can clean out the
+registry and remove all registered URIs:
+
+  FakeWeb.clean_registry
+
+=== Blocking all real requests
+
+When you're using FakeWeb to replace _all_ of your requests, it's useful to
+catch when requests are made for unregistered URIs (unlike the default
+behavior, which is to pass those requests through to Net::HTTP as usual).
+
+  FakeWeb.allow_net_connect = false
+  Net::HTTP.get(URI.parse("http://example.com/"))
+  => raises FakeWeb::NetConnectNotAllowedError
+
+  FakeWeb.allow_net_connect = true
+  Net::HTTP.get(URI.parse("http://example.com/"))
+  => FakeWeb is bypassed and the response from a real request is returned
+
+It's recommended that you set <tt>FakeWeb.allow_net_connect = false</tt> in the
+setup for your tests.
+
+==== Allowing requests to a specific server
+
+If you want to prevent your tests from hitting the internet while allowing
+access to a specific server for integration testing, you can assign a URI or
++Regexp+ to be used as a whitelist for outbound requests:
+
+  FakeWeb.allow_net_connect = %r[^https?://localhost]
+  Net::HTTP.get(URI.parse("http://localhost/path"))  # => allowed
+  Net::HTTP.get(URI.parse("http://example.com/"))    # => raises FakeWeb::NetConnectNotAllowedError
+
+=== Specifying HTTP response headers
+
+When you register a response using the <tt>:body</tt> option, you're only
+setting the body of the response. If you want to add headers to these responses,
+simply add the header as an option to +register_uri+:
+
+  FakeWeb.register_uri(:get, "http://example.com/hello.txt", :body => "Hello", :content_type => "text/plain")
+
+This sets the "Content-Type" header in the response.
+
+=== Checking the last request
+
+It's often useful to retrieve the last request made by your code, so you can
+write tests for its content. FakeWeb keeps track of the last request, whether it
+was stubbed or not:
+
+  Net::HTTP.get(URI.parse("http://example.com"))
+  FakeWeb.last_request  # => Net::HTTP::Get request object
+
+== More info
+
+FakeWeb lets you decouple your test environment from live services without
+modifying code or writing extensive stubs.
+
+In addition to the conceptual advantage of having idempotent request
+behaviour, FakeWeb makes tests run faster than if they were made to remote (or
+even local) web servers. It also makes it possible to run tests without a
+network connection or in situations where the server is behind a firewall or
+has host-based access controls.
+
+FakeWeb works with anything based on Net::HTTP--both higher-level wrappers,
+like OpenURI, as well as a ton of libraries for popular web services.
+
+
+== Known Issues
+
+* Request bodies are ignored, including PUT and POST parameters. If you need
+  different responses for different request bodies, you need to request
+  different URLs, and register different responses for each. (Query strings are
+  fully supported, though.) We're currently considering how the API should
+  change to add support for request bodies in 1.3.0. Your input would be really
+  helpful: see https://groups.google.com/d/msg/fakeweb-users/RNGQprEuQnM/ryCiMeBD91YJ
+  for a discussion of some different options. Thanks!

data/lib/fake_web.rb

@@ -0,0 +1,213 @@
+require 'fake_web/ext/net_http'
+require 'fake_web/registry'
+require 'fake_web/response'
+require 'fake_web/responder'
+require 'fake_web/stub_socket'
+require 'fake_web/utility'
+
+FakeWeb::Utility.record_loaded_net_http_replacement_libs
+FakeWeb::Utility.puts_warning_for_net_http_around_advice_libs_if_needed
+
+module FakeWeb
+
+  # Returns the version string for the copy of FakeWeb you have loaded.
+  VERSION = '1.3.0'
+
+  # Resets the FakeWeb Registry. This will force all subsequent web requests to
+  # behave as real requests.
+  def self.clean_registry
+    Registry.instance.clean_registry
+  end
+
+  # Enables or disables real HTTP connections for requests that don't match
+  # registered URIs.
+  #
+  # If you set <tt>FakeWeb.allow_net_connect = false</tt> and subsequently try
+  # to make a request to a URI you haven't registered with .register_uri, a
+  # NetConnectNotAllowedError will be raised. This is handy when you want to
+  # make sure your tests are self-contained, or want to catch the scenario
+  # when a URI is changed in implementation code without a corresponding test
+  # change.
+  #
+  # When <tt>FakeWeb.allow_net_connect = true</tt> (the default), requests to
+  # URIs not stubbed with FakeWeb are passed through to Net::HTTP.
+  #
+  # If you assign a +String+, +URI+, or +Regexp+ object, unstubbed requests
+  # will be allowed if they match that value. This is useful when you want to
+  # allow access to a local server for integration testing, while still
+  # preventing your tests from using the internet.
+  def self.allow_net_connect=(allowed)
+    case allowed
+    when String, URI, Regexp
+      @allow_all_connections = false
+      Registry.instance.register_passthrough_uri(allowed)
+    else
+      @allow_all_connections = allowed
+      Registry.instance.remove_passthrough_uri
+    end
+  end
+
+  # Enable pass-through to Net::HTTP by default.
+  self.allow_net_connect = true
+
+  # Returns +true+ if requests to URIs not registered with FakeWeb are passed
+  # through to Net::HTTP for normal processing (the default). Returns +false+
+  # if an exception is raised for these requests.
+  #
+  # If you've assigned a +String+, +URI+, or +Regexp+ to
+  # <tt>FakeWeb.allow_net_connect=</tt>, you must supply a URI to check
+  # against that filter. Otherwise, an ArgumentError will be raised.
+  def self.allow_net_connect?(uri = nil)
+    if Registry.instance.passthrough_uri_map.any?
+      raise ArgumentError, "You must supply a URI to test" if uri.nil?
+      Registry.instance.passthrough_uri_matches?(uri)
+    else
+      @allow_all_connections
+    end
+  end
+
+  # This exception is raised if you set <tt>FakeWeb.allow_net_connect =
+  # false</tt> and subsequently try to make a request to a URI you haven't
+  # stubbed.
+  class NetConnectNotAllowedError < StandardError; end;
+
+  # This exception is raised if a Net::HTTP request matches more than one of
+  # the stubs you've registered. To fix the problem, remove a duplicate
+  # registration or disambiguate any regular expressions by making them more
+  # specific.
+  class MultipleMatchingURIsError < StandardError; end;
+
+  # call-seq:
+  #   FakeWeb.register_uri(method, uri, options)
+  #
+  # Register requests using the HTTP method specified by the symbol +method+
+  # for +uri+ to be handled according to +options+. If you specify the method
+  # <tt>:any</tt>, the response will be reigstered for any request for +uri+.
+  # +uri+ can be a +String+, +URI+, or +Regexp+ object. +options+ must be either
+  # a +Hash+ or an +Array+ of +Hashes+ (see below), which must contain one of
+  # these two keys:
+  #
+  # <tt>:body</tt>::
+  #   A string which is used as the body of the response. If the string refers
+  #   to a valid filesystem path, the contents of that file will be read and used
+  #   as the body of the response instead. (This used to be two options,
+  #   <tt>:string</tt> and <tt>:file</tt>, respectively. These are now deprecated.)
+  # <tt>:response</tt>::
+  #   Either a <tt>Net::HTTPResponse</tt>, +IO+, +StringIO+, or +String+, which
+  #   is used as the full response for the request.
+  #
+  #   The easier way by far is to pass the <tt>:response</tt> option to
+  #   +register_uri+ as a +String+ or an (open for reads) +IO+ object which
+  #   will be used as the complete HTTP response, including headers and body.
+  #   If the string points to a readable file, this file will be used as the
+  #   content for the request.
+  #
+  #   To obtain a complete response document, you can use the +curl+ command,
+  #   like so:
+  #
+  #     curl -i http://example.com > response_from_example.com
+  #
+  #   which can then be used in your test environment like so:
+  #
+  #     FakeWeb.register_uri(:get, "http://example.com", :response => "response_from_example.com")
+  #
+  #   See the <tt>Net::HTTPResponse</tt>
+  #   documentation[http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/classes/Net/HTTPResponse.html]
+  #   for more information on creating custom response objects.
+  #
+  # +options+ may also be an +Array+ containing a list of the above-described
+  # +Hash+. In this case, FakeWeb will rotate through each response. You can
+  # optionally repeat a response more than once before rotating:
+  #
+  # <tt>:times</tt>::
+  #   The number of times this response will be used before moving on to the
+  #   next one. The last response will be repeated indefinitely, regardless of
+  #   its <tt>:times</tt> parameter.
+  #
+  # Two optional arguments are also accepted:
+  #
+  # <tt>:status</tt>::
+  #   Passing <tt>:status</tt> as a two-value array will set the response code
+  #   and message. The defaults are <tt>200</tt> and <tt>OK</tt>, respectively.
+  #   Example:
+  #     FakeWeb.register_uri(:get, "http://example.com", :body => "Go away!", :status => [404, "Not Found"])
+  # <tt>:exception</tt>::
+  #   The argument passed via <tt>:exception</tt> will be raised when the
+  #   specified URL is requested. Any +Exception+ class is valid. Example:
+  #     FakeWeb.register_uri(:get, "http://example.com", :exception => Net::HTTPError)
+  #
+  # If you're using the <tt>:body</tt> response type, you can pass additional
+  # options to specify the HTTP headers to be used in the response. Example:
+  #
+  #   FakeWeb.register_uri(:get, "http://example.com/index.txt", :body => "Hello", :content_type => "text/plain")
+  #
+  # You can also pass an array of header values to include a header in the
+  # response more than once:
+  #
+  #   FakeWeb.register_uri(:get, "http://example.com", :set_cookie => ["name=value", "example=1"])
+  def self.register_uri(*args)
+    case args.length
+    when 3
+      Registry.instance.register_uri(*args)
+    when 2
+      print_missing_http_method_deprecation_warning(*args)
+      Registry.instance.register_uri(:any, *args)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 3)")
+    end
+  end
+
+  # call-seq:
+  #   FakeWeb.response_for(method, uri)
+  #
+  # Returns the faked Net::HTTPResponse object associated with +method+ and +uri+.
+  def self.response_for(*args, &block) #:nodoc: :yields: response
+    case args.length
+    when 2
+      Registry.instance.response_for(*args, &block)
+    when 1
+      print_missing_http_method_deprecation_warning(*args)
+      Registry.instance.response_for(:any, *args, &block)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 2)")
+    end
+  end
+
+  # call-seq:
+  #   FakeWeb.registered_uri?(method, uri)
+  #
+  # Returns true if a +method+ request for +uri+ is registered with FakeWeb.
+  # Specify a method of <tt>:any</tt> to check against all HTTP methods.
+  def self.registered_uri?(*args)
+    case args.length
+    when 2
+      Registry.instance.registered_uri?(*args)
+    when 1
+      print_missing_http_method_deprecation_warning(*args)
+      Registry.instance.registered_uri?(:any, *args)
+    else
+      raise ArgumentError.new("wrong number of arguments (#{args.length} for 2)")
+    end
+  end
+
+  # Returns the request object from the last request made via Net::HTTP.
+  def self.last_request
+    @last_request
+  end
+
+  def self.last_request=(request) #:nodoc:
+    @last_request = request
+  end
+
+  private
+
+  def self.print_missing_http_method_deprecation_warning(*args)
+    method = caller.first.match(/`(.*?)'/)[1]
+    new_args = args.map { |a| a.inspect }.unshift(":any")
+    new_args.last.gsub!(/^\{|\}$/, "").gsub!("=>", " => ") if args.last.is_a?(Hash)
+    $stderr.puts
+    $stderr.puts "Deprecation warning: FakeWeb requires an HTTP method argument (or use :any). Try this:"
+    $stderr.puts "  FakeWeb.#{method}(#{new_args.join(', ')})"
+    $stderr.puts "Called at #{caller[1]}"
+  end
+end

data/lib/fake_web/ext/net_http.rb

@@ -0,0 +1,60 @@
+require 'net/http'
+require 'net/https'
+require 'stringio'
+
+module Net  #:nodoc: all
+
+  class BufferedIO
+    eval <<-RUBY
+      def initialize_with_fakeweb(*args#{", **opts" if RUBY_VERSION >= "2.4.0" })
+        initialize_without_fakeweb(*args#{", **opts" if RUBY_VERSION >= "2.4.0" })
+        @io = FakeWeb::Utility.io_from_fake_response_object(@io)
+      end
+    RUBY
+    alias_method :initialize_without_fakeweb, :initialize
+    alias_method :initialize, :initialize_with_fakeweb
+  end
+
+  class HTTP
+    class << self
+      def socket_type_with_fakeweb
+        FakeWeb::StubSocket
+      end
+      alias_method :socket_type_without_fakeweb, :socket_type
+      alias_method :socket_type, :socket_type_with_fakeweb
+    end
+
+    def request_with_fakeweb(request, body = nil, &block)
+      FakeWeb.last_request = request
+
+      uri = FakeWeb::Utility.request_uri_as_string(self, request)
+      method = request.method.downcase.to_sym
+
+      if FakeWeb.registered_uri?(method, uri)
+        @socket = Net::HTTP.socket_type.new
+        FakeWeb::Utility.produce_side_effects_of_net_http_request(request, body)
+        FakeWeb.response_for(method, uri, &block)
+      elsif FakeWeb.allow_net_connect?(uri)
+        connect_without_fakeweb
+        request_without_fakeweb(request, body, &block)
+      else
+        uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+        raise FakeWeb::NetConnectNotAllowedError,
+              "Real HTTP connections are disabled. Unregistered request: #{request.method} #{uri}"
+      end
+    end
+    alias_method :request_without_fakeweb, :request
+    alias_method :request, :request_with_fakeweb
+
+
+    def connect_with_fakeweb
+      unless @@alredy_checked_for_net_http_replacement_libs ||= false
+        FakeWeb::Utility.puts_warning_for_net_http_replacement_libs_if_needed
+        @@alredy_checked_for_net_http_replacement_libs = true
+      end
+      nil
+    end
+    alias_method :connect_without_fakeweb, :connect
+    alias_method :connect, :connect_with_fakeweb
+  end
+end

data/lib/fake_web/registry.rb

@@ -0,0 +1,132 @@
+require 'singleton'
+
+module FakeWeb
+  class Registry #:nodoc:
+    include Singleton
+
+    attr_accessor :uri_map, :passthrough_uri_map
+
+    def initialize
+      clean_registry
+    end
+
+    def clean_registry
+      self.uri_map = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def register_uri(method, uri, options)
+      uri_map[normalize_uri(uri)][method] = [*[options]].flatten.collect do |option|
+        if !option.respond_to?(:keys)
+          raise ArgumentError.new("Expected options hash: #{option.inspect}")
+        end
+        FakeWeb::Responder.new(method, uri, option, option[:times])
+      end
+    end
+
+    def registered_uri?(method, uri)
+      !responders_for(method, uri).empty?
+    end
+
+    def response_for(method, uri, &block)
+      responders = responders_for(method, uri)
+      return nil if responders.empty?
+
+      next_responder = responders.last
+      responders.each do |responder|
+        if responder.times and responder.times > 0
+          responder.times -= 1
+          next_responder = responder
+          break
+        end
+      end
+
+      next_responder.response(&block)
+    end
+
+    def register_passthrough_uri(uri)
+      self.passthrough_uri_map = {normalize_uri(uri) => {:any => true}}
+    end
+
+    def remove_passthrough_uri
+      self.passthrough_uri_map = {}
+    end
+
+    def passthrough_uri_matches?(uri)
+      uri = normalize_uri(uri)
+      uri_map_matches(passthrough_uri_map, :any, uri, URI) ||
+      uri_map_matches(passthrough_uri_map, :any, uri, Regexp)
+    end
+
+    private
+
+    def responders_for(method, uri)
+      uri = normalize_uri(uri)
+
+      uri_map_matches(uri_map, method, uri, URI) ||
+      uri_map_matches(uri_map, :any,   uri, URI) ||
+      uri_map_matches(uri_map, method, uri, Regexp) ||
+      uri_map_matches(uri_map, :any,   uri, Regexp) ||
+      []
+    end
+
+    def uri_map_matches(map, method, uri, type_to_check = URI)
+      uris_to_check = variations_of_uri_as_strings(uri)
+
+      matches = map.select { |registered_uri, method_hash|
+        registered_uri.is_a?(type_to_check) && method_hash.has_key?(method)
+      }.select { |registered_uri, method_hash|
+        if type_to_check == URI
+          uris_to_check.include?(registered_uri.to_s)
+        elsif type_to_check == Regexp
+          uris_to_check.any? { |u| u.match(registered_uri) }
+        end
+      }
+
+      if matches.size > 1
+        raise MultipleMatchingURIsError,
+          "More than one registered URI matched this request: #{method.to_s.upcase} #{uri}"
+      end
+
+      matches.map { |_, method_hash| method_hash[method] }.first
+    end
+
+
+    def variations_of_uri_as_strings(uri_object)
+      normalized_uri = normalize_uri(uri_object.dup)
+      normalized_uri_string = normalized_uri.to_s
+
+      variations = [normalized_uri_string]
+
+      # if the port is implied in the original, add a copy with an explicit port
+      if normalized_uri.default_port == normalized_uri.port
+        variations << normalized_uri_string.sub(
+                        /#{Regexp.escape(normalized_uri.request_uri)}$/,
+                        ":#{normalized_uri.port}#{normalized_uri.request_uri}")
+      end
+
+      variations
+    end
+
+    def normalize_uri(uri)
+      return uri if uri.is_a?(Regexp)
+      normalized_uri =
+        case uri
+        when URI then uri
+        when String
+          uri = 'http://' + uri unless uri.match('^https?://')
+          URI.parse(uri)
+        end
+      normalized_uri.query = sort_query_params(normalized_uri.query)
+      normalized_uri.normalize
+    end
+
+    def sort_query_params(query)
+      if query.nil? || query.empty?
+        nil
+      else
+        query.split('&').sort.join('&')
+      end
+    end
+
+  end
+end

data/lib/fake_web/responder.rb

@@ -0,0 +1,127 @@
+module FakeWeb
+  class Responder #:nodoc:
+
+    attr_accessor :method, :uri, :options, :times
+    KNOWN_OPTIONS = [:body, :exception, :response, :status].freeze
+
+    def initialize(method, uri, options, times)
+      self.method = method
+      self.uri = uri
+      self.options = options
+      self.times = times ? times : 1
+
+      if options.has_key?(:file) || options.has_key?(:string)
+        print_file_string_options_deprecation_warning
+        options[:body] = options.delete(:file) || options.delete(:string)
+      end
+    end
+
+    def response(&block)
+      if has_baked_response?
+        response = baked_response
+      else
+        code, msg = meta_information
+        response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
+        response.instance_variable_set(:@body, body)
+        headers_extracted_from_options.each do |name, value|
+          if value.respond_to?(:each)
+            value.each { |v| response.add_field(name, v) }
+          else
+            response[name] = value
+          end
+        end
+      end
+
+      response.instance_variable_set(:@read, true)
+      response.extend FakeWeb::Response
+
+      optionally_raise(response)
+
+      yield response if block_given?
+
+      response
+    end
+
+    private
+
+    def headers_extracted_from_options
+      options.reject {|name, _| KNOWN_OPTIONS.include?(name) }.map { |name, value|
+        [name.to_s.split("_").map { |segment| segment.capitalize }.join("-"), value]
+      }
+    end
+
+    def body
+      body = options[:body]
+      return nil if body.to_s == ''
+
+      body = body.to_s if defined?(Pathname) && body.is_a?(Pathname)
+
+      if !body.include?("\0") && File.exist?(body) && !File.directory?(body)
+        File.read(body)
+      else
+        body
+      end
+    end
+
+    def baked_response
+      response = options[:response]
+      response = response.to_s if defined?(Pathname) && response.is_a?(Pathname)
+
+      if response.is_a?(String) || response.is_a?(IO) || response.is_a?(StringIO)
+        socket = Net::BufferedIO.new(response)
+        r = Net::HTTPResponse.read_new(socket)
+
+        # Store the original transfer-encoding
+        saved_transfer_encoding = r.instance_eval {
+          @header['transfer-encoding'] if @header.key?('transfer-encoding')
+        }
+
+        # Read the body of response
+        r.instance_eval { @header['transfer-encoding'] = nil }
+        r.reading_body(socket, true) {}
+
+        # Delete the transfer-encoding key from r.@header if there wasn't one;
+        # otherwise, restore the saved_transfer_encoding
+        if saved_transfer_encoding.nil?
+          r.instance_eval { @header.delete('transfer-encoding') }
+        else
+          r.instance_eval { @header['transfer-encoding'] = saved_transfer_encoding }
+        end
+        r
+      elsif response.is_a?(Net::HTTPResponse)
+        response
+      else
+        raise ArgumentError, "Handler not implemented for response #{response.inspect}"
+      end
+    end
+
+    def has_baked_response?
+      options.has_key?(:response)
+    end
+
+    def optionally_raise(response)
+      return unless options.has_key?(:exception)
+
+      case options[:exception].to_s
+      when "Net::HTTPError", "OpenURI::HTTPError"
+        raise options[:exception].new('Exception from FakeWeb', response)
+      else
+        raise options[:exception].new('Exception from FakeWeb')
+      end
+    end
+
+    def meta_information
+      options.has_key?(:status) ? options[:status] : [200, 'OK']
+    end
+
+    def print_file_string_options_deprecation_warning
+      which = options.has_key?(:file) ? :file : :string
+      first_external_caller = caller.detect { |line| !line.include?("/lib/fake_web") }
+      $stderr.puts
+      $stderr.puts "Deprecation warning: FakeWeb's :#{which} option has been renamed to :body."
+      $stderr.puts "Just replace :#{which} with :body in your FakeWeb.register_uri calls."
+      $stderr.puts "Called at #{first_external_caller}"
+    end
+
+  end
+end

data/lib/fake_web/response.rb

@@ -0,0 +1,10 @@
+module FakeWeb
+  module Response #:nodoc:
+
+    def read_body(*args, &block)
+      yield @body if block_given?
+      @body
+    end
+
+  end
+end

data/lib/fake_web/stub_socket.rb

@@ -0,0 +1,23 @@
+module FakeWeb
+  class StubSocket #:nodoc:
+
+    Net::BufferedIO.instance_methods.grep(/_timeout$/).each do |timeout|
+      attr_accessor timeout
+    end
+
+    def initialize(*args)
+    end
+
+    def closed?
+      @closed ||= false
+      @closed
+    end
+
+    def close
+      @closed = true
+    end
+
+    def readuntil(*args)
+    end
+  end
+end

data/lib/fake_web/utility.rb

@@ -0,0 +1,98 @@
+module FakeWeb
+  module Utility #:nodoc:
+
+    def self.decode_userinfo_from_header(header)
+      header.sub(/^Basic /, "").unpack("m").first
+    end
+
+    def self.encode_unsafe_chars_in_userinfo(userinfo)
+      unsafe_in_userinfo = /[^#{URI::REGEXP::PATTERN::UNRESERVED};&=+$,]|^(#{URI::REGEXP::PATTERN::ESCAPED})/
+      userinfo.split(":").map { |part| uri_escape(part, unsafe_in_userinfo) }.join(":")
+    end
+
+    def self.strip_default_port_from_uri(uri)
+      case uri
+      when %r{^http://}  then uri.sub(%r{:80(/|$)}, '\1')
+      when %r{^https://} then uri.sub(%r{:443(/|$)}, '\1')
+      else uri
+      end
+    end
+
+    # Returns a string with a normalized version of a Net::HTTP request's URI.
+    def self.request_uri_as_string(net_http, request)
+      protocol = net_http.use_ssl? ? "https" : "http"
+
+      path = request.path
+      path = URI.parse(request.path).request_uri if request.path =~ /^http/
+
+      if request["authorization"] =~ /^Basic /
+        userinfo = FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
+        userinfo = FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
+      else
+        userinfo = ""
+      end
+
+      "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
+    end
+
+    # Wrapper that falls back to URI.escape for compatibility with 1.8
+    def self.uri_escape(*args)
+      houdini = URI.const_defined?(:Parser) ? URI::Parser.new : URI
+      houdini.escape(*args)
+    end
+
+    def self.produce_side_effects_of_net_http_request(request, body)
+      request.set_body_internal(body)
+      request.content_length = request.body.length unless request.body.nil?
+    end
+
+    def self.io_from_fake_response_object(obj)
+      case obj
+      when Socket, OpenSSL::SSL::SSLSocket, StringIO, IO
+        obj  # usable as-is
+      when String
+        if !obj.include?("\0") && File.exist?(obj) && !File.directory?(obj)
+          File.open(obj, "r")
+        else
+          StringIO.new(obj)
+        end
+      else
+        raise ArgumentError, "Unable to create fake socket from #{obj}"
+      end
+    end
+
+    def self.puts_warning_for_net_http_around_advice_libs_if_needed
+      libs = {"Samuel" => defined?(Samuel)}
+      warnings = libs.select { |_, loaded| loaded }.map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: FakeWeb was loaded after #{name}\e[0m
+          * #{name}'s code is being ignored when a request is handled by FakeWeb,
+            because both libraries work by patching Net::HTTP.
+          * To fix this, just reorder your requires so that FakeWeb is before #{name}.
+        TEXT
+      end
+      $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+    end
+
+    def self.record_loaded_net_http_replacement_libs
+      libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+      @loaded_net_http_replacement_libs = libs.map { |name, loaded| name if loaded }.compact
+    end
+
+    def self.puts_warning_for_net_http_replacement_libs_if_needed
+      libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+      warnings = libs.select { |_, loaded| loaded }.
+                    reject { |name, _| @loaded_net_http_replacement_libs.include?(name) }.
+                    map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: #{name} was loaded after FakeWeb\e[0m
+          * FakeWeb's code is being ignored, because #{name} replaces parts of
+            Net::HTTP without deferring to other libraries. This will break Net::HTTP requests.
+          * To fix this, just reorder your requires so that #{name} is before FakeWeb.
+        TEXT
+      end
+      $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+    end
+
+  end
+end

data/lib/fakeweb.rb

@@ -0,0 +1,2 @@
+# So you can require "fakeweb" instead of "fake_web"
+require "fake_web"

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: fakeweb-fi
+version: !ruby/object:Gem::Version
+  version: 1.3.1
+platform: ruby
+authors:
+- Chris Kampmeier
+- Blaine Cook
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: ZenTest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.9'
+- !ruby/object:Gem::Dependency
+  name: sdoc
+  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: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: FakeWeb is a helper for faking web requests in Ruby. It works at a global
+  level, without modifying code or writing extensive stubs.
+email:
+- chris@kampers.net
+- romeda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG
+- LICENSE.txt
+- README.rdoc
+files:
+- CHANGELOG
+- LICENSE.txt
+- README.rdoc
+- lib/fake_web.rb
+- lib/fake_web/ext/net_http.rb
+- lib/fake_web/registry.rb
+- lib/fake_web/responder.rb
+- lib/fake_web/response.rb
+- lib/fake_web/stub_socket.rb
+- lib/fake_web/utility.rb
+- lib/fakeweb.rb
+homepage: https://github.com/chrisk/fakeweb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--show-hash --charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fakeweb
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A tool for faking responses to HTTP requests
+test_files: []