bloveless_grackle 0.1.10

data/lib/grackle/handlers.rb

@@ -0,0 +1,90 @@
+module Grackle
+  
+  # This module contain handlers that know how to take a response body 
+  # from Twitter and turn it into a TwitterStruct return value. Handlers are 
+  # used by the Client to give back return values from API calls. A handler
+  # is intended to provide a +decode_response+ method which accepts the response body 
+  # as a string.
+  module Handlers
+    
+    # Decodes JSON Twitter API responses
+    class JSONHandler
+    
+      def decode_response(res)
+        json_result = JSON.parse(res)
+        load_recursive(json_result)
+      end
+      
+      private
+        def load_recursive(value)
+          if value.kind_of? Hash
+            build_struct(value)
+          elsif value.kind_of? Array
+            value.map{|v| load_recursive(v)}
+          else
+            value
+          end
+        end
+      
+        def build_struct(hash)
+          struct = TwitterStruct.new
+          hash.each do |key,v|
+            struct.send("#{key}=",load_recursive(v))
+          end
+          struct
+        end
+      
+    end
+    
+    # Decodes XML Twitter API responses
+    class XMLHandler
+      
+      #Known nodes returned by twitter that contain arrays
+      ARRAY_NODES = ['ids','statuses','users']
+      
+      def decode_response(res)
+        xml = REXML::Document.new(res)
+        load_recursive(xml.root)
+      end
+      
+      private
+        def load_recursive(node)
+          if array_node?(node)
+            node.elements.map {|e| load_recursive(e)}
+          elsif node.elements.size > 0
+            build_struct(node)
+          elsif node.elements.size == 0
+            value = node.text
+            fixnum?(value) ? value.to_i : value
+          end
+        end
+      
+        def build_struct(node)
+          ts = TwitterStruct.new
+          node.elements.each do |e|
+            ts.send("#{e.name}=",load_recursive(e))  
+          end
+          ts
+        end
+        
+        # Most of the time Twitter specifies nodes that contain an array of 
+        # sub-nodes with a type="array" attribute. There are some nodes that 
+        # they dont' do that for, though, including the <ids> node returned 
+        # by the social graph methods. This method tries to work in both situations.
+        def array_node?(node)
+          node.attributes['type'] == 'array' || ARRAY_NODES.include?(node.name)
+        end
+      
+        def fixnum?(value)
+          value =~ /^\d+$/
+        end
+    end
+    
+    # Just echoes back the response body. This is primarily used for unknown formats
+    class StringHandler
+      def decode_response(res)
+        res
+      end
+    end
+  end
+end

data/lib/grackle/transport.rb

@@ -0,0 +1,248 @@
+module Grackle
+  
+  class Response #:nodoc:
+    attr_accessor :method, :request_uri, :status, :body
+    
+    def initialize(method,request_uri,status,body)
+      self.method = method
+      self.request_uri = request_uri
+      self.status = status
+      self.body = body
+    end
+  end
+  
+  class Transport
+    
+    attr_accessor :debug, :proxy
+  
+    CRLF = "\r\n"
+    DEFAULT_REDIRECT_LIMIT = 5
+    
+    class << self
+      attr_accessor :ca_cert_file
+    end
+    
+    def req_class(method)
+      Net::HTTP.const_get(method.to_s.capitalize)
+    end
+    
+    # Options are one of
+    # - :params - a hash of parameters to be sent with the request. If a File is a parameter value, \
+    #             a multipart request will be sent. If a Time is included, .httpdate will be called on it.
+    # - :headers - a hash of headers to send with the request
+    # - :auth - a hash of authentication parameters for either basic or oauth
+    # - :timeout - timeout for the http request in seconds
+    def request(method, string_url, options={})
+      params = stringify_params(options[:params])
+      if method == :get && params
+        string_url << query_string(params)
+      end
+      url = URI.parse(string_url)
+      begin
+        execute_request(method,url,options)
+      rescue Timeout::Error
+        raise "Timeout while #{method}ing #{url.to_s}"
+      end
+    end
+    
+    def execute_request(method,url,options={})
+      conn = http_class.new(url.host, url.port)
+      conn.use_ssl = (url.scheme == 'https')
+      if conn.use_ssl?
+        configure_ssl(conn)
+      end
+      conn.start do |http| 
+        req = req_class(method).new(url.request_uri)
+        http.read_timeout = options[:timeout]
+        add_headers(req,options[:headers])
+        if file_param?(options[:params])
+          add_multipart_data(req,options[:params])
+        else
+          add_form_data(req,options[:params])
+        end
+        if options.has_key? :auth
+          if options[:auth][:type] == :basic
+            add_basic_auth(req,options[:auth])
+          elsif options[:auth][:type] == :oauth
+            add_oauth(http,req,options[:auth])
+          end
+        end
+        dump_request(req) if debug
+        res = http.request(req)
+        dump_response(res) if debug
+        redirect_limit = options[:redirect_limit] || DEFAULT_REDIRECT_LIMIT
+        if res.code.to_s =~ /^3\d\d$/ && redirect_limit > 0 && res['location']
+          execute_request(method,URI.parse(res['location']),options.merge(:redirect_limit=>redirect_limit-1))
+        else 
+          Response.new(method,url.to_s,res.code.to_i,res.body)
+        end
+      end
+    end
+
+    def query_string(params)
+      query = case params
+        when Hash then params.map{|key,value| url_encode_param(key,value) }.join("&")
+        else url_encode(params.to_s)
+      end
+      if !(query == nil || query.length == 0) && query[0,1] != '?'
+        query = "?#{query}"
+      end
+      query
+    end      
+  
+    private
+      def stringify_params(params)
+        return nil unless params
+        params.inject({}) do |h, pair|
+          key, value = pair
+          if value.respond_to? :httpdate
+            value = value.httpdate
+          end
+          h[key] = value
+          h
+        end
+      end
+      
+      def file_param?(params)
+        return false unless params
+        params.any? {|key,value| value.respond_to? :read }
+      end
+      
+      def url_encode(value)
+        require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+        CGI.escape(value.to_s)
+      end
+      
+      def url_encode_param(key,value)
+        "#{url_encode(key)}=#{url_encode(value)}"
+      end
+      
+      def add_headers(req,headers)
+        if headers
+          headers.each do |header, value|
+            req[header] = value
+          end
+        end        
+      end
+    
+      def add_form_data(req,params)
+        if request_body_permitted?(req) && params
+          req.set_form_data(params)
+        end
+      end
+    
+      def add_multipart_data(req,params)
+        boundary = Time.now.to_i.to_s(16)
+        req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        body = ""
+        params.each do |key,value|
+          esc_key = url_encode(key)
+          body << "--#{boundary}#{CRLF}"
+          if value.respond_to?(:read)
+            mime_type = MIME::Types.type_for(value.path)[0] || MIME::Types["application/octet-stream"][0]
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{CRLF}"
+            body << "Content-Type: #{mime_type.simplified}#{CRLF*2}"
+            body << value.read
+          else
+            body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{CRLF*2}#{value}"
+          end
+          body << CRLF
+        end
+        body << "--#{boundary}--#{CRLF*2}"
+        req.body = body
+        req["Content-Length"] = req.body.size
+      end
+    
+      def add_basic_auth(req,auth)
+        username = auth[:username]
+        password = auth[:password]
+        if username && password
+          req.basic_auth(username,password)
+        end
+      end
+      
+      def add_oauth(conn,req,auth)
+        options = auth.reject do |key,value|
+          [:type,:consumer_key,:consumer_secret,:token,:token_secret].include?(key)
+        end
+        unless options.has_key?(:site)
+          options[:site] = oauth_site(conn,req)
+        end
+        consumer = OAuth::Consumer.new(auth[:consumer_key],auth[:consumer_secret],options)
+        access_token = OAuth::AccessToken.new(consumer,auth[:token],auth[:token_secret])
+        consumer.sign!(req,access_token)
+      end
+
+      def oauth_site(conn,req)
+        site = "#{(conn.use_ssl? ? "https" : "http")}://#{conn.address}"
+        if (conn.use_ssl? && conn.port != 443) || (!conn.use_ssl? && conn.port != 80) 
+          site << ":#{conn.port}"
+        end
+        site
+      end
+      
+      def dump_request(req)
+        puts "Sending Request"
+        puts"#{req.method} #{req.path}"
+        dump_headers(req)
+      end
+    
+      def dump_response(res)
+        puts "Received Response"
+        dump_headers(res)
+        puts res.body
+      end
+    
+      def dump_headers(msg)
+        msg.each_header do |key, value|
+          puts "\t#{key}=#{value}"
+        end
+      end
+
+      def http_class
+        if proxy
+          if proxy.kind_of?(Proc)
+            proxy.call(self)
+          else
+            proxy
+          end
+        else
+          Net::HTTP
+        end
+      end
+
+      def configure_ssl(conn)
+        if self.class.ca_cert_file
+          conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          conn.ca_file = self.class.ca_cert_file
+        else
+          # Turn off SSL verification which gets rid of warning in 1.8.x and 
+          # an error in 1.9.x.
+          conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          unless @ssl_warning_shown
+            puts <<-EOS
+Warning: SSL Verification is not being performed. While your communication is 
+being encrypted, the identity of the other party is not being confirmed nor the 
+SSL certificate verified. It's recommended that you specify a file containing 
+root SSL certificates like so:
+ 
+Grackle::Transport.ca_cert_file = "path/to/cacerts.pem"
+  
+You can download this kind of file from the maintainers of cURL:
+http://curl.haxx.se/ca/cacert.pem
+  
+EOS
+            @ssl_warning_shown = true
+          end
+        end
+      end
+
+      # Methods like Twitter's DELETE list membership expect that the user id 
+      # will be form encoded like a POST request in the body. Net::HTTP seems 
+      # to think that DELETEs can't have body parameters so we have to work 
+      # around that.
+      def request_body_permitted?(req)
+        req.request_body_permitted? || req.kind_of?(Net::HTTP::Delete)
+      end
+  end
+end

data/lib/grackle/utils.rb

@@ -0,0 +1,16 @@
+module Grackle
+  module Utils
+    
+    VALID_PROFILE_IMAGE_SIZES = [:bigger,:normal,:mini]
+    
+    #Easy method for getting different sized profile images using Twitter's naming scheme
+    def profile_image_url(url,size=:normal)
+      size = VALID_PROFILE_IMAGE_SIZES.find(:normal){|s| s == size.to_sym}
+      return url if url.nil? || size == :normal
+      url.sub(/_normal\./,"_#{size.to_s}.")
+    end
+  
+    module_function :profile_image_url    
+    
+  end
+end

data/test/test_client.rb

@@ -0,0 +1,359 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestClient < Test::Unit::TestCase
+  
+  #Used for mocking HTTP requests
+  class Net::HTTP
+    class << self
+      attr_accessor :response, :request, :last_instance, :responder
+    end
+    
+    def connect
+      # This needs to be overridden so SSL requests can be mocked
+    end
+   
+    def request(req)
+      self.class.last_instance = self
+      if self.class.responder
+        self.class.responder.call(self,req)        
+      else
+        self.class.request = req
+        self.class.response
+      end
+    end
+  end
+  
+  class MockProxy < Net::HTTP
+    class << self
+      attr_accessor :started
+      [:response,:request,:last_instance,:responder].each do |m|
+        class_eval "
+          def #{m}; Net::HTTP.#{m}; end
+          def #{m}=(val); Net::HTTP.#{m} = val; end
+        "
+      end
+    end
+    
+    def start
+      self.class.started = true
+      super
+    end
+  end
+  
+  #Mock responses that conform to HTTPResponse's interface
+  class MockResponse < Net::HTTPResponse
+    #include Net::HTTPHeader
+    attr_accessor :code, :body
+    def initialize(code,body,headers={})
+      super
+      self.code = code
+      self.body = body
+      headers.each do |name, value|
+        self[name] = value
+      end
+    end
+  end
+  
+  #Transport that collects info on requests and responses for testing purposes
+  class MockTransport < Grackle::Transport
+    attr_accessor :status, :body, :method, :url, :options, :timeout
+    
+    def initialize(status,body,headers={})
+      Net::HTTP.response = MockResponse.new(status,body,headers)
+    end
+    
+    def request(method, string_url, options)
+      self.method = method
+      self.url = URI.parse(string_url)
+      self.options = options
+      super(method,string_url,options)
+    end
+  end
+  
+  class TestHandler
+    attr_accessor :decode_value
+    
+    def initialize(value)
+      self.decode_value = value
+    end
+    
+    def decode_response(body)
+      decode_value  
+    end
+  end
+  
+  def test_redirects
+    redirects = 2 #Check that we can follow 2 redirects before getting to original request
+    req_count = 0
+    responder = Proc.new do |inst, req|
+      req_count += 1
+      #Store the original request
+      if req_count == 1
+        inst.class.request = req 
+      else
+        assert_equal("/somewhere_else#{req_count-1}.json",req.path)
+      end
+      if req_count <= redirects
+        MockResponse.new(302,"You are being redirected",'location'=>"http://twitter.com/somewhere_else#{req_count}.json")
+      else
+        inst.class.response
+      end
+    end
+    with_http_responder(responder) do
+      test_simple_get_request
+    end
+    assert_equal(redirects+1,req_count)
+  end
+  
+  def test_timeouts
+    client = new_client(200,'{"id":12345,"screen_name":"test_user"}')
+    assert_equal(60, client.timeout)
+    client.timeout = 30
+    assert_equal(30, client.timeout)
+  end
+  
+  def test_simple_get_request
+    client = new_client(200,'{"id":12345,"screen_name":"test_user"}')
+    value = client.users.show.json? :screen_name=>'test_user'
+    assert_equal(:get,client.transport.method)
+    assert_equal('http',client.transport.url.scheme)
+    assert(!Net::HTTP.last_instance.use_ssl?,'Net::HTTP instance should not be set to use SSL')
+    assert_equal('api.twitter.com',client.transport.url.host)
+    assert_equal('/1/users/show.json',client.transport.url.path)
+    assert_equal('test_user',client.transport.options[:params][:screen_name])
+    assert_equal('screen_name=test_user',Net::HTTP.request.path.split(/\?/)[1])
+    assert_equal(12345,value.id)
+  end
+  
+  def test_simple_post_request_with_basic_auth
+    client = Grackle::Client.new(:auth=>{:type=>:basic,:username=>'fake_user',:password=>'fake_pass'})
+    test_simple_post(client) do
+      assert_match(/Basic/i,Net::HTTP.request['Authorization'],"Request should include Authorization header for basic auth")
+    end
+  end
+  
+  def test_simple_post_request_with_oauth
+    client = Grackle::Client.new(:auth=>{:type=>:oauth,:consumer_key=>'12345',:consumer_secret=>'abc',:token=>'wxyz',:token_secret=>'98765'})
+    test_simple_post(client) do
+      auth = Net::HTTP.request['Authorization']
+      assert_match(/OAuth/i,auth,"Request should include Authorization header for OAuth")
+      assert_match(/oauth_consumer_key="12345"/,auth,"Auth header should include consumer key")
+      assert_match(/oauth_token="wxyz"/,auth,"Auth header should include token")
+      assert_match(/oauth_signature_method="HMAC-SHA1"/,auth,"Auth header should include HMAC-SHA1 signature method as that's what Twitter supports")
+    end
+  end
+  
+  def test_ssl
+    client = new_client(200,'[{"id":1,"text":"test 1"}]',:ssl=>true)
+    client.statuses.public_timeline?
+    assert_equal("https",client.transport.url.scheme)
+    assert(Net::HTTP.last_instance.use_ssl?,'Net::HTTP instance should be set to use SSL')
+  end
+  
+  def test_ssl_with_ca_cert_file
+    MockTransport.ca_cert_file = "some_ca_certs.pem"
+    client = new_client(200,'[{"id":1,"text":"test 1"}]',:ssl=>true)
+    client.statuses.public_timeline?
+    assert_equal(OpenSSL::SSL::VERIFY_PEER,Net::HTTP.last_instance.verify_mode,'Net::HTTP instance should use OpenSSL::SSL::VERIFY_PEER mode')
+    assert_equal(MockTransport.ca_cert_file,Net::HTTP.last_instance.ca_file,'Net::HTTP instance should have cert file set')
+  end
+  
+  def test_default_format
+    client = new_client(200,'[{"id":1,"text":"test 1"}]',:default_format=>:json)
+    client.statuses.public_timeline?
+    assert_match(/\.json$/,client.transport.url.path)
+    
+    client = new_client(200,'<statuses type="array"><status><id>1</id><text>test 1</text></status></statuses>',:default_format=>:xml)
+    client.statuses.public_timeline?
+    assert_match(/\.xml$/,client.transport.url.path)
+  end
+  
+  def test_api
+    client = new_client(200,'[{"id":1,"text":"test 1"}]',:api=>:search)
+    client.search? :q=>'test'
+    assert_equal('search.twitter.com',client.transport.url.host)
+
+    client[:rest].users.show.some_user?
+    assert_equal('api.twitter.com',client.transport.url.host)
+
+    client.api = :search
+    client.trends?
+    assert_equal('search.twitter.com',client.transport.url.host)
+    
+    client.api = :v1
+    client.search? :q=>'test'
+    assert_equal('api.twitter.com',client.transport.url.host)
+    assert_match(%r{^/1/search},client.transport.url.path)
+
+    client.api = :rest
+    client[:v1].users.show.some_user?
+    assert_equal('api.twitter.com',client.transport.url.host)
+    assert_match(%r{^/1/users/show/some_user},client.transport.url.path)
+  end
+  
+  def test_headers
+    client = new_client(200,'[{"id":1,"text":"test 1"}]',:headers=>{'User-Agent'=>'TestAgent/1.0','X-Test-Header'=>'Header Value'})
+    client.statuses.public_timeline?
+    assert_equal('TestAgent/1.0',Net::HTTP.request['User-Agent'],"Custom User-Agent header should have been set")
+    assert_equal('Header Value',Net::HTTP.request['X-Test-Header'],"Custom X-Test-Header header should have been set")
+  end
+  
+  def test_custom_handlers
+    client = new_client(200,'[{"id":1,"text":"test 1"}]',:handlers=>{:json=>TestHandler.new(42)})
+    value = client.statuses.public_timeline.json?
+    assert_equal(42,value)
+  end
+  
+  def test_clear
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    client.some.url.that.does.not.exist
+    assert_equal('/some/url/that/does/not/exist',client.send(:request).path,"An unexecuted path should be built up")
+    client.clear
+    assert_equal('',client.send(:request).path,"The path shoudl be cleared")
+  end
+  
+  def test_file_param_triggers_multipart_encoding
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    client.account.update_profile_image! :image=>File.new(__FILE__)    
+    assert_match(/multipart\/form-data/,Net::HTTP.request['Content-Type'])
+  end
+  
+  def test_time_param_is_http_encoded_and_escaped
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    time = Time.now-60*60
+    client.statuses.public_timeline? :since=>time  
+    assert_equal("/1/statuses/public_timeline.json?since=#{CGI::escape(time.httpdate)}",Net::HTTP.request.path)
+  end
+
+  def test_simple_http_method_block
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    client.delete { direct_messages.destroy :id=>1, :other=>'value' }
+    assert_equal(:delete,client.transport.method, "delete block should use delete method")
+    assert_equal("/1/direct_messages/destroy/1.json",Net::HTTP.request.path)
+    assert_equal('value',client.transport.options[:params][:other])
+    
+    client = new_client(200,'{"id":54321,"screen_name":"test_user"}')
+    value = client.get { users.show.json? :screen_name=>'test_user' }
+    assert_equal(:get,client.transport.method)
+    assert_equal('http',client.transport.url.scheme)
+    assert(!Net::HTTP.last_instance.use_ssl?,'Net::HTTP instance should not be set to use SSL')
+    assert_equal('api.twitter.com',client.transport.url.host)
+    assert_equal('/1/users/show.json',client.transport.url.path)
+    assert_equal('test_user',client.transport.options[:params][:screen_name])
+    assert_equal('screen_name=test_user',Net::HTTP.request.path.split(/\?/)[1])
+    assert_equal(54321,value.id)    
+  end
+  
+  def test_http_method_blocks_choose_right_method
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    client.get { search :q=>'test' }
+    assert_equal(:get,client.transport.method, "Get block should choose get method")
+    client.delete { direct_messages.destroy :id=>1 }
+    assert_equal(:delete,client.transport.method, "Delete block should choose delete method")
+    client.post { direct_messages.destroy :id=>1 }
+    assert_equal(:post,client.transport.method, "Post block should choose post method")
+    client.put { direct_messages :id=>1 }
+    assert_equal(:put,client.transport.method, "Put block should choose put method")
+  end
+  
+  def test_http_method_selection_precedence
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    client.get { search! :q=>'test' }
+    assert_equal(:get,client.transport.method, "Get block should override method even if post bang is used")
+    client.delete { search? :q=>'test', :__method=>:post }
+    assert_equal(:post,client.transport.method, ":__method=>:post should override block setting and method suffix")
+  end
+  
+  def test_underscore_method_works_with_numbers
+    client = new_client(200,'{"id":12345,"screen_name":"test_user"}')
+    value = client.users.show._(12345).json?
+    assert_equal(:get,client.transport.method)
+    assert_equal('http',client.transport.url.scheme)
+    assert(!Net::HTTP.last_instance.use_ssl?,'Net::HTTP instance should not be set to use SSL')
+    assert_equal('api.twitter.com',client.transport.url.host)
+    assert_equal('/1/users/show/12345.json',client.transport.url.path)
+    assert_equal(12345,value.id)
+  end
+  
+  def test_transport_proxy_setting_is_used
+    client = new_client(200,'{"id":12345,"screen_name":"test_user"}')
+    called = false
+    call_trans = nil
+    client.transport.proxy = Proc.new {|trans| call_trans = trans; called = true; MockProxy }
+    client.users.show._(12345).json?
+    assert(called,"Proxy proc should be called during request")
+    assert(MockProxy.started,"Proxy should have been called")
+    assert_equal(client.transport,call_trans,"Proxy should have been called with transport")
+    MockProxy.started = false
+    client.transport.proxy = MockProxy
+    client.users.show._(12345).json?
+    assert(MockProxy.started,"Proxy should have been called")
+    MockProxy.started = false
+    client.transport.proxy = nil
+    assert_equal(false,MockProxy.started,"Proxy should not have been called")
+  end
+  
+  def test_auto_append_ids_is_honored
+    client = new_client(200,'{"id":12345,"screen_name":"test_user"}')
+    client.users.show.json? :id=>12345
+    assert_equal('/1/users/show/12345.json',client.transport.url.path,"Id should be appended by default")
+    client.auto_append_ids = false
+    client.users.show.json? :id=>12345
+    assert_equal('/1/users/show.json',client.transport.url.path,"Id should not be appended")
+    assert_equal(12345,client.transport.options[:params][:id], "Id should be treated as a parameter")
+    assert_equal("id=#{12345}",Net::HTTP.request.path.split(/\?/)[1],"id should be part of the query string")    
+  end
+  
+  def test_auto_append_ids_can_be_set_in_constructor
+    client = new_client(200,'{"id":12345,"screen_name":"test_user"}',:auto_append_ids=>false)
+    client.users.show.json? :id=>12345
+    assert_equal('/1/users/show.json',client.transport.url.path,"Id should not be appended")
+    assert_equal(12345,client.transport.options[:params][:id], "Id should be treated as a parameter")
+    assert_equal("id=#{12345}",Net::HTTP.request.path.split(/\?/)[1],"id should be part of the query string")    
+  end
+  
+  def test_default_api
+    client = Grackle::Client.new
+    assert_equal(:v1,client.api,":v1 should be default api")
+  end
+  
+  # Methods like Twitter's DELETE list membership expect that the user id will 
+  # be form encoded like a POST request in the body. Net::HTTP seems to think 
+  # that DELETEs can't have body parameters so we have to work around that.
+  def test_delete_can_send_body_parameters
+    client = new_client(200,'{"id":12345,"name":"Test List","members":0}')
+    client.delete { some_user.some_list.members? :user_id=>12345 }
+    assert_equal(:delete,client.transport.method,"Expected delete request")
+    assert_equal('http',client.transport.url.scheme,"Expected scheme to be http")
+    assert_equal('api.twitter.com',client.transport.url.host,"Expected request to be against twitter.com")
+    assert_equal('/1/some_user/some_list/members.json',client.transport.url.path)
+    assert_match(/user_id=12345/,Net::HTTP.request.body,"Parameters should be form encoded")
+  end
+  
+  private
+    def with_http_responder(responder)
+      Net::HTTP.responder = responder
+      yield
+    ensure
+      Net::HTTP.responder = nil
+    end
+    
+    def new_client(response_status, response_body, client_opts={})
+      client = Grackle::Client.new(client_opts)
+      client.transport = MockTransport.new(response_status,response_body)
+      client
+    end
+    
+    def test_simple_post(client)
+      client.transport = MockTransport.new(200,'{"id":12345,"text":"test status"}')
+      value = client.statuses.update! :status=>'test status'
+      assert_equal(:post,client.transport.method,"Expected post request")
+      assert_equal('http',client.transport.url.scheme,"Expected scheme to be http")
+      assert_equal('api.twitter.com',client.transport.url.host,"Expected request to be against twitter.com")
+      assert_equal('/1/statuses/update.json',client.transport.url.path)
+      assert_match(/status=test%20status/,Net::HTTP.request.body,"Parameters should be form encoded")
+      assert_equal(12345,value.id)
+      yield(client) if block_given?
+    end
+  
+end