fakeweb 1.2.3 → 1.2.4

data/test/test_fake_web_open_uri.rb

@@ -7,17 +7,17 @@ class TestFakeWebOpenURI < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uri
-    FakeWeb.register_uri('http://mock/test_example.txt', :file => File.dirname(__FILE__) + '/fixtures/test_example.txt')
-    assert_equal 'test example content', FakeWeb.response_for('http://mock/test_example.txt').body
+    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
   end
   
   def test_mock_open
-    FakeWeb.register_uri('http://mock/test_example.txt', :file => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     assert_equal 'test example content', open('http://mock/test_example.txt').read
   end
   
   def test_mock_open_with_string_as_registered_uri
-    FakeWeb.register_uri('http://mock/test_string.txt', :string => 'foo')
+    FakeWeb.register_uri(:get, 'http://mock/test_string.txt', :body => 'foo')
     assert_equal 'foo', open('http://mock/test_string.txt').string
   end
   
@@ -31,21 +31,21 @@ class TestFakeWebOpenURI < Test::Unit::TestCase
   end
   
   def test_mock_open_that_raises_exception
-    FakeWeb.register_uri('http://mock/raising_exception.txt', :exception => StandardError)
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => StandardError)
     assert_raises(StandardError) do
       open('http://mock/raising_exception.txt')
     end
   end
 
   def test_mock_open_that_raises_an_http_error
-    FakeWeb.register_uri('http://mock/raising_exception.txt', :exception => OpenURI::HTTPError)
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => OpenURI::HTTPError)
     assert_raises(OpenURI::HTTPError) do
       open('http://mock/raising_exception.txt')
     end
   end
 
   def test_mock_open_that_raises_an_http_error_with_a_specific_status
-    FakeWeb.register_uri('http://mock/raising_exception.txt', :exception => OpenURI::HTTPError, :status => ['123', 'jodel'])
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => OpenURI::HTTPError, :status => ['123', 'jodel'])
     exception = assert_raises(OpenURI::HTTPError) do
       open('http://mock/raising_exception.txt')
     end
@@ -54,7 +54,7 @@ class TestFakeWebOpenURI < Test::Unit::TestCase
   end
 
   def test_mock_open_with_block
-    FakeWeb.register_uri('http://mock/test_example.txt', :file => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     open('http://mock/test_example.txt') do |f|
       assert 'test example content', f.readlines
     end

data/test/test_helper.rb

@@ -8,6 +8,14 @@ require 'mocha'
 
 module FakeWebTestHelper
 
+  def capture_stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.rewind && $stderr.read
+  ensure
+    $stderr = STDERR
+  end
+
   # Sets several expectations (using Mocha) that a real HTTP request makes it
   # past FakeWeb to the socket layer. You can use this when you need to check
   # that a request isn't handled by FakeWeb.

data/test/test_query_string.rb

@@ -7,35 +7,35 @@ class TestFakeWebQueryString < Test::Unit::TestCase
   end
 
   def test_register_uri_string_with_query_params
-    FakeWeb.register_uri('http://example.com/?a=1&b=1', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com/?a=1&b=1')
+    FakeWeb.register_uri(:get, 'http://example.com/?a=1&b=1', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/?a=1&b=1')
 
-    FakeWeb.register_uri(URI.parse("http://example.org/?a=1&b=1"), :string => "foo")
-    assert FakeWeb.registered_uri?("http://example.org/?a=1&b=1")
+    FakeWeb.register_uri(:post, URI.parse("http://example.org/?a=1&b=1"), :body => "foo")
+    assert FakeWeb.registered_uri?(:post, "http://example.org/?a=1&b=1")
   end
 
   def test_register_uri_with_query_params_and_check_in_different_order
-    FakeWeb.register_uri('http://example.com/?a=1&b=1', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com/?b=1&a=1')
+    FakeWeb.register_uri(:get, 'http://example.com/?a=1&b=1', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/?b=1&a=1')
 
-    FakeWeb.register_uri(URI.parse('http://example.org/?a=1&b=1'), :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.org/?b=1&a=1')
+    FakeWeb.register_uri(:post, URI.parse('http://example.org/?a=1&b=1'), :body => 'foo')
+    assert FakeWeb.registered_uri?(:post, 'http://example.org/?b=1&a=1')
   end
 
   def test_registered_uri_gets_recognized_with_empty_query_params
-    FakeWeb.register_uri('http://example.com/', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com/?')
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/?')
 
-    FakeWeb.register_uri(URI.parse('http://example.org/'), :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.org/?')
+    FakeWeb.register_uri(:post, URI.parse('http://example.org/'), :body => 'foo')
+    assert FakeWeb.registered_uri?(:post, 'http://example.org/?')
   end
 
   def test_register_uri_with_empty_query_params_and_check_with_none
-    FakeWeb.register_uri('http://example.com/?', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com/')
+    FakeWeb.register_uri(:get, 'http://example.com/?', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/')
 
-    FakeWeb.register_uri(URI.parse('http://example.org/?'), :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.org/')
+    FakeWeb.register_uri(:post, URI.parse('http://example.org/?'), :body => 'foo')
+    assert FakeWeb.registered_uri?(:post, 'http://example.org/')
   end
 
   def test_registry_sort_query_params

data/test/test_regexes.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestRegexes < Test::Unit::TestCase
+
+  def setup
+    FakeWeb.clean_registry
+    @original_allow_net_connect = FakeWeb.allow_net_connect?
+  end
+
+  def teardown
+    FakeWeb.allow_net_connect = @old_allow_net_conncet
+  end
+
+  def test_registered_uri_with_pattern
+    FakeWeb.register_uri(:get, %r|http://example.com/test_example/\d+|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/test_example/25")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/test_example/abc")
+  end
+
+  def test_response_for_with_matching_registered_uri
+    FakeWeb.register_uri(:get, %r|http://www.google.com|, :body => "Welcome to Google!")
+    assert_equal "Welcome to Google!", FakeWeb.response_for(:get, "http://www.google.com").body
+  end
+
+  def test_registered_uri_with_authentication_and_pattern
+    FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
+    assert FakeWeb.registered_uri?(:get, 'http://user:pass@mock/example.txt')
+  end
+
+  def test_registered_uri_with_authentication_and_pattern_handles_case_insensitivity
+    FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
+    assert FakeWeb.registered_uri?(:get, 'http://uSeR:PAss@mock/example.txt')
+  end
+
+  def test_request_with_authentication_and_pattern_handles_case_insensitivity
+    FakeWeb.register_uri(:get, %r|http://user:pass@mock/example\.\w+|i, :body => "example")
+    http = Net::HTTP.new('mock', 80)
+    req = Net::HTTP::Get.new('/example.txt')
+    req.basic_auth 'uSeR', 'PAss'
+    assert_equal "example", http.request(req).body
+  end
+
+  def test_registering_with_overlapping_regexes_uses_first_registered
+    FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "first")
+    FakeWeb.register_uri(:get, %r|http://example\.com/a|, :body => "second")
+    response = Net::HTTP.start("example.com") { |query| query.get('/a') }
+    assert_equal "first", response.body
+  end
+
+  def test_registry_does_not_find_using_mismatched_protocols_or_ports_when_registered_with_both
+    FakeWeb.register_uri(:get, %r|http://www.example.com:80|, :body => "example")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:80")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443")
+  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")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.com:443/test")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:443/test")
+    FakeWeb.register_uri(:get, %r|https://www.example.org/test|, :body => "example")
+    assert FakeWeb.registered_uri?(:get, "https://www.example.org:443/test")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.org:80/test")
+    assert !FakeWeb.registered_uri?(:get, "http://www.example.org:80/test")
+  end
+
+  def test_registry_matches_using_mismatched_port_when_registered_without
+    FakeWeb.register_uri(:get, %r|http://www.example.com|, :body => "example")
+    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, "http://www.example.com:12345")
+    assert !FakeWeb.registered_uri?(:get, "https://www.example.com:443")
+    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")
+  end
+
+  def test_registry_matches_with_query_params
+    FakeWeb.register_uri(:get, %r[example.com/list\?(.*&|)important=1], :body => "example")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?hash=123&important=1&unimportant=2")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?hash=123&important=12&unimportant=2")
+    assert FakeWeb.registered_uri?(:get, "http://example.com/list?important=1&unimportant=2")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/list?important=2")
+    assert !FakeWeb.registered_uri?(:get, "http://example.com/list?important=2&unimportant=1")
+    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
+end

data/test/test_response_headers.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestResponseHeaders < Test::Unit::TestCase
+
+  def setup
+    FakeWeb.clean_registry
+  end
+
+  def test_content_type_when_registering_with_string_and_content_type_header
+    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_only
+    FakeWeb.register_uri(:get, "http://example.com/users.json", :body => '[{"username": "chrisk"}]')
+    response = Net::HTTP.start("example.com") { |query| query.get("/users.json") }
+    assert_equal '[{"username": "chrisk"}]', response.body
+    assert_nil response['Content-Type']
+  end
+
+  def test_cookies_when_registering_with_file_and_set_cookie_header
+    FakeWeb.register_uri(:get, "http://example.com/", :body => File.dirname(__FILE__) + '/fixtures/test_example.txt',
+                                                      :set_cookie => "user_id=1; example=yes")
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "test example content", response.body
+    assert_equal "user_id=1; example=yes", response['Set-Cookie']
+  end
+
+  def test_registering_with_baked_response_ignores_header_options
+    fake_response = Net::HTTPOK.new('1.1', '200', 'OK')
+    fake_response["Server"] = "Apache/1.3.27 (Unix)"
+    FakeWeb.register_uri(:get, "http://example.com/", :response => fake_response,
+                                                      :server => "FakeWeb/1.2.3 (Ruby)")
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "200", response.code
+    assert_equal "OK", response.message
+    assert_equal "Apache/1.3.27 (Unix)", response["Server"]
+  end
+
+  def test_headers_are_rotated_when_registering_with_response_rotation
+    FakeWeb.register_uri(:get, "http://example.com",
+                               [{:body => 'test1', :expires => "Thu, 14 Jun 2009 16:00:00 GMT",
+                                                   :content_type => "text/plain"},
+                                {:body => 'test2', :expires => "Thu, 14 Jun 2009 16:00:01 GMT"}])
+
+    Net::HTTP.start("example.com") do |query|
+      response = query.get("/")
+      assert_equal 'test1', response.body
+      assert_equal "Thu, 14 Jun 2009 16:00:00 GMT", response['Expires']
+      assert_equal "text/plain", response['Content-Type']
+
+      response = query.get("/")
+      assert_equal 'test2', response.body
+      assert_equal "Thu, 14 Jun 2009 16:00:01 GMT", response['Expires']
+      assert_nil response['Content-Type']
+    end
+  end
+
+  def test_registering_with_status_option_and_response_headers
+    FakeWeb.register_uri(:get, "http://example.com", :status => ["301", "Moved Permanently"],
+                                                     :location => "http://www.example.com")
+
+    response = Net::HTTP.start("example.com") { |query| query.get("/") }
+    assert_equal "301", response.code
+    assert_equal "Moved Permanently", response.message
+    assert_equal "http://www.example.com", response["Location"]
+  end
+
+end

data/test/test_trailing_slashes.rb

@@ -12,48 +12,48 @@ class TestFakeWebTrailingSlashes < Test::Unit::TestCase
   end
 
   def test_registering_root_without_slash_and_ask_predicate_method_with_slash
-    FakeWeb.register_uri(:get, "http://www.example.com", :string => "root")
+    FakeWeb.register_uri(:get, "http://www.example.com", :body => "root")
     assert FakeWeb.registered_uri?(:get, "http://www.example.com/")
   end
 
   def test_registering_root_without_slash_and_request
-    FakeWeb.register_uri(:get, "http://www.example.com", :string => "root")
+    FakeWeb.register_uri(:get, "http://www.example.com", :body => "root")
     response = Net::HTTP.start("www.example.com") { |query| query.get('/') }
     assert_equal "root", response.body
   end
 
   def test_registering_root_with_slash_and_ask_predicate_method_without_slash
-    FakeWeb.register_uri(:get, "http://www.example.com/", :string => "root")
+    FakeWeb.register_uri(:get, "http://www.example.com/", :body => "root")
     assert FakeWeb.registered_uri?(:get, "http://www.example.com")
   end
 
   def test_registering_root_with_slash_and_request
-    FakeWeb.register_uri(:get, "http://www.example.com/", :string => "root")
+    FakeWeb.register_uri(:get, "http://www.example.com/", :body => "root")
     response = Net::HTTP.start("www.example.com") { |query| query.get('/') }
     assert_equal "root", response.body
   end
 
   def test_registering_path_without_slash_and_ask_predicate_method_with_slash
-    FakeWeb.register_uri(:get, "http://www.example.com/users", :string => "User list")
+    FakeWeb.register_uri(:get, "http://www.example.com/users", :body => "User list")
     assert !FakeWeb.registered_uri?(:get, "http://www.example.com/users/")
   end
 
   def test_registering_path_without_slash_and_request_with_slash
     FakeWeb.allow_net_connect = false
-    FakeWeb.register_uri(:get, "http://www.example.com/users", :string => "User list")
+    FakeWeb.register_uri(:get, "http://www.example.com/users", :body => "User list")
     assert_raise FakeWeb::NetConnectNotAllowedError do
       response = Net::HTTP.start("www.example.com") { |query| query.get('/users/') }
     end
   end
 
   def test_registering_path_with_slash_and_ask_predicate_method_without_slash
-    FakeWeb.register_uri(:get, "http://www.example.com/users/", :string => "User list")
+    FakeWeb.register_uri(:get, "http://www.example.com/users/", :body => "User list")
     assert !FakeWeb.registered_uri?(:get, "http://www.example.com/users")
   end
 
   def test_registering_path_with_slash_and_request_without_slash
     FakeWeb.allow_net_connect = false
-    FakeWeb.register_uri(:get, "http://www.example.com/users/", :string => "User list")
+    FakeWeb.register_uri(:get, "http://www.example.com/users/", :body => "User list")
     assert_raise FakeWeb::NetConnectNotAllowedError do
       response = Net::HTTP.start("www.example.com") { |query| query.get('/users') }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fakeweb
 version: !ruby/object:Gem::Version 
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors: 
 - Chris Kampmeier
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-31 00:00:00 -07:00
+date: 2009-06-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,30 +40,36 @@ files:
 - LICENSE.txt
 - README.rdoc
 - Rakefile
+- lib
+- lib/fake_web
 - lib/fake_web.rb
+- lib/fake_web/ext
 - 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/fakeweb.rb
+- test
+- test/fixtures
 - 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_query_string.rb
+- test/test_regexes.rb
+- test/test_response_headers.rb
 - test/test_trailing_slashes.rb
 has_rdoc: true
 homepage: http://github.com/chrisk/fakeweb
-licenses: []
-
 post_install_message: 
 rdoc_options: 
 - --main
@@ -91,21 +97,25 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: fakeweb
-rubygems_version: 1.3.2
+rubygems_version: 1.3.0
 signing_key: 
-specification_version: 3
+specification_version: 2
 summary: A tool for faking responses to HTTP requests
 test_files: 
+- test/fixtures
 - 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_query_string.rb
+- test/test_regexes.rb
+- test/test_response_headers.rb
 - test/test_trailing_slashes.rb