alvarobp-partigirb 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alvaro Bautista & Fernando Blat
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,9 @@
+= partigirb
+
+Wrapper for the Partigi REST API.
+
+Adapted from Hayes Davis grackle gem (http://github.com/hayesdavis/grackle/tree/master)
+
+== Copyright
+
+Copyright (c) 2009 Alvaro Bautista & Fernando Blat, released under MIT license

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "partigirb"
+    gem.summary = %Q{TODO}
+    gem.email = ["alvarobp@gmail.com", "ferblape@gmail.com"]
+    gem.homepage = "http://github.com/alvarobp/partigirb"
+    gem.authors = ["Alvaro Bautista", "Fernando Blat"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "partigirb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/partigirb/client.rb

@@ -0,0 +1,169 @@
+module Partigirb
+  class Client
+    class Request #:nodoc:
+      attr_accessor :client, :path, :method, :api_version
+      
+      def initialize(client,api_version=Partigirb::CURRENT_API_VERSION)
+        self.client = client
+        self.api_version = api_version
+        self.method = :get
+        self.path = ''
+      end
+      
+      def <<(path)
+        self.path << path
+      end
+      
+      def path?
+        path.length > 0
+      end
+    
+      def url
+        "#{scheme}://#{host}/api/v#{self.api_version}#{path}"
+      end
+         
+      def host
+        client.api_host
+      end
+    
+      def scheme
+        'http'
+      end
+    end
+    
+    VALID_METHODS = [:get,:post,:put,:delete]
+    VALID_FORMATS = [:atom,:xml,:json]
+
+    PARTIGI_API_HOST = "www.partigi.com"
+    TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
+    
+    attr_accessor :default_format, :headers, :api_version, :transport, :request, :api_host, :auth
+    
+    def initialize(options={})
+      self.transport = Transport.new
+      self.api_host = PARTIGI_API_HOST.clone
+      self.api_version = options[:api_version] || Partigirb::CURRENT_API_VERSION
+      self.headers = {"User-Agent"=>"Partigirb/#{Partigirb::VERSION}"}.merge!(options[:headers]||{})
+      self.default_format = options[:default_format] || :xml
+
+      #self.handlers = {:json=>Handlers::JSONHandler.new,:xml=>Handlers::XMLHandler.new,:unknown=>Handlers::StringHandler.new}
+      #self.handlers.merge!(options[:handlers]||{})
+      
+      # Authentication param should be a hash with keys:
+      # login (required)
+      # api_secret (required)
+      # nonce (optional, would be automatically generated if missing)
+      # timestamp (optional, current timestamp will be automatically used if missing)
+      self.auth = options[:auth]
+    end
+    
+    def method_missing(name,*args)
+      # If method is a format name, execute using that format
+      if format_invocation?(name)
+        return call_with_format(name,*args)
+      end
+      # If method ends in ! or ? use that to determine post or get
+      if name.to_s =~ /^(.*)(!|\?)$/
+        name = $1.to_sym
+        # ! is a post, ? is a get
+        self.request.method = ($2 == '!' ? :post : :get)          
+        if format_invocation?(name)
+          return call_with_format(name,*args)
+        else
+          self.request << "/#{$1}"
+          return call_with_format(self.default_format,*args)
+        end
+      end
+      # Else add to the request path
+      self.request << "/#{name}"
+      self
+    end
+    
+    # Clears any pending request built up by chained methods but not executed
+    def clear
+      self.request = nil
+    end
+    
+    def request
+      @request ||= Request.new(self,api_version)
+    end
+    
+    protected
+    
+    def call_with_format(format,params={})
+      request << ".#{format}"
+      res = send_request(params)
+      process_response(format,res)
+    ensure
+      clear
+    end
+    
+    def send_request(params)
+      begin
+        set_authentication_headers
+        
+        transport.request(
+          request.method, request.url, :headers=>headers, :params=>params
+        )
+      rescue => e
+        puts e
+      end        
+    end
+    
+    def process_response(format, res)
+      process_response_errors(format, res) if res.code != 200
+      
+      # TODO: Use ResponseParser here depending on format to return a Response object
+      res
+    end
+    
+    def process_response_errors(format, res)
+      # FIXME: This is totally provisional, we should use a ResponseParser to parse errors for each format
+      case format
+      when :xml
+        res.body =~ /<error>Partigi::(.*)<\/error>/
+        puts "Error: #{$1}"
+      end
+    end
+    
+    def format_invocation?(name)
+      self.request.path? && VALID_FORMATS.include?(name)
+    end
+    
+    # Adds the proper WSSE headers if there are the right authentication parameters
+    def set_authentication_headers
+      unless self.auth.nil? || self.auth === Hash || self.auth.empty?
+        auths = self.auth.stringify_keys
+      
+        if auths.has_key?('login') &&  auths.has_key?('api_secret')
+          if !auths['timestamp'].nil?
+            timestamp = case auths['timestamp']
+            when Time
+              auths['timestamp'].strftime(TIMESTAMP_FORMAT)
+            when String
+              auths['timestamp']
+            end
+          else
+            timestamp = Time.now.strftime(TIMESTAMP_FORMAT) if timestamp.nil?
+          end
+        
+          nonce = auths['nonce'] || generate_nonce
+          password_digest = generate_password_digest(nonce, timestamp, auths['login'], auths['api_secret'])
+          headers.merge!({
+            'Authorization' => "WSSE realm=\"#{PARTIGI_API_HOST}\", profile=\"UsernameToken\"",
+            'X-WSSE' => "UsernameToken Username=\"#{auths['login']}\", PasswordDigest=\"#{password_digest}\", Nonce=\"#{nonce}\", Created=\"#{timestamp}\""
+          })
+        end
+      end
+    end
+    
+    def generate_nonce
+      o =  [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten
+      Digest::MD5.hexdigest((0..10).map{o[rand(o.length)]}.join)
+    end
+    
+    def generate_password_digest(nonce, timestamp, login, secret)
+      Base64.encode64(Digest::SHA1.hexdigest("#{nonce}#{timestamp}#{login}#{secret}")).chomp
+    end
+  end
+end

data/lib/partigirb/core_ext.rb

@@ -0,0 +1,19 @@
+# Ruby Hash extensions from ActiveSupport
+
+class Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+end

data/lib/partigirb/transport.rb

@@ -0,0 +1,160 @@
+module Partigirb
+  
+  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
+  
+    CRLF = "\r\n"
+    
+    def req_class(method)
+      case method
+        when :get then Net::HTTP::Get
+        when :post then Net::HTTP::Post
+        when :put then Net::HTTP::Put
+        when :delete then Net::HTTP::Delete
+      end
+    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
+    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 = Net::HTTP.new(url.host, url.port)
+      #conn.use_ssl = (url.scheme == 'https')
+      conn.start do |http|
+        req = req_class(method).new(url.request_uri)
+        
+        add_headers(req,options[:headers])
+        if file_param?(options[:params])
+          add_multipart_data(req,options[:params])
+        else
+          add_form_data(req,options[:params])
+        end
+        
+        dump_request(req) if debug
+        res = http.request(req)
+        dump_response(res) if debug
+        res
+      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 req.request_body_permitted? && 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
+
+      private
+        
+        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
+  end
+end

data/lib/partigirb.rb

@@ -0,0 +1,17 @@
+module Partigirb
+  VERSION='0.1.0'
+  CURRENT_API_VERSION=1
+end
+
+$:.unshift File.dirname(__FILE__)
+
+require 'open-uri'
+require 'net/http'
+require 'base64'
+require 'digest'
+require 'mime/types'
+
+require 'partigirb/core_ext'
+
+require 'partigirb/transport'
+require 'partigirb/client'

data/partigirb.gemspec

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{partigirb}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alvaro Bautista", "Fernando Blat"]
+  s.date = %q{2009-07-20}
+  s.email = ["alvarobp@gmail.com", "ferblape@gmail.com"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/partigirb.rb",
+     "lib/partigirb/client.rb",
+     "lib/partigirb/core_ext.rb",
+     "lib/partigirb/transport.rb",
+     "partigirb.gemspec",
+     "test/client_test.rb",
+     "test/mocks/net_http_mock.rb",
+     "test/mocks/response_mock.rb",
+     "test/mocks/transport_mock.rb",
+     "test/test_helper.rb",
+     "test/transport_test.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/alvarobp/partigirb}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{TODO}
+  s.test_files = [
+    "test/client_test.rb",
+     "test/mocks/net_http_mock.rb",
+     "test/mocks/response_mock.rb",
+     "test/mocks/transport_mock.rb",
+     "test/test_helper.rb",
+     "test/transport_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ClientTest < Test::Unit::TestCase
+  def setup
+    @client = new_client
+  end
+  
+  should "use GET method by default" do
+    @client.users.show.xml
+    
+    assert_equal(:get, @client.transport.method)
+  end
+  
+  should "use GET method for methods ending with ?" do
+    @client.users.show.xml?
+    
+    assert_equal(:get, @client.transport.method)
+  end
+  
+  should "not make a request if format is missing" do
+    MockTransport.any_instance.expects(:request).never
+    
+    @client.users.show
+    
+    assert_nil @client.transport.url
+  end
+  
+  should "use POST method for methods ending with !" do
+    @client.users.show.xml!
+    
+    assert_equal(:post, @client.transport.method)
+  end
+  
+  should "use POST method and default format for methods ending with !" do
+    @client.friendships.create!
+    
+    assert_equal(:post, @client.transport.method)
+    assert @client.transport.url.path.include?("/friendships/create.xml")
+  end
+  
+  should "request to the Partigi API host through HTTP protocol" do
+    @client.users.show.xml
+    
+    assert_equal('http', @client.transport.url.scheme)
+    assert_equal(Partigirb::Client::PARTIGI_API_HOST, @client.transport.url.host)
+  end
+  
+  should "use the current API version by default" do
+    @client.users.show.xml
+    
+    assert_equal(Partigirb::CURRENT_API_VERSION, @client.api_version)
+  end
+  
+  should "put the requested API version in the request url" do
+    @client = new_client(200, '', {:api_version => 3})
+    @client.users.show.xml
+    
+    assert_equal '/api/v3/users/show.xml', @client.transport.url.path
+  end
+  
+  should "add paremeters to url on GET" do
+    @client.items.index.xml :type => 'film', :page => 1, :per_page => 20
+    
+    assert_equal 3, request_query.size
+    assert request_query.include?('type=film')
+    assert request_query.include?('page=1')
+    assert request_query.include?('per_page=20')
+  end
+  
+  should "add parameters to request body on POST" do
+    @client.reviews.create! :item_id => 'star-wars', :type => 'film', :status => 2, :text => 'My favorite movie', :rating => '5'
+    
+    assert_equal 5, post_data.size
+    assert post_data.include?('item_id=star-wars')
+    assert post_data.include?('type=film')
+    assert post_data.include?('status=2')
+    assert post_data.include?('text=My%20favorite%20movie')
+    assert post_data.include?('rating=5')
+  end
+  
+  should "add any headers to the HTTP requests" do
+    @client = new_client(200, '', {:headers => {'Useless' => 'void', 'Fake' => 'header'}})
+    @client.user.show.xml
+    
+    assert_not_nil Net::HTTP.request['Useless']
+    assert_equal 'void', Net::HTTP.request['Useless']
+    assert_not_nil Net::HTTP.request['Fake']
+    assert_equal 'header', Net::HTTP.request['Fake']
+  end
+  
+  should "add authentication headers when login and secret are provided" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret'})
+    
+    @client.friendships.update! :id => 321
+    
+    assert_not_nil Net::HTTP.request['Authorization']
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    
+    assert_not_nil Net::HTTP.request['X-WSSE']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="[^"]+"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "not add authentication headers if no auth params are provided" do
+    @client.friendships.update! :id => 321
+    
+    assert_nil Net::HTTP.request['Authorization']
+    assert_nil Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use given nonce for authentication" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :nonce => '123456789101112'})
+    @client.friendships.update! :id => 321
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="123456789101112", Created="[^"]+"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use given timestamp string for authentication" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :timestamp => '2009-07-15T14:43:07Z'})
+    @client.friendships.update! :id => 321
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="2009-07-15T14:43:07Z"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use given Time object as timestamp for authentication" do
+    timestamp = Time.now
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :timestamp => timestamp})
+    @client.friendships.update! :id => 321
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="#{timestamp.strftime(Partigirb::Client::TIMESTAMP_FORMAT)}"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  should "use the PasswordDigest from given parameters" do
+    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :nonce => '123456789101112', :timestamp => '2009-07-15T14:43:07Z'})
+    @client.friendships.update! :id => 321
+    
+    pdigest = Base64.encode64(Digest::SHA1.hexdigest("1234567891011122009-07-15T14:43:07Zauserhis_api_secret")).chomp
+    
+    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
+    assert_match /UsernameToken Username="auser", PasswordDigest="#{pdigest}", Nonce="123456789101112", Created="2009-07-15T14:43:07Z"/, Net::HTTP.request['X-WSSE']
+  end
+  
+  context "generate_nonce method" do
+    should "generate random strings" do
+      @client.instance_eval do
+        nonces = []
+        1.upto(25) do
+          assert !nonces.include?(generate_nonce)
+        end
+      end
+    end
+  end
+  
+  # TODO: Test for responses
+  
+  # Copied from Grackle
+  should "clear the request path on clear" do
+    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 build up")
+    client.clear
+    assert_equal('',client.send(:request).path,"The path shoudl be cleared")
+  end
+  
+  should "use multipart encoding when using a file param" do
+    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
+  
+  should "escape and encode time param" do
+    client = new_client(200,'[{"id":1,"text":"test 1"}]')
+    time = Time.now-60*60
+    client.statuses.public_timeline? :since=>time  
+    assert_equal("/api/v#{Partigirb::CURRENT_API_VERSION}/statuses/public_timeline.xml?since=#{CGI::escape(time.httpdate)}", Net::HTTP.request.path)
+  end
+end

data/test/mocks/net_http_mock.rb

@@ -0,0 +1,12 @@
+#Used for mocking HTTP requests
+class Net::HTTP
+  class << self
+    attr_accessor :response, :request, :last_instance
+  end
+
+  def request(req)
+    self.class.last_instance = self
+    self.class.request = req
+    self.class.response
+  end
+end

data/test/mocks/response_mock.rb

@@ -0,0 +1,12 @@
+#Mock responses that conform mostly to HTTPResponse's interface
+class MockResponse
+  include Net::HTTPHeader
+  attr_accessor :code, :body
+  def initialize(code,body,headers={})
+    self.code = code
+    self.body = body
+    headers.each do |name, value|
+      self[name] = value
+    end
+  end
+end

data/test/mocks/transport_mock.rb

@@ -0,0 +1,15 @@
+#Transport that collects info on requests and responses for testing purposes
+class MockTransport < Partigirb::Transport
+  attr_accessor :status, :body, :method, :url, :options
+
+  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

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'ruby-debug'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'partigirb'
+
+# TODO: Mock requests in some better way?
+Dir.glob('test/mocks/*_mock.rb').each { |e| require e } 
+
+class Test::Unit::TestCase
+  def new_client(status=200, response_body='', client_opts={})
+    client = Partigirb::Client.new(client_opts)
+    client.transport = MockTransport.new(status,response_body)
+    client
+  end
+  
+  def request_query
+    if Net::HTTP.request && !Net::HTTP.request.path.nil? && !Net::HTTP.request.path.empty?
+      Net::HTTP.request.path.split(/\?/)[1].split('&')
+    else
+      nil
+    end
+  end
+  
+  def post_data
+    Net::HTTP.request.body.split('&')
+  end
+end

data/test/transport_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'net/http'
+
+class RequestTest < Test::Unit::TestCase
+  def test_nothing
+    assert true
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: alvarobp-partigirb
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alvaro Bautista
+- Fernando Blat
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- alvarobp@gmail.com
+- ferblape@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/partigirb.rb
+- lib/partigirb/client.rb
+- lib/partigirb/core_ext.rb
+- lib/partigirb/transport.rb
+- partigirb.gemspec
+- test/client_test.rb
+- test/mocks/net_http_mock.rb
+- test/mocks/response_mock.rb
+- test/mocks/transport_mock.rb
+- test/test_helper.rb
+- test/transport_test.rb
+has_rdoc: true
+homepage: http://github.com/alvarobp/partigirb
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/client_test.rb
+- test/mocks/net_http_mock.rb
+- test/mocks/response_mock.rb
+- test/mocks/transport_mock.rb
+- test/test_helper.rb
+- test/transport_test.rb