fakeweb 1.2.5 → 1.2.6

data/.gitignore

@@ -0,0 +1,5 @@
+/doc
+/rdoc
+/coverage
+/pkg
+/.idea

data/CHANGELOG

@@ -1,3 +1,19 @@
+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

data/Rakefile

@@ -1,76 +1,70 @@
 puts "Using ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
 
 require 'rubygems'
-require 'rake/gempackagetask'
-require 'rake/testtask'
+require 'rake'
+
 begin
-  require 'rdoc/task'
+  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 "\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"
-  raise
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-task :default => :test
 
-desc "Run All Tests"
-Rake::TestTask.new :test do |test|
-  test.test_files = ["test/**/*.rb"]
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
   test.verbose = false
+  test.warning = true
 end
 
-desc "Generate Documentation"
-RDoc::Task.new do |rdoc|
-  rdoc.main = "README.rdoc"
-  rdoc.rdoc_dir = "doc"
-  rdoc.rdoc_files.include("README.rdoc", "CHANGELOG", "LICENSE.txt", "lib/*.rb")
-  rdoc.title = "FakeWeb API Documentation"
-  rdoc.options << '--line-numbers' << '--charset' << 'utf-8'
-end
-
-desc %{Update ".manifest" with the latest list of project filenames. Respect\
-.gitignore by excluding everything that git ignores. Update `files` and\
-`test_files` arrays in "*.gemspec" file if it's present.}
-task :manifest do
-  list = Dir['**/*'].sort
-  spec_file = Dir['*.gemspec'].first
-  list -= [spec_file] if spec_file
-
-  File.read('.gitignore').each_line do |glob|
-    glob = glob.chomp.sub(/^\//, '')
-    list -= Dir[glob]
-    list -= Dir["#{glob}/**/*"] if File.directory?(glob) and !File.symlink?(glob)
-    puts "excluding #{glob}"
-  end
-
-  if spec_file
-    spec = File.read spec_file
-    spec.gsub!(/^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx) do
-      assignment = $1
-      bunch = $2 ? list.grep(/^test\//) : list
-      '%s%%w(%s)' % [assignment, bunch.join(' ')]
-    end
+task :default => :test
 
-    File.open(spec_file,   'w') {|f| f << spec }
-  end
-  File.open('.manifest', 'w') {|f| f << list.join("\n") }
-end
 
-if RUBY_PLATFORM =~ /java/
-  puts "rcov support disabled (running under JRuby)."
-elsif RUBY_VERSION =~ /^1\.9/
-  puts "rcov support disabled (running under Ruby 1.9)"
-else
+begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |t|
-    t.test_files = FileList['test/**/test*.rb'] 
+    t.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
     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
 
-spec = eval(File.read(File.join(File.dirname(__FILE__), "fakeweb.gemspec")))
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar_gz = true
-  pkg.need_zip    = true
+
+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/VERSION

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

data/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/lib/fake_web.rb

@@ -9,6 +9,9 @@ require 'fake_web/utility'
 
 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
@@ -47,9 +50,10 @@ module FakeWeb
   class NetConnectNotAllowedError < StandardError; end;
 
   # This exception is raised if a Net::HTTP request matches more than one of
-  # the regular expression-based stubs you've registered. To fix the problem,
-  # disambiguate the regular expressions by making them more specific.
-  class MultipleMatchingRegexpsError < StandardError; end;
+  # 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)

data/lib/fake_web/registry.rb

@@ -19,7 +19,6 @@ module FakeWeb
     end
 
     def registered_uri?(method, uri)
-      normalized_uri = normalize_uri(uri)
       !responses_for(method, uri).empty?
     end
 
@@ -45,39 +44,64 @@ module FakeWeb
     def responses_for(method, uri)
       uri = normalize_uri(uri)
 
-      if uri_map[uri].has_key?(method)
-        uri_map[uri][method]
-      elsif uri_map[uri].has_key?(:any)
-        uri_map[uri][:any]
-      elsif uri_map_matches?(method, uri)
-        uri_map_matches(method, uri)
-      elsif uri_map_matches(:any, uri)
-        uri_map_matches(:any, uri)
-      else
-        []
-      end
+      uri_map_matches(method, uri, URI) ||
+      uri_map_matches(:any,   uri, URI) ||
+      uri_map_matches(method, uri, Regexp) ||
+      uri_map_matches(:any,   uri, Regexp) ||
+      []
     end
 
-    def uri_map_matches?(method, uri)
-      !uri_map_matches(method, uri).nil?
-    end
-
-    def uri_map_matches(method, uri)
-      uri = normalize_uri(uri.to_s).to_s
-      uri = Utility.strip_default_port_from_uri(uri)
+    def uri_map_matches(method, uri, type_to_check = URI)
+      uris_to_check = variations_of_uri_as_strings(uri)
 
       matches = uri_map.select { |registered_uri, method_hash|
-        registered_uri.is_a?(Regexp) && uri.match(registered_uri) && method_hash.has_key?(method)
+        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 MultipleMatchingRegexpsError,
-          "More than one regular expression matched this request: #{method.to_s.upcase} #{uri}"
+        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)
+      uris = []
+      normalized_uri = normalize_uri(uri_object)
+
+      # all orderings of query parameters
+      query = normalized_uri.query
+      if query.nil? || query.empty?
+        uris << normalized_uri
+      else
+        FakeWeb::Utility.simple_array_permutation(query.split('&')) do |p|
+          current_permutation = normalized_uri.dup
+          current_permutation.query = p.join('&')
+          uris << current_permutation
+        end
+      end
+
+      uri_strings = uris.map { |uri| uri.to_s }
+
+      # including and omitting the default port
+      if normalized_uri.default_port == normalized_uri.port
+        uri_strings += uris.map { |uri|
+          uri.to_s.sub(/#{Regexp.escape(normalized_uri.request_uri)}$/,
+                       ":#{normalized_uri.port}#{normalized_uri.request_uri}")
+        }
+      end
+
+      uri_strings
+    end
+
     def normalize_uri(uri)
       return uri if uri.is_a?(Regexp)
       normalized_uri =

data/lib/fake_web/utility.rb

@@ -18,5 +18,27 @@ module FakeWeb
       end
     end
 
+    # Array#permutation wrapper for 1.8.6-compatibility. It only supports the
+    # simple case that returns all permutations (so it doesn't take a numeric
+    # argument).
+    def self.simple_array_permutation(array, &block)
+      # use native implementation if it exists
+      return array.permutation(&block) if array.respond_to?(:permutation)
+
+      yield array if array.length <= 1
+
+      array.length.times do |i|
+        rest = array.dup
+        picked = rest.delete_at(i)
+        next if rest.empty?
+
+        simple_array_permutation(rest) do |part_of_rest|
+          yield [picked] + part_of_rest
+        end
+      end
+
+      array
+    end
+
   end
 end

data/test/test_deprecations.rb

@@ -6,49 +6,49 @@ class TestDeprecations < Test::Unit::TestCase
     warning = capture_stderr do
       FakeWeb.register_uri("http://example.com", :body => "test")
     end
-    assert_match /deprecation warning: fakeweb/i, warning
+    assert_match %r(deprecation warning: fakeweb)i, warning
   end
 
   def test_registered_uri_without_method_argument_prints_deprecation_warning
     warning = capture_stderr do
       FakeWeb.registered_uri?("http://example.com")
     end
-    assert_match /deprecation warning: fakeweb/i, warning
+    assert_match %r(deprecation warning: fakeweb)i, warning
   end
 
   def test_response_for_without_method_argument_prints_deprecation_warning
     warning = capture_stderr do
       FakeWeb.response_for("http://example.com")
     end
-    assert_match /deprecation warning: fakeweb/i, warning
+    assert_match %r(deprecation warning: fakeweb)i, warning
   end
 
   def test_register_uri_without_method_argument_prints_deprecation_warning_with_correct_caller
     warning = capture_stderr do
       FakeWeb.register_uri("http://example.com", :body => "test")
     end
-    assert_match /Called at.*?test_deprecations\.rb/i, warning
+    assert_match %r(Called at.*?test_deprecations\.rb)i, warning
   end
 
   def test_register_uri_with_string_option_prints_deprecation_warning
     warning = capture_stderr do
       FakeWeb.register_uri(:get, "http://example.com", :string => "test")
     end
-    assert_match /deprecation warning: fakeweb's :string option/i, warning
+    assert_match %r(deprecation warning: fakeweb's :string option)i, warning
   end
 
   def test_register_uri_with_file_option_prints_deprecation_warning
     warning = capture_stderr do
       FakeWeb.register_uri(:get, "http://example.com", :file => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     end
-    assert_match /deprecation warning: fakeweb's :file option/i, warning
+    assert_match %r(deprecation warning: fakeweb's :file option)i, warning
   end
 
   def test_register_uri_with_string_option_prints_deprecation_warning_with_correct_caller
     warning = capture_stderr do
       FakeWeb.register_uri(:get, "http://example.com", :string => "test")
     end
-    assert_match /Called at.*?test_deprecations\.rb/i, warning
+    assert_match %r(Called at.*?test_deprecations\.rb)i, warning
   end
 
 end

data/test/test_fake_web.rb

@@ -104,6 +104,23 @@ class TestFakeWeb < Test::Unit::TestCase
     end
   end
 
+  def test_clean_registry_affects_registered_uri
+    FakeWeb.register_uri(:get, "http://example.com", :body => "registered")
+    assert FakeWeb.registered_uri?(:get, "http://example.com")
+    FakeWeb.clean_registry
+    assert !FakeWeb.registered_uri?(:get, "http://example.com")
+  end
+
+  def test_clean_registry_affects_net_http_requests
+    FakeWeb.register_uri(:get, "http://example.com", :body => "registered")
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "registered", response.body
+    FakeWeb.clean_registry
+    assert_raise FakeWeb::NetConnectNotAllowedError do
+      Net::HTTP.start("example.com") { |query| query.get("/") }
+    end
+  end
+
   def test_response_for_with_registered_uri
     FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     assert_equal 'test example content', FakeWeb.response_for(:get, 'http://mock/test_example.txt').body
@@ -515,4 +532,8 @@ class TestFakeWeb < Test::Unit::TestCase
     assert_equal "1.0", response.http_version
   end
 
+  def test_version
+    assert_equal "1.2.6", FakeWeb::VERSION
+  end
+
 end

data/test/test_helper.rb

@@ -9,12 +9,14 @@ require 'mocha'
 
 # Give all tests a common setup and teardown that prevents shared state
 class Test::Unit::TestCase
+  alias setup_without_fakeweb setup
   def setup
     FakeWeb.clean_registry
     @original_allow_net_connect = FakeWeb.allow_net_connect?
     FakeWeb.allow_net_connect = false
   end
 
+  alias teardown_without_fakeweb teardown
   def teardown
     FakeWeb.allow_net_connect = @original_allow_net_connect
   end

data/test/test_precedence.rb

@@ -48,4 +48,32 @@ class TestPrecedence < Test::Unit::TestCase
     assert_equal "string", response.body
   end
 
+  def test_identical_registration_replaces_previous_registration
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "first")
+    FakeWeb.register_uri(:get, "http://example.com/test", :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "second", response.body
+  end
+
+  def test_identical_registration_replaces_previous_registration_accounting_for_normalization
+    FakeWeb.register_uri(:get, "http://example.com/test?", :body => "first")
+    FakeWeb.register_uri(:get, "http://example.com:80/test", :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "second", response.body
+  end
+
+  def test_identical_registration_replaces_previous_registration_accounting_for_query_params
+    FakeWeb.register_uri(:get, "http://example.com/test?a=1&b=2", :body => "first")
+    FakeWeb.register_uri(:get, "http://example.com/test?b=2&a=1", :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test?a=1&b=2') }
+    assert_equal "second", response.body
+  end
+
+  def test_identical_registration_replaces_previous_registration_with_regexes
+    FakeWeb.register_uri(:get, /test/, :body => "first")
+    FakeWeb.register_uri(:get, /test/, :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/test') }
+    assert_equal "second", response.body
+  end
+
 end

data/test/test_regexes.rb

@@ -39,17 +39,28 @@ class TestRegexes < Test::Unit::TestCase
   def test_requesting_a_uri_that_matches_two_registered_regexes_raises_an_error
     FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
     FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
-    assert_raise FakeWeb::MultipleMatchingRegexpsError do
+    assert_raise FakeWeb::MultipleMatchingURIsError do
       Net::HTTP.start("example.com") { |query| query.get('/a') }
     end
   end
 
+  def test_requesting_a_uri_that_matches_two_registered_regexes_with_differently_ordered_query_params_raises_an_error
+    FakeWeb.register_uri(:get, %r[example.com/list\?b=2&a=1], :body => "first")
+    FakeWeb.register_uri(:get, %r[example.com/list\?a=1&b=2], :body => "second")
+    assert_raise FakeWeb::MultipleMatchingURIsError do
+      Net::HTTP.start("example.com") { |query| query.get('/list?a=1&b=2') }
+    end
+    assert_raise FakeWeb::MultipleMatchingURIsError do
+      Net::HTTP.start("example.com") { |query| query.get('/list?b=2&a=1') }
+    end
+  end
+
   def test_requesting_a_uri_that_matches_two_registered_regexes_raises_an_error_including_request_info
     FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
     FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
     begin
       Net::HTTP.start("example.com") { |query| query.get('/a') }
-    rescue FakeWeb::MultipleMatchingRegexpsError => exception
+    rescue FakeWeb::MultipleMatchingURIsError => exception
     end
     assert exception.message.include?("GET http://example.com/a")
   end
@@ -60,6 +71,36 @@ class TestRegexes < Test::Unit::TestCase
     assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443")
   end
 
+  def test_registry_finds_using_non_default_port
+    FakeWeb.register_uri(:get, %r|example\.com:8080|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:8080/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:8080/path")
+  end
+
+  def test_registry_finds_using_default_port_and_http_when_registered_with_explicit_port_80
+    FakeWeb.register_uri(:get, %r|example\.com:80|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com/path")
+
+    # check other permutations, too
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80/path")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:8080/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:80/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:8080/path")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com/path")
+  end
+
+  def test_registry_finds_using_default_port_and_https_when_registered_with_explicit_port_443
+    FakeWeb.register_uri(:get, %r|example\.com:443|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com/path")
+
+    # check other permutations, too
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:443/path")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:44321/path")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:443/path")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:44321/path")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com/path")
+  end
+
   def test_registry_only_finds_using_default_port_when_registered_without_if_protocol_matches
     FakeWeb.register_uri(:get, %r|http://www.example.com/test|, :body => "example")
     assert FakeWeb.registered_uri?(:get, "http://www.example.com:80/test")
@@ -80,14 +121,14 @@ class TestRegexes < Test::Unit::TestCase
     assert !FakeWeb.registered_uri?(:get, "https://www.example.com")
   end
 
-  def test_registry_matches_using_any_protocol_and_port_when_registered_without_protocol_or_port
-    FakeWeb.register_uri(:get, %r|www.example.com|, :body => "example")
-    assert FakeWeb.registered_uri?(:get, "http://www.example.com")
-    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80")
-    assert FakeWeb.registered_uri?(:get, "http://www.example.com:443")
-    assert FakeWeb.registered_uri?(:get, "https://www.example.com")
-    assert FakeWeb.registered_uri?(:get, "https://www.example.com:80")
-    assert FakeWeb.registered_uri?(:get, "https://www.example.com:443")
+  def test_registry_matches_using_default_port_for_protocol_when_registered_without_protocol_or_port
+    FakeWeb.register_uri(:get, %r|www.example.com/home|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com/home")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com/home")
+    assert FakeWeb.registered_uri?(:get, "http://www.example.com:80/home")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.com:443/home")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:80/home")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443/home")
   end
 
   def test_registry_matches_with_query_params
@@ -100,4 +141,12 @@ class TestRegexes < Test::Unit::TestCase
     assert !FakeWeb.registered_uri?(:get, "http://example.com/list?hash=123&important=2&unimportant=1")
     assert !FakeWeb.registered_uri?(:get, "http://example.com/list?notimportant=1&unimportant=1")
   end
+
+  def test_registry_matches_with_unsorted_query_params
+    FakeWeb.register_uri(:get, %r[example\.com/list\?b=2&a=1], :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?b=2&a=1")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?a=1&b=2")
+    assert FakeWeb.registered_uri?(:get, "https://example.com:443/list?b=2&a=1")
+  end
+
 end

data/test/test_response_headers.rb

@@ -2,13 +2,19 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestResponseHeaders < Test::Unit::TestCase
 
-  def test_content_type_when_registering_with_string_and_content_type_header
+  def test_content_type_when_registering_with_string_and_content_type_header_as_symbol_option
     FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]', :content_type => "application/json")
     response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
     assert_equal '[{"username": "chrisk"}]', response.body
     assert_equal "application/json", response['Content-Type']
   end
 
+  def test_content_type_when_registering_with_string_and_content_type_header_as_string_option
+    FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]', 'Content-Type' => "application/json")
+    response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
+    assert_equal "application/json", response['Content-Type']
+  end
+
   def test_content_type_when_registering_with_string_only
     FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]')
     response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }

data/test/test_utility.rb

@@ -67,4 +67,25 @@ class TestUtility < Test::Unit::TestCase
     assert_equal uri, FakeWeb::Utility.strip_default_port_from_uri(uri)
   end
 
+  def test_simple_array_permutation_with_one_element
+    array, permutations = [1], [[1]]
+    FakeWeb::Utility.simple_array_permutation(array) do |permutation|
+      permutations.delete(permutation)
+    end
+    assert permutations.empty?
+  end
+
+  def test_simple_array_permutation_with_three_elements
+    array = [1, 2, 3]
+    permutations = [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
+    FakeWeb::Utility.simple_array_permutation(array) do |permutation|
+      permutations.delete(permutation)
+    end
+    assert permutations.empty?
+  end
+
+  def test_simple_array_permutation_return_value
+    array = [1, 2, 3]
+    assert array, FakeWeb::Utility.simple_array_permutation(array) { }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fakeweb
 version: !ruby/object:Gem::Version 
-  version: 1.2.5
+  version: 1.2.6
 platform: ruby
 authors: 
 - Chris Kampmeier
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-08 00:00:00 -07:00
+date: 2009-08-31 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,14 +32,16 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- CHANGELOG
 - LICENSE.txt
 - README.rdoc
 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
@@ -72,14 +74,7 @@ licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --main
-- README.rdoc
-- --title
-- FakeWeb API Documentation
-- --charset
-- utf-8
-- --line-numbers
-- --inline-source
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -97,16 +92,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: fakeweb
-rubygems_version: 1.3.4
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: A tool for faking responses to HTTP requests
 test_files: 
-- 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