monkeywrench 0.1.5 → 0.1.6

data/test/lib/fakeweb/README.rdoc

@@ -0,0 +1,193 @@
+= 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
+
+The latest release of FakeWeb is once again available from your friendly
+RubyForge mirror. Just install the gem:
+
+  sudo gem install fakeweb
+
+Note: the gem was previously available as +FakeWeb+ (capital letters), but now
+all versions are simply registered as +fakeweb+. If you have any old +FakeWeb+
+gems lying around, remove them: <tt>sudo gem uninstall FakeWeb</tt>
+
+
+== 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
+http://groups.google.com/group/fakeweb-users.
+
+The main source repository is http://github.com/chrisk/fakeweb.
+
+== Examples
+
+Start by requiring FakeWeb:
+
+  require 'rubygems'
+  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.
+
+=== 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-like 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 FakeWeb.register_uri 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 stub requests that use basic authentication with +userinfo+ strings in
+the 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
+
+This is handy when you want to make sure your tests are self-contained, or you
+want to catch the scenario when a URI is changed in implementation code
+without a corresponding test change.
+
+=== 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.
+
+== 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 http://groups.google.com/group/fakeweb-users/browse_thread/thread/44d190a6b12e4273
+  for a discussion of some different options. Thanks!
+
+
+== Copyright
+
+Copyright 2006-2007 Blaine Cook
+
+Copyright 2008-2009 various contributors
+
+  FakeWeb is free software; you can redistribute it and/or modify it under the
+  terms of the GNU General Public License as published by the Free Software
+  Foundation; either version 2 of the License, or (at your option) any later
+  version.
+
+  FakeWeb is distributed in the hope that it will be useful, but WITHOUT ANY
+  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+  details.
+
+  You should have received a copy of the GNU General Public License along
+  with FakeWeb; if not, write to the Free Software Foundation, Inc., 51
+  Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+See <tt>LICENSE.txt</tt> for the full terms.

data/test/lib/fakeweb/Rakefile

@@ -0,0 +1,70 @@
+# puts "Using ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+
+require 'rubygems'
+require 'rake'
+
+# begin
+#   require 'jeweler'
+#   Jeweler::Tasks.new do |gem|
+#     gem.name = "fakeweb"
+#     gem.rubyforge_project = "fakeweb"
+#     gem.summary = "A tool for faking responses to HTTP requests"
+#     gem.description = "FakeWeb is a helper for faking web requests in Ruby. It works at a global level, without modifying code or writing extensive stubs."
+#     gem.email = ["chris@kampers.net", "romeda@gmail.com"]
+#     gem.authors = ["Chris Kampmeier", "Blaine Cook"]
+#     gem.homepage = "http://github.com/chrisk/fakeweb"
+#     gem.add_development_dependency "mocha", ">= 0.9.5"
+#   end
+#   Jeweler::GemcutterTasks.new
+#   Jeweler::RubyforgeTasks.new do |rubyforge|
+#     rubyforge.doc_task = "rdoc"
+#     rubyforge.remote_doc_path = ""
+#   end
+# rescue LoadError
+#   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+# end
+
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb", "test/vendor")
+  test.verbose = false
+  test.warning = true
+end
+
+task :default => :test
+
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb", "test/vendor")
+    t.rcov_opts << "--sort coverage"
+    t.rcov_opts << "--exclude gems"
+    t.warning = true
+  end
+rescue
+  print "rcov support disabled "
+  if RUBY_PLATFORM =~ /java/
+    puts "(running under JRuby)"
+  elsif RUBY_VERSION =~ /^1\.9/
+    puts "(running under Ruby 1.9)"
+  else
+    puts "(install RCov to enable the `rcov` task)"
+  end
+end
+
+
+begin
+  require 'rdoc/task'
+  Rake::RDocTask.new do |rdoc|
+    version = File.exist?('VERSION') ? File.read('VERSION') : ""
+    rdoc.main = "README.rdoc"
+    rdoc.rdoc_files.include("README.rdoc", "CHANGELOG", "LICENSE.txt", "lib/*.rb")
+    rdoc.title = "FakeWeb #{version} API Documentation"
+    rdoc.options << '--line-numbers' << '--charset' << 'utf-8'
+  end
+rescue LoadError
+  puts "\nIt looks like you're using an old version of RDoc, but FakeWeb requires a newer one."
+  puts "You can try upgrading with `sudo gem install rdoc`.\n\n"
+end

data/test/lib/fakeweb/VERSION

@@ -0,0 +1 @@
+1.2.6

data/test/lib/fakeweb/fakeweb.gemspec

@@ -0,0 +1,88 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fakeweb}
+  s.version = "1.2.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chris Kampmeier", "Blaine Cook"]
+  s.date = %q{2009-08-31}
+  s.description = %q{FakeWeb is a helper for faking web requests in Ruby. It works at a global level, without modifying code or writing extensive stubs.}
+  s.email = ["chris@kampers.net", "romeda@gmail.com"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG",
+     "LICENSE.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "fakeweb.gemspec",
+     "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",
+     "test/fixtures/google_response_from_curl",
+     "test/fixtures/google_response_with_transfer_encoding",
+     "test/fixtures/google_response_without_transfer_encoding",
+     "test/fixtures/test_example.txt",
+     "test/fixtures/test_txt_file",
+     "test/test_allow_net_connect.rb",
+     "test/test_deprecations.rb",
+     "test/test_fake_authentication.rb",
+     "test/test_fake_web.rb",
+     "test/test_fake_web_open_uri.rb",
+     "test/test_helper.rb",
+     "test/test_missing_open_uri.rb",
+     "test/test_precedence.rb",
+     "test/test_query_string.rb",
+     "test/test_regexes.rb",
+     "test/test_response_headers.rb",
+     "test/test_trailing_slashes.rb",
+     "test/test_utility.rb"
+  ]
+  s.homepage = %q{http://github.com/chrisk/fakeweb}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{fakeweb}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A tool for faking responses to HTTP requests}
+  s.test_files = [
+    "test/test_allow_net_connect.rb",
+     "test/test_deprecations.rb",
+     "test/test_fake_authentication.rb",
+     "test/test_fake_web.rb",
+     "test/test_fake_web_open_uri.rb",
+     "test/test_helper.rb",
+     "test/test_missing_open_uri.rb",
+     "test/test_precedence.rb",
+     "test/test_query_string.rb",
+     "test/test_regexes.rb",
+     "test/test_response_headers.rb",
+     "test/test_trailing_slashes.rb",
+     "test/test_utility.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<mocha>, [">= 0.9.5"])
+    else
+      s.add_dependency(%q<mocha>, [">= 0.9.5"])
+    end
+  else
+    s.add_dependency(%q<mocha>, [">= 0.9.5"])
+  end
+end

data/test/lib/fakeweb/lib/fake_web.rb

@@ -0,0 +1,179 @@
+require 'singleton'
+
+require "#{File.dirname(__FILE__)}/fake_web/ext/net_http"
+require "#{File.dirname(__FILE__)}/fake_web/registry"
+require "#{File.dirname(__FILE__)}/fake_web/response"
+require "#{File.dirname(__FILE__)}/fake_web/responder"
+require "#{File.dirname(__FILE__)}/fake_web/stub_socket"
+require "#{File.dirname(__FILE__)}/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 = File.read(File.join(File.dirname(__FILE__), "..", "VERSION")).strip
+
+  # 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.
+  def self.allow_net_connect=(allowed)
+    @allow_net_connect = allowed
+  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.
+  def self.allow_net_connect?
+    @allow_net_connect
+  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 an <tt>Net::HTTPResponse</tt>, an +IO+, or a +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://www.example.com/ > response_for_www.example.com
+  #
+  #   which can then be used in your test environment like so:
+  #
+  #     FakeWeb.register_uri(:get, 'http://www.example.com/', :response => 'response_for_www.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 provided response,
+  # you may optionally provide:
+  #
+  # <tt>:times</tt>::
+  #   The number of times this response will be used. Decremented by one each time it's called.
+  #   FakeWeb will use the final provided request indefinitely, regardless of its :times 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("http://www.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('http://www.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")
+  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 for 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
+
+  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