weary 0.6.0 → 0.7.0

data/lib/weary/resource.rb

@@ -79,7 +79,7 @@ module Weary
       parameters = setup_parameters(params, defaults)
       request_opts = setup_options(parameters, credentials)
       uri.query = request_opts[:query].to_params if request_opts[:query]
-      Weary::Request.new(uri.normalize.to_s, @via, request_opts)
+      Request.new(uri.normalize.to_s, @via, request_opts)
     end
     
     # Setup the parameters to make the Request with

data/lib/weary/response.rb

@@ -1,35 +1,33 @@
 module Weary
   class Response
   
-    attr_reader :raw, :method, :code, :message, :header, :content_type, :cookie, :body, :format
-    alias mime_type content_type
+    attr_reader :raw, :requester, :code, :message, :header, :content_type, :cookie, :body, :url
     
-    def initialize(http_response, http_method)
-      raise ArgumentError, "Must be a Net::HTTPResponse" unless http_response.is_a?(Net::HTTPResponse)
+    def initialize(http_response, requester)
       @raw = http_response
-      @method = http_method
+      @requester = requester
+      @url = requester.uri
       @code = http_response.code.to_i
       @message = http_response.message
       @header = http_response.to_hash
       @content_type = http_response.content_type
       @cookie = http_response['Set-Cookie']
       @body = http_response.body
-      self.format = http_response.content_type
     end
     
     # Is this an HTTP redirect?
     def redirected?
-      @raw.is_a?(Net::HTTPRedirection)
+      raw.is_a?(Net::HTTPRedirection)
     end
     
     # Was this Request successful?
     def success?
-      (200..299).include?(@code)
+      (200..299).include?(code)
     end
     
     # Returns a symbol corresponding to the Response's Content Type
-    def format=(type)
-      @format = case type
+    def format
+      @format ||= case content_type
         when *ContentTypes[:json]
           :json
         when *ContentTypes[:xml]
@@ -38,35 +36,33 @@ module Weary
           :html
         when *ContentTypes[:yaml]
           :yaml
-        when *ContentTypes[:plain]
-          :plain
         else
-          nil
+          :plain
       end
     end
     
     # Follow the Redirect
     def follow_redirect
       if redirected?
-        Request.new(@raw['location'], @method).perform
-      else
-        nil
-      end
+        new_request = requester.dup
+        new_request.uri = @raw['location']
+        new_request.perform
+      end  
     end
     
     # Parse the body with Crack parsers (if XML/HTML) or Yaml parser
     def parse
-      raise StandardError, "The Response has no body. #{@method.to_s.upcase} request sent." unless @body
+      raise StandardError, "The Response has no body. #{requester.via.to_s.upcase} request sent." unless body
       handle_errors
-      case @format
+      case format
         when :xml, :html
-          Crack::XML.parse @body
+          Crack::XML.parse body
         when :json
-          Crack::JSON.parse @body
+          Crack::JSON.parse body
         when :yaml
-          YAML::load @body
+          YAML::load body
         else
-          @body
+          body
       end
     end
     

data/spec/spec_helper.rb

@@ -1,16 +1,16 @@
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'rubygems'
-require 'spec'
 require 'weary'
+require 'spec'
+require 'fakeweb'
 
 def get_fixture(filename)
   open(File.join(File.dirname(__FILE__), 'fixtures', "#{filename.to_s}")).read
 end
 
-def mock_response(request_method = :get, code=200, header={}, body=nil)
-  response_class = Net::HTTPResponse::CODE_TO_OBJ[code.to_s]
-  message = case code
+def http_status_message(code)
+  message = case code.to_i
     when 200
       "OK"
     when 301
@@ -29,6 +29,8 @@ def mock_response(request_method = :get, code=200, header={}, body=nil)
       "Method Not Allowed"
     when 409
       "Conflict"
+    when 418
+      "I'm a teapot"  
     when 422
       "Unprocessable Entity"
     when 401...500
@@ -38,18 +40,5 @@ def mock_response(request_method = :get, code=200, header={}, body=nil)
     else
       "Unknown"
   end
-  response = response_class.new("1.1", code, "Hello World!")
-  response.initialize_http_header(header)
-  response.stub!(:body).and_return(body)
-  response.stub!(:message).and_return(message)
-  
-  response
-end
-
-def mock_request(url, method = :get, options={}, mock_header={}, mock_body=nil)
-  request = Weary::Request.new(url, method, options)
-  http_response = mock_response(method, 200, mock_header, mock_body)
-  request.stub!(:perform).and_return Weary::Response.new(http_response, method)
-  
-  request
+  [code.to_s,message]
 end

data/spec/weary/base_spec.rb

@@ -203,7 +203,7 @@ describe Weary::Base do
         cred = {:username => 'mwunsch', :password => 'secret'}
         lambda { n.authentication_test }.should raise_error
         n.credentials cred[:username], cred[:password]
-        n.authentication_test.options[:basic_auth].should == cred
+        n.authentication_test.credentials.should == cred
       end
       
       it 'passes in default parameters if defined' do
@@ -211,14 +211,14 @@ describe Weary::Base do
         defaults = {:id => 1234, :message => "Hello world"}
         lambda { n.params_test }.should raise_error
         n.defaults = defaults
-        n.params_test.options[:body].should == defaults
+        n.params_test.with.should == defaults.to_params
       end
       
       it 'accepts parameters when given' do
         n = @methtest.new
         req = n.params_test :id => 1234, :message => "Hello world", :foo => "Bar"
-        req.options[:body].should == {:id => 1234, :message => "Hello world"}
-        req.options[:body].has_key?(:foo).should == false
+        req.with.should == {:id => 1234, :message => "Hello world"}.to_params
+        req.with.include?("foo").should == false
       end
       
       
@@ -253,7 +253,7 @@ describe Weary::Base do
       
       obj.credentials "username", "password"
       obj.instance_variable_get(:@credentials).should == {:username => "username", :password => "password"}
-      obj.important(:id => 1234).options[:basic_auth].should == obj.instance_variable_get(:@credentials)
+      obj.important(:id => 1234).credentials.should == obj.instance_variable_get(:@credentials)
     end
     
     it 'credentials can be an OAuth access token' do
@@ -263,8 +263,7 @@ describe Weary::Base do
       
       obj.credentials oauth_token
       obj.instance_variable_get(:@credentials).class.should == OAuth::AccessToken
-      obj.important(:id => 1234).options.has_key?(:oauth).should == true
-      obj.important(:id => 1234).options.has_key?(:basic_auth).should == false
+      obj.important(:id => 1234).credentials.should == oauth_token
     end
     
     it 'can set defaults to pass into requests' do
@@ -272,7 +271,7 @@ describe Weary::Base do
       
       obj.defaults = {:user => "mwunsch", :message => "hello world"}
       obj.defaults.should == {:user => "mwunsch", :message => "hello world"}
-      obj.thing(:id => 1234).options[:query].should == {:user => "mwunsch", :message => "hello world", :id => 1234}
+      obj.thing(:id => 1234).uri.query.should == {:user => "mwunsch", :message => "hello world", :id => 1234}.to_params
     end
     
     it 'has a list of resources' do
@@ -297,8 +296,8 @@ describe Weary::Base do
       obj1.resources[:thing].follows = false
       obj1.rebuild_method(obj1.resources[:thing])
       
-      obj1.thing(:id => 1234).options[:no_follow].should == true
-      @klass.new.thing(:id => 1234).options[:no_follow].should == nil
+      obj1.thing(:id => 1234).follows?.should == false
+      @klass.new.thing(:id => 1234).follows?.should == true
     end
     
     it 'can modify a resource without modifying the resources of its class' do
@@ -314,7 +313,7 @@ describe Weary::Base do
       
       obj.credentials "username", "password"
       obj.modify_resource(:important) {|r| r.follows = false }
-      obj.important(:id => 1234).options[:no_follow].should == true
+      obj.important(:id => 1234).follows?.should == false
     end
     
   end

data/spec/weary/batch_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Weary::Batch do
+  after do
+    FakeWeb.clean_registry
+  end
+  
+  it 'is a group of requests' do
+    requests = [ Weary.get('http://twitter.com'),
+                 Weary.get('http://github.com'),
+                 Weary.get('http://vimeo.com'),
+                 Weary.get('http://tumblr.com')]
+    
+    test = Weary::Batch.new(requests)
+    test.requests.should == requests
+  end
+  
+  it 'contains a pool of threads, left empty until processing' do
+    requests = [ Weary.get('http://twitter.com'),
+                 Weary.get('http://github.com'),
+                 Weary.get('http://vimeo.com'),
+                 Weary.get('http://tumblr.com')]
+    
+    test = Weary::Batch.new(requests)
+    test.pool.blank?.should == true    
+  end
+  
+  it 'performs requests in parallel' do
+    resources = %w[http://twitter.com http://github.com http://vimeo.com http://tumblr.com]
+    resources.each {|url| FakeWeb.register_uri :get, url, :body => 'Hello world' }
+    
+    requests = [ Weary.get('http://twitter.com'),
+                 Weary.get('http://github.com'),
+                 Weary.get('http://vimeo.com'),
+                 Weary.get('http://tumblr.com')]
+    
+    test = Weary::Batch.new(requests)
+    responses = test.perform
+    responses.size.should == 4
+    responses.each {|response| response.code.should == 200 }
+  end
+  
+  describe 'Callbacks' do
+    before do
+      resources = %w[http://twitter.com http://github.com http://vimeo.com http://tumblr.com]
+      resources.each {|url| FakeWeb.register_uri :get, url, :body => 'Hello world' }
+      @requests = [ Weary.get('http://twitter.com'),
+                   Weary.get('http://github.com'),
+                   Weary.get('http://vimeo.com'),
+                   Weary.get('http://tumblr.com')]
+    end
+    
+    it 'stores the on_complete callback' do
+      test = Weary::Batch.new(@requests)
+      test.on_complete do
+        'hello'
+      end
+      test.on_complete.call.should == 'hello'
+    end
+    
+    it 'stores the before_send callback' do
+      test = Weary::Batch.new(@requests)
+      test.before_send do
+        'hello'
+      end
+      test.before_send.call.should == 'hello'
+    end
+    
+    
+  end
+end

data/spec/weary/httpverb_spec.rb

@@ -17,4 +17,9 @@ describe Weary::HTTPVerb do
     @test.request_class.should == Net::HTTP::Get
   end
   
+  it 'freaks out if you give it an unrecognized verb' do
+    test = Weary::HTTPVerb.new('FooBar')
+    lambda{ test.request_class }.should raise_error
+  end
+  
 end

data/spec/weary/request_spec.rb

@@ -2,50 +2,343 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe Weary::Request do
   
-  it "should contain a url" do
+  it 'creates a Net/HTTP connection' do
     test = Weary::Request.new("http://google.com")
-    test.uri.is_a?(URI).should == true
+    test.http.class.should == Net::HTTP
   end
   
-  it "should parse the http method" do
-    test = Weary::Request.new("http://google.com", "POST")
-    test.method.should == :post
+  it 'maps to a Net/HTTPRequest class' do
+    test = Weary::Request.new("http://google.com")
+    test.request_preparation.class.should == Net::HTTP::Get
   end
   
-  it "should craft a Net/HTTP Request" do
-    test = Weary::Request.new("http://google.com").send :http
-    test.class.should == Net::HTTP
+  describe 'Request' do
+    it 'prepares a Net/HTTP request' do
+      test = Weary::Request.new("http://google.com")
+      test.request.class.should == Net::HTTP::Get
+    end
+    
+    it 'prepares a body for POST' do
+      test = Weary::Request.new("http://foo.bar", :post)
+      test.with = {:name => "markwunsch"}
+      req = test.request
+      req.class.should == Net::HTTP::Post
+      req.body.should == test.with
+    end
+    
+    it 'sets up headers' do
+      test = Weary::Request.new("http://foo.bar")
+      test.headers = {"User-Agent" => Weary::UserAgents["Safari 4.0.2 - Mac"]}
+      req = test.request
+      req['User-Agent'].should == Weary::UserAgents["Safari 4.0.2 - Mac"]
+    end
+    
+    it 'has an authorization header when basic auth is used' do
+      test = Weary::Request.new("http://foo.bar")
+      test.credentials = {:username => "mark", :password => "secret"}
+      req = test.request
+      req.key?('Authorization').should == true
+    end
+    
+    it "prepares an oauth scheme if a token is provided" do
+      consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
+      token = OAuth::AccessToken.new(consumer, "token", "secret")
+      test = Weary::Request.new("http://foo.bar", :post)
+      test.credentials = token
+      test.request.oauth_helper.options[:token].should == token
+    end
   end
   
-  # replace with FakeWeb
-  it "should perform the request and retrieve a response" do
-    test = Weary::Request.new("http://foo.bar")
-    method = test.method
-    response = Weary::Response.new(mock_response(method, 301, {'Location' => 'http://bar.foo'}), method)
-    test.stub!(:perform).and_return(response)
-    test.perform.code.should == 301
-    test.perform.redirected?.should == true
+  describe 'Options' do
+    it 'sets the credentials to basic authentication' do
+      basic_auth = {:username => 'mark', :password => 'secret'}
+      test = Weary::Request.new("http://foo.bar", :get, {:basic_auth => basic_auth})
+      test.credentials.should == basic_auth
+    end
+
+    it 'sets the credentials to an oauth token' do
+      consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
+      token = OAuth::AccessToken.new(consumer, "token", "secret")
+      test = Weary::Request.new("http://foo.bar", :post, {:oauth => token})
+      test.credentials.should == token
+    end
+
+    it 'sets the body params' do
+      body = {:options => "something"}
+      test = Weary::Request.new("http://foo.bar", :post, {:body => body})
+      test.with.should == body.to_params
+      test2 = Weary::Request.new("http://foo.bar", :post, {:body => body.to_params})
+      test2.with.should == body.to_params
+    end
+
+    it 'sets header values' do
+      head = {"User-Agent" => Weary::UserAgents["Safari 4.0.2 - Mac"]}
+      test = Weary::Request.new("http://foo.bar", :get, {:headers => head})
+      test.headers.should == head
+    end
+
+    it 'sets a following value for redirection' do
+      test = Weary::Request.new("http://foo.bar", :get, {:no_follow => true})
+      test.follows?.should == false
+      test = Weary::Request.new("http://foo.bar", :get, {:no_follow => false})
+      test.follows?.should == true
+      test = Weary::Request.new("http://foo.bar", :get)
+      test.follows?.should == true
+    end
+    
+    it 'uses the #with hash to create a URI query string if the method is a GET' do
+      test = Weary::Request.new("http://foo.bar/path/to/something")
+      test.with = {:name => "markwunsch", :title => "awesome"}
+      test.uri.query.should == test.with
+    end
   end
+    
+  describe 'Perform' do
+    # These tests reveal tight coupling with Response API, which may or may not be a good thing
+    
+    after do
+      FakeWeb.clean_registry
+    end
+    
+    it 'performs the request and gets back a response' do
+      hello = "Hello from FakeWeb"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :body => hello)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      response = test.perform
+      response.class.should == Weary::Response
+      response.body.should == hello
+    end
+      
+    it 'follows redirection' do
+      hello = "Hello from FakeWeb"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
+      FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      response = test.perform
+      response.body.should == hello
+    end
+    
+    it 'will not follow redirection if disabled' do
+      hello = "Hello from FakeWeb"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
+      FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
+      
+      test = Weary::Request.new("http://markwunsch.com", :get, :no_follow => true)
+      response = test.perform
+      response.code.should == 301
+    end
+    
+    it 'passes the response into a callback' do
+      hello = "Hello from FakeWeb"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :body => hello)
+      response_body = ""
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      test.perform do |response|
+        response_body = response.body
+      end
+      
+      response_body.should == hello
+    end
+    
+    it 'performs the callback even when redirected' do
+      hello = "Hello from FakeWeb"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
+      FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
+      
+      response_body = ""
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      test.perform do |response|
+        response_body = response.body
+      end
+      
+      response_body.should == hello
+    end
+    
+    it 'authorizes with basic authentication' do
+      message = 'You are authorized to do that.'
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(401))
+      FakeWeb.register_uri(:get, "http://mark:secret@markwunsch.com", :body => message)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      response = test.perform
+      response.code.should == 401
+      response.body.should_not == message
+      test.credentials = {:username => 'mark', :password => 'secret'}
+      response = test.perform
+      response.code.should == 200
+      response.body.should == message
+    end
+    
+    it 'still authorizes correctly if redirected' do
+      message = 'You are authorized to do that.'
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(401))
+      FakeWeb.register_uri(:get, "http://mark:secret@markwunsch.com", :status => http_status_message(301), :Location => 'http://markwunsch.net')
+      FakeWeb.register_uri(:get, "http://markwunsch.net", :status => http_status_message(401))
+      FakeWeb.register_uri(:get, "http://mark:secret@markwunsch.net", :body => message)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      test.credentials = {:username => 'mark', :password => 'secret'}
+      response = test.perform
+      response.code.should == 200
+      response.body.should == message
+    end
+    
+    it 'converts parameters to url query strings' do
+      params = {:id => 'mark', :message => 'hello'}
+      message = "Using FakeWeb with params of #{params.to_params}"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(403))
+      FakeWeb.register_uri(:get, "http://markwunsch.com?#{params.to_params}", :body => message)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      test.with = params
+      response = test.perform
+      response.body.should == message
+    end
+    
+    it 'sends query strings correctly when redirected' do
+      params = {:id => 'mark', :message => 'hello'}
+      message = "Using FakeWeb with params of #{params.to_params}"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(403))
+      FakeWeb.register_uri(:get, "http://markwunsch.net", :status => http_status_message(403))
+      FakeWeb.register_uri(:get, "http://markwunsch.com?#{params.to_params}", :status => http_status_message(301), :Location => 'http://markwunsch.net')
+      FakeWeb.register_uri(:get, "http://markwunsch.net?#{params.to_params}", :body => message)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      test.with = params
+      response = test.perform
+      response.code.should == 200
+    end
+    
+    it 'converts parameters to request body on post' do
+      params = {:id => 'mark', :message => 'hello'}
+      message = "Using FakeWeb with params of #{params.to_params}"
+      FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(403))
+      FakeWeb.register_uri(:post, "http://markwunsch.com", :body => message)
+      
+      test = Weary::Request.new("http://markwunsch.com")
+      test.via = :post
+      test.with = params
+      response = test.perform
+      response.code.should == 200
+      response.body.should == message
+      
+      # No way of testing Request bodies with FakeWeb as of 1.2.7 
+    end    
   
-  # replace with FakeWeb
-  it "should follow redirects" do
-    test = Weary::Request.new("http://foo.bar")
-    method = test.method   
-    response = Weary::Response.new(mock_response(method, 301, {'Location' => 'http://bar.foo'}), method)
-    response.stub!(:follow_redirect).and_return Weary::Response.new(mock_response(method, 200, {}), method)
-    test.stub!(:perform).and_return(response)
-    test.perform.code.should == 301
-    test.perform.redirected?.should == true
-    test.perform.follow_redirect.code.should == 200
-    # not exactly kosher.
+    describe 'Non-Blocking, Threaded' do
+      # Not exactly sure the best way to test these
+      
+      it 'creates a new thread to perform the request' do
+        hello = "Hello from FakeWeb"
+        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => hello)
+
+        test = Weary::Request.new("http://markwunsch.com")
+        test.perform!.value.body.should == hello
+      end
+      
+      it "sets its callback" do
+        msg = "You did it!"
+        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
+        test = Weary::Request.new("http://markwunsch.com")
+        body = ""
+
+        thread = test.perform! do |r|
+          body = r.body
+        end
+        body = thread.value.body
+        body.should == msg
+      end
+    end
   end
   
-  it "should prepare an oauth scheme if a token is provided" do
-    consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
-    token = OAuth::AccessToken.new(consumer, "token", "secret")
-    test = Weary::Request.new("http://foo.bar", :post, {:oauth => token})
-    test.send(:request).oauth_helper.options[:token].should == token
-    # seems a good a way as any to test if OAuth helpers have been added to the request
+  describe 'Callbacks' do
+    after do
+      FakeWeb.clean_registry
+    end
+    
+    describe 'on_complete' do
+      it 'stores the callback' do
+        test = Weary::Request.new("http://markwunsch.com")
+        test.on_complete do
+          'hello'
+        end
+        test.on_complete.call.should == 'hello'
+      end
+      
+      it 'accepts a block, and the block becomes the callback' do
+        msg = "You did it!"
+        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
+        test = Weary::Request.new("http://markwunsch.com")
+        body = ""
+
+        test.on_complete do |response|
+          body = response.body
+        end
+
+        test.perform
+        body.should == msg
+      end
+
+      it 'is overriden when a block is passed to the perform method' do
+        msg = "You did it!"
+        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
+        test = Weary::Request.new("http://markwunsch.com")
+        body = ""
+
+        test.on_complete do |response|
+          body = response.body
+        end
+        test.perform
+        body.should == msg
+
+        test.perform do |response|
+          body = 'Now it is different'
+        end
+
+        body.should == 'Now it is different'
+      end
+    end
+    
+    describe 'before_send' do
+      it 'stores the callback' do
+        test = Weary::Request.new("http://markwunsch.com")
+        test.before_send do
+          'hello'
+        end
+        test.before_send.call.should == 'hello'
+      end
+      
+      it 'accepts a block, and the block becomes the callback' do
+        msg = "You did it!"
+        FakeWeb.register_uri(:get, "http://markwunsch.com", :body => msg)
+        test = Weary::Request.new("http://markwunsch.com")
+        body = ""
+
+        test.before_send do
+          body = msg
+        end
+        body.should_not == msg
+        test.perform
+        body.should == msg
+      end
+      
+      it 'takes the Request as an argument, so it can be manipulate before sending' do
+        hello = "Hello from FakeWeb"
+        FakeWeb.register_uri(:get, "http://markwunsch.com", :status => http_status_message(301), :Location => 'http://redirected.com')
+        FakeWeb.register_uri(:get, "http://redirected.com", :body => hello)
+        
+        test = Weary::Request.new("http://markwunsch.com")
+        test.before_send do |req|
+          req.follows = false
+        end
+        
+        test.perform.code.should == 301
+      end
+    end
   end
   
 end