oauth_weshays 0.4.8.pre

data/test/test_consumer.rb

@@ -0,0 +1,220 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'mocha'
+
+require 'stringio'
+
+# This performs testing against Andy Smith's test server http://term.ie/oauth/example/
+# Thanks Andy.
+# This also means you have to be online to be able to run these.
+class ConsumerTest < Test::Unit::TestCase
+  def setup
+    @consumer=OAuth::Consumer.new(
+        'consumer_key_86cad9', '5888bf0345e5d237',
+        {
+        :site=>"http://blabla.bla",
+        :proxy=>"http://user:password@proxy.bla:8080",
+        :request_token_path=>"/oauth/example/request_token.php",
+        :access_token_path=>"/oauth/example/access_token.php",
+        :authorize_path=>"/oauth/example/authorize.php",
+        :scheme=>:header,
+        :http_method=>:get
+        })
+    @token = OAuth::ConsumerToken.new(@consumer,'token_411a7f', '3196ffd991c8ebdb')
+    @request_uri = URI.parse('http://example.com/test?key=value')
+    @request_parameters = { 'key' => 'value' }
+    @nonce = 225579211881198842005988698334675835446
+    @timestamp = "1199645624"
+    @consumer.http=Net::HTTP.new(@request_uri.host, @request_uri.port)
+  end
+
+  def test_initializer
+    assert_equal "consumer_key_86cad9",@consumer.key
+    assert_equal "5888bf0345e5d237",@consumer.secret
+    assert_equal "http://blabla.bla",@consumer.site
+    assert_equal "http://user:password@proxy.bla:8080",@consumer.proxy
+    assert_equal "/oauth/example/request_token.php",@consumer.request_token_path
+    assert_equal "/oauth/example/access_token.php",@consumer.access_token_path
+    assert_equal "http://blabla.bla/oauth/example/request_token.php",@consumer.request_token_url
+    assert_equal "http://blabla.bla/oauth/example/access_token.php",@consumer.access_token_url
+    assert_equal "http://blabla.bla/oauth/example/authorize.php",@consumer.authorize_url
+    assert_equal :header,@consumer.scheme
+    assert_equal :get,@consumer.http_method
+  end
+
+   def test_defaults
+    @consumer=OAuth::Consumer.new(
+      "key",
+      "secret",
+      {
+          :site=>"http://twitter.com"
+      })
+    assert_equal "key",@consumer.key
+    assert_equal "secret",@consumer.secret
+    assert_equal "http://twitter.com",@consumer.site
+    assert_nil    @consumer.proxy
+    assert_equal "/oauth/request_token",@consumer.request_token_path
+    assert_equal "/oauth/access_token",@consumer.access_token_path
+    assert_equal "http://twitter.com/oauth/request_token",@consumer.request_token_url
+    assert_equal "http://twitter.com/oauth/access_token",@consumer.access_token_url
+    assert_equal "http://twitter.com/oauth/authorize",@consumer.authorize_url
+    assert_equal :header,@consumer.scheme
+    assert_equal :post,@consumer.http_method
+  end
+
+  def test_site_without_path
+    @consumer=OAuth::Consumer.new(
+      "key",
+      "secret",
+      {
+          :site=>"http://twitter.com"
+      })
+    request = stub(:oauth! => nil)
+    http = stub(:request => stub(:to_hash => {}))
+    Net::HTTP::Get.expects(:new).with('/people', {}).returns(request)
+    @consumer.expects(:create_http).returns(http)
+    @consumer.request(:get, '/people', nil, {})
+  end
+
+  def test_site_with_path
+    @consumer=OAuth::Consumer.new(
+      "key",
+      "secret",
+      {
+          :site=>"http://identi.ca/api"
+      })
+    request = stub(:oauth! => nil)
+    http = stub(:request => stub(:to_hash => {}))
+    Net::HTTP::Get.expects(:new).with('/api/people', {}).returns(request)
+    @consumer.expects(:create_http).returns(http)
+    @consumer.request(:get, '/people', nil, {})
+  end
+
+  def test_post_of_nested_params_maintains_nesting
+    @consumer=OAuth::Consumer.new(
+      "key",
+      "secret",
+      {
+          :site=>"http://twitter.com"
+      })
+    request = @consumer.create_signed_request(
+      :post,
+      '/people',
+      nil,
+      {},
+      {
+        :key => {
+          :subkey => 'value'
+        }
+      })
+    assert_equal 'key%5Bsubkey%5D=value', request.body
+    assert_equal request.content_type, 'application/x-www-form-urlencoded'
+  end
+
+  def test_override_paths
+    @consumer=OAuth::Consumer.new(
+      "key",
+      "secret",
+      {
+          :site=>"http://twitter.com",
+          :request_token_url=>"http://oauth.twitter.com/request_token",
+          :access_token_url=>"http://oauth.twitter.com/access_token",
+          :authorize_url=>"http://site.twitter.com/authorize"
+      })
+    assert_equal "key",@consumer.key
+    assert_equal "secret",@consumer.secret
+    assert_equal "http://twitter.com",@consumer.site
+    assert_equal "/oauth/request_token",@consumer.request_token_path
+    assert_equal "/oauth/access_token",@consumer.access_token_path
+    assert_equal "http://oauth.twitter.com/request_token",@consumer.request_token_url
+    assert_equal "http://oauth.twitter.com/access_token",@consumer.access_token_url
+    assert_equal "http://site.twitter.com/authorize",@consumer.authorize_url
+    assert_equal :header,@consumer.scheme
+    assert_equal :post,@consumer.http_method
+  end
+
+ def test_that_token_response_should_be_uri_parameter_format_as_default
+    @consumer.expects(:request).returns(create_stub_http_response("oauth_token=token&oauth_token_secret=secret"))
+
+    hash = @consumer.token_request(:get, "")
+
+    assert_equal "token", hash[:oauth_token]
+    assert_equal "secret", hash[:oauth_token_secret]
+  end
+
+  def test_can_provided_a_block_to_interpret_token_response
+    @consumer.expects(:request).returns(create_stub_http_response)
+
+    hash = @consumer.token_request(:get, '') {{ :oauth_token => 'token', :oauth_token_secret => 'secret' }}
+
+    assert_equal 'token', hash[:oauth_token]
+    assert_equal 'secret', hash[:oauth_token_secret]
+  end
+
+  def test_token_request_follows_redirect
+    redirect_url = @request_uri.clone
+    redirect_url.path = "/oauth/example/request_token_redirect.php"
+    stub_request(:get, /.*#{@request_uri.path}/).to_return(:status => 301, :headers => {'Location' => redirect_url.to_s})
+    stub_request(:get, /.*#{redirect_url.path}/).to_return(:body => "oauth_token=token&oauth_token_secret=secret")
+
+    hash = @consumer.token_request(:get, @request_uri.path) {{ :oauth_token => 'token', :oauth_token_secret => 'secret' }}
+
+    assert_equal 'token', hash[:oauth_token]
+    assert_equal 'secret', hash[:oauth_token_secret]
+  end
+
+  def test_that_can_provide_a_block_to_interpret_a_request_token_response
+    @consumer.expects(:request).returns(create_stub_http_response)
+
+    token = @consumer.get_request_token {{ :oauth_token => 'token', :oauth_token_secret => 'secret' }}
+
+    assert_equal 'token', token.token
+    assert_equal 'secret', token.secret
+  end
+
+  def test_that_block_is_not_mandatory_for_getting_an_access_token
+    stub_token = mock
+    @consumer.expects(:request).returns(create_stub_http_response("oauth_token=token&oauth_token_secret=secret"))
+
+    token = @consumer.get_access_token(stub_token)
+
+    assert_equal 'token', token.token
+    assert_equal 'secret', token.secret
+  end
+
+  def test_that_can_provide_a_block_to_interpret_an_access_token_response
+    stub_token = mock
+    @consumer.expects(:request).returns(create_stub_http_response)
+
+    token = @consumer.get_access_token(stub_token) {{ :oauth_token => 'token', :oauth_token_secret => 'secret' }}
+
+    assert_equal 'token', token.token
+    assert_equal 'secret', token.secret
+  end
+
+  def test_that_not_setting_ignore_callback_will_include_oauth_callback_in_request_options
+    request_options = {}
+    @consumer.stubs(:request).returns(create_stub_http_response)
+
+    @consumer.get_request_token(request_options) {{ :oauth_token => 'token', :oauth_token_secret => 'secret' }}
+
+    assert_equal 'oob', request_options[:oauth_callback]
+  end
+
+  def test_that_setting_ignore_callback_will_exclude_oauth_callback_in_request_options
+    request_options = { :exclude_callback=> true }
+    @consumer.stubs(:request).returns(create_stub_http_response)
+
+    @consumer.get_request_token(request_options) {{ :oauth_token => 'token', :oauth_token_secret => 'secret' }}
+
+    assert_nil request_options[:oauth_callback]
+  end
+
+  private
+
+  def create_stub_http_response expected_body=nil
+    stub_http_response = stub
+    stub_http_response.stubs(:code).returns(200)
+    stub_http_response.stubs(:body).tap {|expectation| expectation.returns(expected_body) unless expected_body.nil? }
+    return stub_http_response
+  end
+end

data/test/test_curb_request_proxy.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../test_helper', __FILE__)
+
+begin
+
+require 'oauth/request_proxy/curb_request'
+require 'curb'
+
+
+class CurbRequestProxyTest < Test::Unit::TestCase
+
+  def test_that_proxy_simple_get_request_works
+    request = Curl::Easy.new('/test?key=value')
+    request_proxy = OAuth::RequestProxy.proxy(request, {:uri => 'http://example.com/test?key=value'})
+
+    expected_parameters = {'key' => ['value']}
+    assert_equal expected_parameters, request_proxy.parameters_for_signature
+    assert_equal 'http://example.com/test', request_proxy.normalized_uri
+  end
+
+  def test_that_proxy_simple_post_request_works_with_arguments
+    request = Curl::Easy.new('/test')
+    params = {'key' => 'value'}
+    request_proxy = OAuth::RequestProxy.proxy(request, {:uri => 'http://example.com/test', :parameters => params})
+
+    expected_parameters = {'key' => 'value'}
+    assert_equal expected_parameters, request_proxy.parameters_for_signature
+    assert_equal 'http://example.com/test', request_proxy.normalized_uri
+  end
+
+  def test_that_proxy_simple_post_request_works_with_form_data
+    request = Curl::Easy.new('/test')
+    request.post_body = 'key=value'
+    request.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+
+    request_proxy = OAuth::RequestProxy.proxy(request, {:uri => 'http://example.com/test'})
+
+    expected_parameters = {'key' => 'value'}
+    assert_equal expected_parameters, request_proxy.parameters_for_signature
+    assert_equal 'http://example.com/test', request_proxy.normalized_uri
+  end
+
+  def test_that_proxy_simple_put_request_works_with_arguments
+    request = Curl::Easy.new('/test')
+    params = {'key' => 'value'}
+    request_proxy = OAuth::RequestProxy.proxy(request, {:uri => 'http://example.com/test', :parameters => params})
+
+    expected_parameters = {'key' => 'value'}
+    assert_equal expected_parameters, request_proxy.parameters_for_signature
+    assert_equal 'http://example.com/test', request_proxy.normalized_uri
+  end
+
+  def test_that_proxy_simple_put_request_works_with_form_data
+    request = Curl::Easy.new('/test')
+    request.post_body = 'key=value'
+
+    request_proxy = OAuth::RequestProxy.proxy(request, {:uri => 'http://example.com/test'})
+
+    expected_parameters = {}
+    assert_equal expected_parameters, request_proxy.parameters_for_signature
+    assert_equal 'http://example.com/test', request_proxy.normalized_uri
+  end
+
+  def test_that_proxy_post_request_works_with_mixed_parameter_sources
+    request = Curl::Easy.new('/test?key=value')
+    request.post_body = 'key2=value2'
+    request.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+    request_proxy = OAuth::RequestProxy.proxy(request, {:uri => 'http://example.com/test?key=value', :parameters => {'key3' => 'value3'}})
+
+    expected_parameters = {'key' => ['value'], 'key2' => 'value2', 'key3' => 'value3'}
+    assert_equal expected_parameters, request_proxy.parameters_for_signature
+    assert_equal 'http://example.com/test', request_proxy.normalized_uri
+  end
+end
+
+rescue LoadError => e
+  warn "! problems loading curb, skipping these tests: #{e}"
+end

data/test/test_em_http_client.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../test_helper', __FILE__)
+begin
+
+require 'oauth/client/em_http'
+
+class EmHttpClientTest < Test::Unit::TestCase
+
+  def setup
+    @consumer = OAuth::Consumer.new('consumer_key_86cad9', '5888bf0345e5d237')
+    @token = OAuth::Token.new('token_411a7f', '3196ffd991c8ebdb')
+    @request_uri = URI.parse('http://example.com/test?key=value')
+    @request_parameters = { 'key' => 'value' }
+    @nonce = 225579211881198842005988698334675835446
+    @timestamp = "1199645624"
+    # This is really unneeded I guess.
+    @http = Net::HTTP.new(@request_uri.host, @request_uri.port)
+  end
+
+  def test_that_using_auth_headers_on_get_requests_works
+    request = create_client
+    request.oauth!(@http, @consumer, @token, {:nonce => @nonce, :timestamp => @timestamp})
+
+    assert_equal 'GET', request.method
+    assert_equal '/test', request.normalize_uri.path
+    assert_equal "key=value", request.normalize_uri.query
+    assert_equal_authz_headers "OAuth oauth_nonce=\"225579211881198842005988698334675835446\", oauth_signature_method=\"HMAC-SHA1\", oauth_token=\"token_411a7f\", oauth_timestamp=\"1199645624\", oauth_consumer_key=\"consumer_key_86cad9\", oauth_signature=\"1oO2izFav1GP4kEH2EskwXkCRFg%3D\", oauth_version=\"1.0\"", authz_header(request)
+  end
+
+  def test_that_using_auth_headers_on_get_requests_works_with_plaintext
+    require 'oauth/signature/plaintext'
+    c = OAuth::Consumer.new('consumer_key_86cad9', '5888bf0345e5d237',{
+      :signature_method => 'PLAINTEXT'
+    })
+    request = create_client
+    request.oauth!(@http, c, @token, {:nonce => @nonce, :timestamp => @timestamp, :signature_method => 'PLAINTEXT'})
+
+    assert_equal 'GET', request.method
+    assert_equal '/test', request.normalize_uri.path
+    assert_equal "key=value", request.normalize_uri.query
+    assert_equal_authz_headers "OAuth oauth_nonce=\"225579211881198842005988698334675835446\", oauth_signature_method=\"PLAINTEXT\", oauth_token=\"token_411a7f\", oauth_timestamp=\"1199645624\", oauth_consumer_key=\"consumer_key_86cad9\", oauth_signature=\"5888bf0345e5d237%263196ffd991c8ebdb\", oauth_version=\"1.0\"", authz_header(request)
+  end
+
+  def test_that_using_auth_headers_on_post_requests_works
+    request = create_client(:uri => "http://example.com/test", :method => "POST", :body => @request_parameters, :head => {"Content-Type" => "application/x-www-form-urlencoded"})
+    request.oauth!(@http, @consumer, @token, {:nonce => @nonce, :timestamp => @timestamp})
+
+    assert_equal 'POST', request.method
+    assert_equal '/test', request.uri.path
+    assert_equal 'key=value', request.normalize_body
+    assert_equal_authz_headers "OAuth oauth_nonce=\"225579211881198842005988698334675835446\", oauth_signature_method=\"HMAC-SHA1\", oauth_token=\"token_411a7f\", oauth_timestamp=\"1199645624\", oauth_consumer_key=\"consumer_key_86cad9\", oauth_signature=\"26g7wHTtNO6ZWJaLltcueppHYiI%3D\", oauth_version=\"1.0\"", authz_header(request)
+  end
+
+  protected
+
+  def create_client(options = {})
+    method         = options.delete(:method) || "GET"
+    uri            = options.delete(:uri)    || @request_uri.to_s
+    client         = EventMachine::HttpClient.new("")
+    client.uri     = URI.parse(uri)
+    client.method  = method.to_s.upcase
+    client.options = options
+    client
+  end
+
+  def authz_header(request)
+    headers = request.options[:head] || {}
+    headers['Authorization'].to_s
+  end
+
+  def assert_equal_authz_headers(expected, actual)
+    assert !actual.nil?
+    assert_equal expected[0,6], actual[0, 6]
+    assert_equal expected[6..1].split(', ').sort, actual[6..1].split(', ').sort
+  end
+
+end
+
+rescue LoadError => e
+  warn "! problem loading em-http, skipping these tests: #{e}"
+end

data/test/test_em_http_request_proxy.rb

@@ -0,0 +1,115 @@
+require File.expand_path('../test_helper', __FILE__)
+
+begin
+
+require 'em-http'
+require 'oauth/request_proxy/em_http_request'
+
+
+class EmHttpRequestProxyTest < Test::Unit::TestCase
+
+  def test_request_proxy_works_with_simple_request
+    proxy = create_request_proxy
+    assert_equal({}, proxy.parameters)
+  end
+
+  def test_request_proxy_works_with_query_string_params
+    assert_equal({"name" => ["Fred"]}, create_request_proxy(:query => "name=Fred").parameters)
+    assert_equal({"name" => ["Fred"]}, create_request_proxy(:query => {:name => "Fred"}).parameters)
+    proxy = create_request_proxy(:query => {:name => "Fred"}, :uri => "http://example.com/?awesome=true")
+    assert_equal({"name" => ["Fred"], "awesome" => ["true"]}, proxy.parameters)
+  end
+
+  def test_request_proxy_works_with_post_body_params_with_correct_content_type
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "POST"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "POST", :body => "a=1"
+    assert_equal({"a" => ["1"]}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "POST", :body => {"a" => 1}
+    assert_equal({"a" => ["1"]}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "PUT"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "PUT", :body => "a=1"
+    assert_equal({"a" => ["1"]}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "PUT", :body => {"a" => 1}
+    assert_equal({"a" => ["1"]}, proxy.parameters)
+  end
+
+  def test_request_proxy_ignore_post_body_with_invalid_content_type
+    proxy = create_request_proxy :head => {'Content-Type' => 'text/plain'}, :method => "POST"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'text/plain'}, :method => "POST", :body => "a=1"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'text/plain'}, :method => "POST", :body => {"a" => 1}
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'text/plain'}, :method => "PUT"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'text/plain'}, :method => "PUT", :body => "a=1"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'text/plain'}, :method => "PUT", :body => {"a" => 1}
+    assert_equal({}, proxy.parameters)
+  end
+
+  def test_request_proxy_ignores_post_body_with_invalid_method
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "DELETE"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "DELETE", :body => "a=1"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "DELETE", :body => {"a" => 1}
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "GET"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "GET", :body => "a=1"
+    assert_equal({}, proxy.parameters)
+    proxy = create_request_proxy :head => {'Content-Type' => 'application/x-www-form-urlencoded'}, :method => "GET", :body => {"a" => 1}
+    assert_equal({}, proxy.parameters)
+  end
+
+  def test_request_proxy_works_with_argument_params
+    assert_equal({"a" => ["1"]}, create_request_proxy(:proxy_options => {:parameters => {"a" => "1"}}).parameters)
+  end
+
+  def test_request_proxy_works_with_mixed_params
+    proxy = create_request_proxy(:proxy_options => {:parameters => {"a" => "1"}},:query => {"c" => "1"}, :uri => "http://example.com/test?b=1")
+    assert_equal({"a" => ["1"], "b" => ["1"], "c" => ["1"]}, proxy.parameters)
+    proxy = create_request_proxy(:proxy_options => {:parameters => {"a" => "1"}}, :body => {"b" => "1"}, :query => {"c" => "1"},
+      :uri => "http://example.com/test?d=1", :method => "POST", :head => {"Content-Type" => "application/x-www-form-urlencoded"})
+    assert_equal({"a" => ["1"], "b" => ["1"], "c" => ["1"], "d" => ["1"]}, proxy.parameters)
+  end
+
+  def test_request_has_the_correct_uri
+    assert_equal "http://example.com/", create_request_proxy.uri
+    assert_equal "http://example.com/?a=1", create_request_proxy(:query => "a=1").uri
+    assert_equal "http://example.com/?a=1", create_request_proxy(:query => {"a" => "1"}).uri
+
+  end
+
+  def test_request_proxy_has_correct_method
+    assert_equal "GET", create_request_proxy(:method => "GET").method
+    assert_equal "PUT", create_request_proxy(:method => "PUT").method
+    assert_equal "POST", create_request_proxy(:method => "POST").method
+    assert_equal "DELETE", create_request_proxy(:method => "DELETE").method
+  end
+
+  protected
+
+  def create_client(options = {})
+    method         = options.delete(:method) || "GET"
+    uri            = options.delete(:uri)    || "http://example.com/"
+    client         = EventMachine::HttpClient.new("")
+    client.uri     = URI.parse(uri)
+    client.method  = method.to_s.upcase
+    client.options = options
+    client
+  end
+
+  def create_request_proxy(opts = {})
+    arguments = opts.delete(:proxy_options) || {}
+    OAuth::RequestProxy.proxy(create_client(opts), arguments)
+  end
+
+end
+
+rescue LoadError => e
+  warn "! problem loading em-http, skipping these tests: #{e}"
+end

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'rubygems'
+
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib/'
+require 'oauth'
+require 'mocha'
+require 'stringio'
+require 'webmock'
+
+class Test::Unit::TestCase
+  include WebMock::API
+
+  def assert_matching_headers(expected, actual)
+    # transform into sorted arrays
+    auth_intro, auth_params = actual.split(' ', 2)
+    assert_equal auth_intro, 'OAuth'
+    expected    = expected.split(/(,|\s)/).reject {|v| v == '' || v =~ /^[\,\s]+/}.sort
+    auth_params = auth_params.split(/(,|\s)/).reject {|v| v == '' || v =~ /^[\,\s]+/}.sort
+    assert_equal expected, auth_params
+  end
+
+  def stub_test_ie
+    stub_request(:any, "http://term.ie/oauth/example/request_token.php").to_return(:body => "oauth_token=requestkey&oauth_token_secret=requestsecret")
+    stub_request(:post, "http://term.ie/oauth/example/access_token.php").to_return(:body => "oauth_token=accesskey&oauth_token_secret=accesssecret")
+    stub_request(:get, %r{http://term\.ie/oauth/example/echo_api\.php\?.+}).to_return(lambda {|request| {:body => request.uri.query}})
+    stub_request(:post, "http://term.ie/oauth/example/echo_api.php").to_return(lambda {|request| {:body => request.body}})
+  end
+end

data/test/test_hmac_sha1.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class TestSignatureHmacSha1 < Test::Unit::TestCase
+  def test_that_hmac_sha1_implements_hmac_sha1
+    assert OAuth::Signature.available_methods.include?('hmac-sha1')
+  end
+
+  def test_that_get_request_from_oauth_test_cases_produces_matching_signature
+    request = Net::HTTP::Get.new('/photos?file=vacation.jpg&size=original&oauth_version=1.0&oauth_consumer_key=dpf43f3p2l4k3l03&oauth_token=nnch734d00sl2jdk&oauth_timestamp=1191242096&oauth_nonce=kllo9940pd9333jh&oauth_signature_method=HMAC-SHA1')
+
+    consumer = OAuth::Consumer.new('dpf43f3p2l4k3l03', 'kd94hf93k423kf44')
+    token = OAuth::Token.new('nnch734d00sl2jdk', 'pfkkdhi9sl3r4s00')
+
+    signature = OAuth::Signature.sign(request, { :consumer => consumer,
+                                                 :token => token,
+                                                 :uri => 'http://photos.example.net/photos' } )
+
+    assert_equal 'tR3+Ty81lMeYAr/Fid0kMTYa/WM=', signature
+  end
+end