fakeweb 1.2.3 → 1.2.4

data/test/test_deprecations.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class TestDeprecations < Test::Unit::TestCase
+
+  def setup
+    FakeWeb.clean_registry
+  end
+
+  def test_register_uri_without_method_argument_prints_deprecation_warning
+    warning = capture_stderr do
+      FakeWeb.register_uri("http://example.com", :body => "test")
+    end
+    assert_match /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
+  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
+  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
+  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
+  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
+  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
+  end
+
+end

data/test/test_fake_authentication.rb

@@ -2,48 +2,48 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestFakeAuthentication < Test::Unit::TestCase
   def setup
-    FakeWeb.register_uri('http://user:pass@mock/auth.txt', :string => 'authorized')
-    FakeWeb.register_uri('http://user2:pass@mock/auth.txt', :string => 'wrong user')
-    FakeWeb.register_uri('http://mock/auth.txt', :string => 'unauthorized')
+    FakeWeb.register_uri(:get, 'http://user:pass@mock/auth.txt', :body => 'authorized')
+    FakeWeb.register_uri(:get, 'http://user2:pass@mock/auth.txt', :body => 'wrong user')
+    FakeWeb.register_uri(:get, 'http://mock/auth.txt', :body => 'unauthorized')
   end
 
   def test_register_uri_with_authentication
-    FakeWeb.register_uri('http://user:pass@mock/test_example.txt', :string => "example")
-    assert FakeWeb.registered_uri?('http://user:pass@mock/test_example.txt')
+    FakeWeb.register_uri(:get, 'http://user:pass@mock/test_example.txt', :body => "example")
+    assert FakeWeb.registered_uri?(:get, 'http://user:pass@mock/test_example.txt')
   end
 
   def test_register_uri_with_authentication_doesnt_trigger_without
-    FakeWeb.register_uri('http://user:pass@mock/test_example.txt', :string => "example")
-    assert !FakeWeb.registered_uri?('http://mock/test_example.txt')
+    FakeWeb.register_uri(:get, 'http://user:pass@mock/test_example.txt', :body => "example")
+    assert !FakeWeb.registered_uri?(:get, 'http://mock/test_example.txt')
   end
 
   def test_register_uri_with_authentication_doesnt_trigger_with_incorrect_credentials
-    FakeWeb.register_uri('http://user:pass@mock/test_example.txt', :string => "example")
-    assert !FakeWeb.registered_uri?('http://user:wrong@mock/test_example.txt')
+    FakeWeb.register_uri(:get, 'http://user:pass@mock/test_example.txt', :body => "example")
+    assert !FakeWeb.registered_uri?(:get, 'http://user:wrong@mock/test_example.txt')
   end
 
   def test_unauthenticated_request
     http = Net::HTTP.new('mock', 80)
     req = Net::HTTP::Get.new('/auth.txt')
-    assert_equal http.request(req).body, 'unauthorized'
+    assert_equal 'unauthorized', http.request(req).body
   end
 
   def test_authenticated_request
     http = Net::HTTP.new('mock',80)
     req = Net::HTTP::Get.new('/auth.txt')
     req.basic_auth 'user', 'pass'
-    assert_equal http.request(req).body, 'authorized'
+    assert_equal 'authorized', http.request(req).body
   end
 
   def test_incorrectly_authenticated_request
     http = Net::HTTP.new('mock',80)
     req = Net::HTTP::Get.new('/auth.txt')
     req.basic_auth 'user2', 'pass'
-    assert_equal http.request(req).body, 'wrong user'
+    assert_equal 'wrong user', http.request(req).body
   end
 
   def test_basic_auth_support_is_transparent_to_oauth
-    FakeWeb.register_uri(:get, "http://sp.example.com/protected", :string => "secret")
+    FakeWeb.register_uri(:get, "http://sp.example.com/protected", :body => "secret")
 
     # from http://oauth.net/core/1.0/#auth_header
     auth_header = <<-HEADER

data/test/test_fake_web.rb

@@ -8,8 +8,8 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_register_uri
-    FakeWeb.register_uri('http://mock/test_example.txt', :string => "example")
-    assert FakeWeb.registered_uri?('http://mock/test_example.txt')
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => "example")
+    assert FakeWeb.registered_uri?(:get, 'http://mock/test_example.txt')
   end
 
   def test_register_uri_with_wrong_number_of_arguments
@@ -17,7 +17,7 @@ class TestFakeWeb < Test::Unit::TestCase
       FakeWeb.register_uri("http://example.com")
     end
     assert_raises ArgumentError do
-      FakeWeb.register_uri(:get, "http://example.com", "/example", :string => "example")
+      FakeWeb.register_uri(:get, "http://example.com", "/example", :body => "example")
     end
   end
 
@@ -41,92 +41,96 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_register_uri_without_domain_name
     assert_raises URI::InvalidURIError do
-      FakeWeb.register_uri('test_example2.txt', File.dirname(__FILE__) + '/fixtures/test_example.txt')
+      FakeWeb.register_uri(:get, 'test_example2.txt', File.dirname(__FILE__) + '/fixtures/test_example.txt')
     end
   end
 
   def test_register_uri_with_port_and_check_with_port
-    FakeWeb.register_uri('http://example.com:3000/', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com:3000/')
+    FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com:3000/')
   end
 
   def test_register_uri_with_port_and_check_without_port
-    FakeWeb.register_uri('http://example.com:3000/', :string => 'foo')
-    assert !FakeWeb.registered_uri?('http://example.com/')
+    FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'foo')
+    assert !FakeWeb.registered_uri?(:get, 'http://example.com/')
   end
 
   def test_register_uri_with_default_port_for_http_and_check_without_port
-    FakeWeb.register_uri('http://example.com:80/', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com/')
+    FakeWeb.register_uri(:get, 'http://example.com:80/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com/')
   end
 
   def test_register_uri_with_default_port_for_https_and_check_without_port
-    FakeWeb.register_uri('https://example.com:443/', :string => 'foo')
-    assert FakeWeb.registered_uri?('https://example.com/')
+    FakeWeb.register_uri(:get, 'https://example.com:443/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'https://example.com/')
   end
 
   def test_register_uri_with_no_port_for_http_and_check_with_default_port
-    FakeWeb.register_uri('http://example.com/', :string => 'foo')
-    assert FakeWeb.registered_uri?('http://example.com:80/')
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'http://example.com:80/')
   end
 
   def test_register_uri_with_no_port_for_https_and_check_with_default_port
-    FakeWeb.register_uri('https://example.com/', :string => 'foo')
-    assert FakeWeb.registered_uri?('https://example.com:443/')
+    FakeWeb.register_uri(:get, 'https://example.com/', :body => 'foo')
+    assert FakeWeb.registered_uri?(:get, 'https://example.com:443/')
   end
 
   def test_register_uri_with_no_port_for_https_and_check_with_443_on_http
-    FakeWeb.register_uri('https://example.com/', :string => 'foo')
-    assert !FakeWeb.registered_uri?('http://example.com:443/')
+    FakeWeb.register_uri(:get, 'https://example.com/', :body => 'foo')
+    assert !FakeWeb.registered_uri?(:get, 'http://example.com:443/')
   end
 
   def test_register_uri_with_no_port_for_http_and_check_with_80_on_https
-    FakeWeb.register_uri('http://example.com/', :string => 'foo')
-    assert !FakeWeb.registered_uri?('https://example.com:80/')
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'foo')
+    assert !FakeWeb.registered_uri?(:get, 'https://example.com:80/')
   end
 
   def test_register_uri_for_any_method_explicitly
-    FakeWeb.register_uri(:any, "http://example.com/rpc_endpoint", :string => "OK")
+    FakeWeb.register_uri(:any, "http://example.com/rpc_endpoint", :body => "OK")
     assert FakeWeb.registered_uri?(:get, "http://example.com/rpc_endpoint")
     assert FakeWeb.registered_uri?(:post, "http://example.com/rpc_endpoint")
     assert FakeWeb.registered_uri?(:put, "http://example.com/rpc_endpoint")
     assert FakeWeb.registered_uri?(:delete, "http://example.com/rpc_endpoint")
     assert FakeWeb.registered_uri?(:any, "http://example.com/rpc_endpoint")
-    assert FakeWeb.registered_uri?("http://example.com/rpc_endpoint")
+    capture_stderr do  # silence deprecation warning
+      assert FakeWeb.registered_uri?("http://example.com/rpc_endpoint")
+    end
   end
 
   def test_register_uri_for_get_method_only
-    FakeWeb.register_uri(:get, "http://example.com/users", :string => "User list")
+    FakeWeb.register_uri(:get, "http://example.com/users", :body => "User list")
     assert FakeWeb.registered_uri?(:get, "http://example.com/users")
     assert !FakeWeb.registered_uri?(:post, "http://example.com/users")
     assert !FakeWeb.registered_uri?(:put, "http://example.com/users")
     assert !FakeWeb.registered_uri?(:delete, "http://example.com/users")
     assert !FakeWeb.registered_uri?(:any, "http://example.com/users")
-    assert !FakeWeb.registered_uri?("http://example.com/users")
+    capture_stderr do  # silence deprecation warning
+      assert !FakeWeb.registered_uri?("http://example.com/users")
+    end
   end
 
   def test_response_for_with_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_response_for_with_unknown_uri
-    assert_equal nil, FakeWeb.response_for(:get, 'http://example.com/')
+    assert_nil FakeWeb.response_for(:get, 'http://example.com/')
   end
 
   def test_response_for_with_put_method
-    FakeWeb.register_uri(:put, "http://example.com", :string => "response")
+    FakeWeb.register_uri(:put, "http://example.com", :body => "response")
     assert_equal 'response', FakeWeb.response_for(:put, "http://example.com").body
   end
 
   def test_response_for_with_any_method_explicitly
-    FakeWeb.register_uri(:any, "http://example.com", :string => "response")
+    FakeWeb.register_uri(:any, "http://example.com", :body => "response")
     assert_equal 'response', FakeWeb.response_for(:get, "http://example.com").body
     assert_equal 'response', FakeWeb.response_for(:any, "http://example.com").body
   end
 
   def test_content_for_registered_uri_with_port_and_request_with_port
-    FakeWeb.register_uri('http://example.com:3000/', :string => 'test example content')
+    FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'test example content')
     Net::HTTP.start('example.com', 3000) do |http|
       response = http.get('/')
       assert_equal 'test example content', response.body
@@ -134,7 +138,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uri_with_default_port_for_http_and_request_without_port
-    FakeWeb.register_uri('http://example.com:80/', :string => 'test example content')
+    FakeWeb.register_uri(:get, 'http://example.com:80/', :body => 'test example content')
     Net::HTTP.start('example.com') do |http|
       response = http.get('/')
       assert_equal 'test example content', response.body
@@ -142,7 +146,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uri_with_no_port_for_http_and_request_with_default_port
-    FakeWeb.register_uri('http://example.com/', :string => 'test example content')
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'test example content')
     Net::HTTP.start('example.com', 80) do |http|
       response = http.get('/')
       assert_equal 'test example content', response.body
@@ -150,7 +154,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uri_with_default_port_for_https_and_request_with_default_port
-    FakeWeb.register_uri('https://example.com:443/', :string => 'test example content')
+    FakeWeb.register_uri(:get, 'https://example.com:443/', :body => 'test example content')
     http = Net::HTTP.new('example.com', 443)
     http.use_ssl = true
     response = http.get('/')
@@ -158,7 +162,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uri_with_no_port_for_https_and_request_with_default_port
-    FakeWeb.register_uri('https://example.com/', :string => 'test example content')
+    FakeWeb.register_uri(:get, 'https://example.com/', :body => 'test example content')
     http = Net::HTTP.new('example.com', 443)
     http.use_ssl = true
     response = http.get('/')
@@ -166,8 +170,8 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uris_with_ports_on_same_domain_and_request_without_port
-    FakeWeb.register_uri('http://example.com:3000/', :string => 'port 3000')
-    FakeWeb.register_uri('http://example.com/', :string => 'port 80')
+    FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'port 3000')
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'port 80')
     Net::HTTP.start('example.com') do |http|
       response = http.get('/')
       assert_equal 'port 80', response.body
@@ -175,8 +179,8 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_content_for_registered_uris_with_ports_on_same_domain_and_request_with_port
-    FakeWeb.register_uri('http://example.com:3000/', :string => 'port 3000')
-    FakeWeb.register_uri('http://example.com/', :string => 'port 80')
+    FakeWeb.register_uri(:get, 'http://example.com:3000/', :body => 'port 3000')
+    FakeWeb.register_uri(:get, 'http://example.com/', :body => 'port 80')
     Net::HTTP.start('example.com', 3000) do |http|
       response = http.get('/')
       assert_equal 'port 3000', response.body
@@ -185,7 +189,7 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_content_for_registered_uri_with_get_method_only
     FakeWeb.allow_net_connect = false
-    FakeWeb.register_uri(:get, "http://example.com/", :string => "test example content")
+    FakeWeb.register_uri(:get, "http://example.com/", :body => "test example content")
     Net::HTTP.start('example.com') do |http|
       assert_equal 'test example content', http.get('/').body
       assert_raises(FakeWeb::NetConnectNotAllowedError) { http.post('/', nil) }
@@ -196,7 +200,7 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_content_for_registered_uri_with_any_method_explicitly
     FakeWeb.allow_net_connect = false
-    FakeWeb.register_uri(:any, "http://example.com/", :string => "test example content")
+    FakeWeb.register_uri(:any, "http://example.com/", :body => "test example content")
     Net::HTTP.start('example.com') do |http|
       assert_equal 'test example content', http.get('/').body
       assert_equal 'test example content', http.post('/', nil).body
@@ -207,7 +211,10 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_content_for_registered_uri_with_any_method_implicitly
     FakeWeb.allow_net_connect = false
-    FakeWeb.register_uri("http://example.com/", :string => "test example content")
+    capture_stderr do  # silence deprecation warning
+      FakeWeb.register_uri("http://example.com/", :body => "test example content")
+    end
+
     Net::HTTP.start('example.com') do |http|
       assert_equal 'test example content', http.get('/').body
       assert_equal 'test example content', http.post('/', nil).body
@@ -217,7 +224,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_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')
     Net::HTTP.start('mock') do |http|
       response = http.get('/test_example.txt')
       assert_equal 'test example content', response.body
@@ -225,7 +232,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_with_undocumented_full_uri_argument_style
-    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')
     Net::HTTP.start('mock') do |query|
       response = query.get('http://mock/test_example.txt')
       assert_equal 'test example content', response.body
@@ -233,7 +240,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_with_undocumented_full_uri_argument_style_and_query
-    FakeWeb.register_uri('http://mock/test_example.txt?a=b', :string => 'test query content')
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt?a=b', :body => 'test query content')
     Net::HTTP.start('mock') do |query|
       response = query.get('http://mock/test_example.txt?a=b')
       assert_equal 'test query content', response.body
@@ -241,7 +248,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_post
-    FakeWeb.register_uri('http://mock/test_example.txt', :file => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    FakeWeb.register_uri(:post, 'http://mock/test_example.txt', :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     response = nil
     Net::HTTP.start('mock') do |query|
       response = query.post('/test_example.txt', '')
@@ -251,7 +258,7 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_mock_post_with_string_as_registered_uri
     response = nil
-    FakeWeb.register_uri('http://mock/test_string.txt', :string => 'foo')
+    FakeWeb.register_uri(:post, 'http://mock/test_string.txt', :body => 'foo')
     Net::HTTP.start('mock') do |query|
       response = query.post('/test_string.txt', '')
     end
@@ -260,7 +267,7 @@ class TestFakeWeb < Test::Unit::TestCase
 
   def test_mock_get_with_request_as_registered_uri
     fake_response = Net::HTTPOK.new('1.1', '200', 'OK')
-    FakeWeb.register_uri('http://mock/test_response', :response => fake_response)
+    FakeWeb.register_uri(:get, 'http://mock/test_response', :response => fake_response)
     response = nil
     Net::HTTP.start('mock') do |query|
       response = query.get('/test_response')
@@ -270,7 +277,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_get_with_request_from_file_as_registered_uri
-    FakeWeb.register_uri('http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
+    FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
     response = nil
     Net::HTTP.start('www.google.com') do |query|
       response = query.get('/')
@@ -280,7 +287,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_post_with_request_from_file_as_registered_uri
-    FakeWeb.register_uri('http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
+    FakeWeb.register_uri(:post, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
     response = nil
     Net::HTTP.start('www.google.com') do |query|
       response = query.post('/', '')
@@ -290,8 +297,8 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_proxy_request
-    FakeWeb.register_uri('http://www.example.com/', :string => "hello world")
-    FakeWeb.register_uri('http://your.proxy.host/', :string => "lala")
+    FakeWeb.register_uri(:get, 'http://www.example.com/', :body => "hello world")
+    FakeWeb.register_uri(:get, 'http://your.proxy.host/', :body => "lala")
     proxy_addr = 'your.proxy.host'
     proxy_port = 8080
 
@@ -302,7 +309,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_https_request
-    FakeWeb.register_uri('https://www.example.com/', :string => "Hello World")
+    FakeWeb.register_uri(:get, 'https://www.example.com/', :body => "Hello World")
     http = Net::HTTP.new('www.example.com', 443)
     http.use_ssl = true
     response = http.get('/')
@@ -310,7 +317,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_register_unimplemented_response
-    FakeWeb.register_uri('http://mock/unimplemented', :response => 1)
+    FakeWeb.register_uri(:get, 'http://mock/unimplemented', :response => 1)
     assert_raises StandardError do
       Net::HTTP.start('mock') { |q| q.get('/unimplemented') }
     end
@@ -352,7 +359,7 @@ class TestFakeWeb < Test::Unit::TestCase
   def test_real_request_on_same_domain_as_mock
     setup_expectations_for_real_apple_hot_news_request
 
-    FakeWeb.register_uri('http://images.apple.com/test_string.txt', :string => 'foo')
+    FakeWeb.register_uri(:get, 'http://images.apple.com/test_string.txt', :body => 'foo')
 
     resp = nil
     Net::HTTP.start('images.apple.com') do |query|
@@ -363,7 +370,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_on_real_domain
-    FakeWeb.register_uri('http://images.apple.com/test_string.txt', :string => 'foo')
+    FakeWeb.register_uri(:get, 'http://images.apple.com/test_string.txt', :body => 'foo')
     resp = nil
     Net::HTTP.start('images.apple.com') do |query|
       resp = query.get('/test_string.txt')
@@ -372,7 +379,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_post_that_raises_exception
-    FakeWeb.register_uri('http://mock/raising_exception.txt', :exception => StandardError)
+    FakeWeb.register_uri(:post, 'http://mock/raising_exception.txt', :exception => StandardError)
     assert_raises(StandardError) do
       Net::HTTP.start('mock') do |query|
         query.post('/raising_exception.txt', 'some data')
@@ -381,7 +388,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_post_that_raises_an_http_error
-    FakeWeb.register_uri('http://mock/raising_exception.txt', :exception => Net::HTTPError)
+    FakeWeb.register_uri(:post, 'http://mock/raising_exception.txt', :exception => Net::HTTPError)
     assert_raises(Net::HTTPError) do
       Net::HTTP.start('mock') do |query|
         query.post('/raising_exception.txt', '')
@@ -397,7 +404,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_instance_syntax
-    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')
     response = nil
     uri = URI.parse('http://mock/test_example.txt')
     http = Net::HTTP.new(uri.host, uri.port)
@@ -412,7 +419,7 @@ class TestFakeWeb < Test::Unit::TestCase
     response = nil
     proxy_address = nil
     proxy_port = nil
-    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')
     uri = URI.parse('http://mock/test_example.txt')
     http = Net::HTTP::Proxy(proxy_address, proxy_port).new(
               uri.host, (uri.port or 80))
@@ -424,7 +431,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_response_type
-    FakeWeb.register_uri('http://mock/test_example.txt', :string => "test")
+    FakeWeb.register_uri(:get, 'http://mock/test_example.txt', :body => "test")
     Net::HTTP.start('mock') do |http|
       response = http.get('/test_example.txt')
       assert_kind_of(Net::HTTPSuccess, response)
@@ -432,7 +439,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_that_raises_an_http_error_with_a_specific_status
-    FakeWeb.register_uri('http://mock/raising_exception.txt', :exception => Net::HTTPError, :status => ['404', 'Not Found'])
+    FakeWeb.register_uri(:get, 'http://mock/raising_exception.txt', :exception => Net::HTTPError, :status => ['404', 'Not Found'])
     exception = assert_raises(Net::HTTPError) do
       Net::HTTP.start('mock') { |http| response = http.get('/raising_exception.txt') }
     end
@@ -441,10 +448,10 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_rotate_responses
-    FakeWeb.register_uri('http://mock/multiple_test_example.txt',
-                         [ {:file => File.dirname(__FILE__) + '/fixtures/test_example.txt', :times => 2},
-                           {:string => "thrice", :times => 3},
-                           {:string => "ever_more"} ])
+    FakeWeb.register_uri(:get, 'http://mock/multiple_test_example.txt',
+                         [ {:body => File.dirname(__FILE__) + '/fixtures/test_example.txt', :times => 2},
+                           {:body => "thrice", :times => 3},
+                           {:body => "ever_more"} ])
 
     uri = URI.parse('http://mock/multiple_test_example.txt')
     2.times { assert_equal 'test example content', Net::HTTP.get(uri) }
@@ -453,7 +460,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_using_response_with_transfer_encoding_header_has_valid_transfer_encoding_header
-    FakeWeb.register_uri('http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_with_transfer_encoding')
+    FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_with_transfer_encoding')
     response = nil
     Net::HTTP.start('www.google.com') do |query|
       response = query.get('/')
@@ -463,7 +470,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_using_response_without_transfer_encoding_header_does_not_have_a_transfer_encoding_header
-    FakeWeb.register_uri('http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
+    FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_without_transfer_encoding')
     response = nil
     Net::HTTP.start('www.google.com') do |query|
       response = query.get('/')
@@ -472,7 +479,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_mock_request_using_response_from_curl_has_original_transfer_encoding_header
-    FakeWeb.register_uri('http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_from_curl')
+    FakeWeb.register_uri(:get, 'http://www.google.com/', :response => File.dirname(__FILE__) + '/fixtures/google_response_from_curl')
     response = nil
     Net::HTTP.start('www.google.com') do |query|
       response = query.get('/')
@@ -482,7 +489,7 @@ class TestFakeWeb < Test::Unit::TestCase
   end
 
   def test_txt_file_should_have_three_lines
-    FakeWeb.register_uri('http://www.google.com/', :file => File.dirname(__FILE__) + '/fixtures/test_txt_file')
+    FakeWeb.register_uri(:get, 'http://www.google.com/', :body => File.dirname(__FILE__) + '/fixtures/test_txt_file')
     response = nil
     Net::HTTP.start('www.google.com') do |query|
       response = query.get('/')
@@ -494,26 +501,44 @@ class TestFakeWeb < Test::Unit::TestCase
     require "fakeweb"
   end
 
-  def test_registering_using_response_with_string_containing_null_byte
+  def test_registering_with_string_containing_null_byte
     # Regression test for File.exists? raising an ArgumentError ("string
     # contains null byte") since :response first tries to find by filename.
     # The string should be treated as a response body, instead, and an
     # EOFError is raised when the byte is encountered.
-    FakeWeb.register_uri("http://example.com", :response => "test\0test")
+    FakeWeb.register_uri(:get, "http://example.com", :response => "test\0test")
     assert_raise EOFError do
       Net::HTTP.get(URI.parse("http://example.com"))
     end
+
+    FakeWeb.register_uri(:get, "http://example.com", :body => "test\0test")
+    body = Net::HTTP.get(URI.parse("http://example.com"))
+    assert_equal "test\0test", body
+  end
+
+  def test_registering_with_string_that_is_a_directory_name
+    # Similar to above, but for Errno::EISDIR being raised since File.exists?
+    # returns true for directories
+    FakeWeb.register_uri(:get, "http://example.com", :response => File.dirname(__FILE__))
+    assert_raise EOFError do
+      body = Net::HTTP.get(URI.parse("http://example.com"))
+    end
+
+    FakeWeb.register_uri(:get, "http://example.com", :body => File.dirname(__FILE__))
+    body = Net::HTTP.get(URI.parse("http://example.com"))
+    assert_equal File.dirname(__FILE__), body
   end
 
   def test_http_version_from_string_response
-    FakeWeb.register_uri(:get, "http://example.com", :string => "example")
+    FakeWeb.register_uri(:get, "http://example.com", :body => "example")
     response = Net::HTTP.start("example.com") { |http| http.get("/") }
     assert_equal "1.0", response.http_version
   end
 
   def test_http_version_from_file_response
-    FakeWeb.register_uri(:get, "http://example.com", :file => File.dirname(__FILE__) + '/fixtures/test_example.txt')
+    FakeWeb.register_uri(:get, "http://example.com", :body => File.dirname(__FILE__) + '/fixtures/test_example.txt')
     response = Net::HTTP.start("example.com") { |http| http.get("/") }
     assert_equal "1.0", response.http_version
   end
+
 end