weary 0.7.2 → 1.0.0.rc1

data/spec/weary/resource_spec.rb

@@ -1,256 +1,256 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'spec_helper'
 
 describe Weary::Resource do
-  before do
-    @test = Weary::Resource.new("test")
+  describe "#url" do
+    it "is an Addressable::Template" do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = Weary::Resource.new "GET", url
+      resource.url.should be_an Addressable::Template
+    end
+
+    it "gets a previously set url" do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = Weary::Resource.new "GET", url
+      resource.url.pattern.should eql url
+    end
+
+    it "sets a new url" do
+      resource = Weary::Resource.new "GET", "http://api.twitter.com/version/users/show.json"
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource.url url
+      resource.url.pattern.should eql url
+    end
+
+    it "accepts variables in the url" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = Weary::Resource.new "GET", url
+      resource.url.variables.should include 'user'
+    end
+
+    it "accepts variables in the sinatra style" do
+      url = "http://github.com/api/v2/json/repos/show/:user/:repo"
+      resource = Weary::Resource.new "GET", url
+      resource.url.variables.should include 'user'
+    end
+  end
+
+  describe "#optional" do
+    it "creates a list of optional parameters for the request" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.optional :login, :token
+      resource.optional.length.should be 2
+    end
+  end
+
+  describe "#required" do
+    it "creates a list of required parameters for the request" do
+      url = "http://api.twitter.com/version/users/show.{format}"
+      resource = described_class.new "GET", url
+      resource.required :screen_name
+      resource.required.length.should be 1
+    end
+  end
+
+  describe "#defaults" do
+    it "sets some default values for parameters" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.defaults :user => "mwunsch", :repo => "weary"
+      resource.defaults.should have_key :user
+    end
+  end
+
+  describe "#headers" do
+    it "prepares headers for the request" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.headers 'User-Agent' => 'RSpec'
+      resource.headers.should eql 'User-Agent' => 'RSpec'
+    end
+  end
+
+  describe "#use" do
+    it "adds a middleware to the stack and passes them onto the request" do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = described_class.new "GET", url
+      resource.use Rack::Lobster
+      stack = resource.request.instance_variable_get :@middlewares
+      stack.flatten.should include Rack::Lobster
+    end
   end
-  
-  describe 'Name' do
-    it 'has a name' do
-      @test.name.should == "test"
-    end
-    
-    it 'replaces the whitespace in the name' do
-      @test.name = " test number two"
-      @test.name.should == "test_number_two"
-      @test.name = "test\nthree"
-      @test.name.should == "test_three"
-    end
-    
-    it 'downcases everything' do
-      @test.name = "TEST"
-      @test.name.should == "test"
-    end
-    
-    it 'is a string' do
-      @test.name = :test
-      @test.name.should == "test"
+
+  describe "#user_agent" do
+    it "updates the #headers hash with a User-Agent" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.user_agent 'RSpec'
+      resource.headers.should eql 'User-Agent' => 'RSpec'
+    end
+  end
+
+  describe "#basic_auth!" do
+    subject do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = described_class.new "GET", url
+    end
+
+    it "prepares the request to accept username and password parameters" do
+      subject.basic_auth!
+      req = subject.request :username => "mwunsch", :password => "secret"
+      req.basic_auth.should be
+    end
+
+    it "allows the default credential params to be overriden" do
+      subject.basic_auth! :login, :token
+      req = subject.request :login => "mwunsch", :token=> "secret"
+      req.basic_auth.should be
+    end
+
+    it "permits the credentials to be completely optional" do
+      subject.basic_auth!
+      req = subject.request
+      req.basic_auth.should_not be
     end
   end
-  
-  describe 'Via' do
-    it 'defaults as a GET request' do
-      @test.via.should == :get
+
+  describe "#oauth!" do
+    subject do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = described_class.new "GET", url
+    end
+
+    it "prepares the request to accept consumer_key and token parameters" do
+      subject.oauth!
+      req = subject.request :consumer_key => "key", :token => "access"
+      req.oauth.should be
     end
 
-    it 'normalizes HTTP request verbs' do
-      @test.via = "POST"
-      @test.via.should == :post
+    it "allows the default oauth params to be overriden" do
+      subject.oauth! :consumer, :access_token
+      req = subject.request :consumer => "key", :access_token => "access"
+      req.oauth.should be
     end
 
-    it 'remains a GET if the input verb is not understood' do
-      @test.via = "foobar"
-      @test.via.should == :get
+    it "permits the oauth parameters to be completely optional" do
+      subject.oauth!
+      req = subject.request
+      req.oauth.should_not be
     end
   end
-  
-  describe 'Parameters' do
-    it 'is an array of params' do
-      @test.with = [:uid, :date]
-      @test.with.should == [:uid, :date]
-      @test.with = :user, :message
-      @test.with.should == [:user, :message]
-    end
-    
-    it 'stores the params as symbols' do
-      @test.with = "user", "message"
-      @test.with.should == [:user, :message]
-    end
-    
-    it 'defines required params' do
-      @test.requires = [:uid, :date]
-      @test.requires.should == [:uid, :date]
-      @test.requires = :user, :message
-      @test.requires.should == [:user, :message]
-    end
-    
-    it 'stores the required params as symbols' do
-      @test.requires = "user", "message"
-      @test.requires.should == [:user, :message]
-    end
-    
-    it 'required params inherently become passed params' do
-      @test.requires = [:user, :message]
-      @test.requires.should == [:user, :message]
-      @test.with.should == [:user, :message]
-    end
-    
-    it 'merges required params with optional params' do
-      @test.with = [:user, :message]
-      @test.requires = [:id, :time]
-      @test.with.should == [:user, :message, :id, :time]
-      @test.requires.should == [:id, :time]
-    end
-    
-    it 'optional params should merge with required params' do
-      @test.requires = [:id, :time]
-      @test.with.should == [:id, :time]
-      @test.with = [:user, :message]
-      @test.requires.should == [:id, :time]
-      @test.with.should == [:id, :time, :user, :message]
+
+  describe "#authenticates?" do
+    subject do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = described_class.new "GET", url
+    end
+
+    it "is false when the resource does not accept authentication" do
+      subject.authenticates?.should be_false
+    end
+
+    it "is true when basic authentication has been declared" do
+      subject.basic_auth!
+      subject.authenticates?.should be_true
+    end
+
+    it "is true when OAuth has been declared" do
+      subject.oauth!
+      subject.authenticates?.should be_true
     end
   end
-  
-  describe 'Authenticates' do
-    it 'defaults to false' do
-      @test.authenticates?.should == false
-    end
-    
-    it 'is always set to a boolean' do
-      @test.authenticates = "foobar"
-      @test.authenticates?.should == true
-      @test.authenticates = "false"
-      @test.authenticates?.should == true
+
+  describe "#expected_params" do
+    it "contains the request's expected parameters" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.required :foo
+      resource.optional :baz
+      resource.expected_params.size.should be 2
+    end
+
+    it "contains the keys of the resource's defaults" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.defaults :foo => "baz"
+      resource.expected_params.should include "foo"
     end
   end
-  
-  describe 'Redirection' do
-    it 'defaults to true' do
-      @test.follows?.should == true
-    end
-    
-    it 'is always set to a boolean' do
-      @test.follows = "foobar"
-      @test.follows?.should == true
-      @test.follows = "false"
-      @test.follows?.should == true
-      @test.follows = false
-      @test.follows?.should == false
+
+  describe "#expects?" do
+    it "is true if the parameter is expected by the request" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.required :foo
+      resource.should be_expects :foo
+    end
+
+    it "is false if the parameter is unexpected" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.required :foo
+      resource.should_not be_expects :baz
     end
   end
-  
-  describe 'URL' do
-    it 'is a valid URI' do
-      @test.url = 'http://foo.bar/foobar'
-      @test.url.scheme.should == 'http'
-      @test.url.host.should == 'foo.bar'
-      @test.url.path.should == '/foobar'
-      @test.url.normalize.to_s.should == 'http://foo.bar/foobar'
-    end
-    
-    it "rejects fake url's" do
-      lambda { @test.url = "this is not really a url" }.should raise_error
+
+  describe "#requirements" do
+    it "contains required parameters and url keys" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      resource.required :foo
+      resource.requirements.size.should be 3
     end
   end
-  
-  describe 'Request Builder' do
-    before do
-      @test.url = 'http://foo.bar'
-      @test.with = :user, :message
-      @test.headers = {"User-Agent" => Weary::UserAgents["Safari 4.0.2 - Mac"]}
-    end
-    
-    it "merges defaults in with passed params" do
-      params = {:message => "Hello"}
-      defaults = {:user => "me"}
-      @test.setup_parameters(params, defaults).should == {:message => "Hello", :user => "me"}
-      @test.setup_parameters(params).should == {:message => "Hello"}
-    end
-    
-    it 'alerts if a required param is missing' do
-      @test.requires = [:id]
-      params = {:user => "me", :message => "Hello"}
-      lambda { @test.find_missing_requirements(params) }.should raise_error
-    end
-    
-    it 'removes unnecessary parameters' do
-      params = {:message => "Hello", :user => "me", :foo => "bar"}
-      @test.remove_unnecessary_params(params).should == {:message => "Hello", :user => "me"}
-    end
-    
-    it 'prepares param options for the request' do
-      params = {:user => "me", :message => "Hello"}
-      @test.prepare_request_body(params)[:query].should == {:user => "me", :message => "Hello"}
-      @test.prepare_request_body(params).has_key?(:body).should == false
-      @test.via = :post
-      @test.prepare_request_body(params)[:body].should == {:user => "me", :message => "Hello"}
-      @test.prepare_request_body(params).has_key?(:query).should == false
-    end
-    
-    it 'alerts if credentials are missing but authorization is required' do
-      @test.authenticates = true
-      lambda { @test.setup_authentication({}) }.should raise_error
-    end
-    
-    it 'negotiates what form of authentication is used (basic or oauth)' do
-      @test.authenticates = true
-      basic_auth = {:username => "mwunsch", :password => "secret123"}
-      oauth_consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
-      oauth_token = OAuth::AccessToken.new(oauth_consumer, "token", "secret")
-      
-      basic_authentication = @test.setup_authentication({},basic_auth)
-      oauth_authentication = @test.setup_authentication({},oauth_token)
-      
-      basic_authentication.has_key?(:basic_auth).should == true
-      basic_authentication.has_key?(:oauth).should == false
-      basic_authentication[:basic_auth].should == basic_auth
-      
-      oauth_authentication.has_key?(:oauth).should == true
-      oauth_authentication.has_key?(:basic_auth).should == false
-      oauth_authentication[:oauth].should == oauth_token
-    end
-    
-    it 'sets request options' do
-      setup = @test.setup_options({})
-      
-      setup.has_key?(:headers).should == true
-      setup.has_key?(:no_follow).should == false
-      setup[:headers].should == @test.headers
-    end
-    
-    it 'sets redirection following options' do
-      @test.follows = false
-      setup = @test.setup_options({})
-      
-      setup[:no_follow].should == true
-    end
-    
-    it 'sets parameter body options' do
-      params = {:user => "me", :message => "Hello"}
-      setup_get = @test.setup_options(params)
-      
-      setup_get.has_key?(:query).should == true
-      setup_get[:query] == params
-      
-      @test.via = :post
-      setup_post = @test.setup_options(params)
-      
-      setup_post.has_key?(:query).should == false
-      setup_post.has_key?(:body).should == true
-      setup_post[:body].should == params      
-    end
-    
-    it 'sets up authentication options' do
-      @test.authenticates = true
-      basic_auth = {:username => "mwunsch", :password => "secret123"}
-      oauth_consumer = OAuth::Consumer.new("consumer_token","consumer_secret",{:site => 'http://foo.bar'})
-      oauth_token = OAuth::AccessToken.new(oauth_consumer, "token", "secret")
-      setup_basic = @test.setup_options({}, basic_auth)
-      setup_oauth = @test.setup_options({}, oauth_token)
-      
-      setup_basic[:basic_auth].should == basic_auth
-      setup_oauth[:oauth].should == oauth_token
-    end
-    
-    it 'builds a Request' do
-      @test.authenticates = true
-      @test.requires = [:id]
-      params = {:user => "me", :message => "Hello", :bar => "foo"}
-      defaults = {:id => 1234, :foo => "bar"}
-      basic_auth = {:username => "mwunsch", :password => "secret123"}
-      
-      request = @test.build!(params, defaults, basic_auth)
-      
-      request.class.should == Weary::Request
-      request.via.should == :get
-      request.credentials.should == basic_auth
+
+  describe "#meets_requirements?" do
+    it "is true if the set of parameters meet the request requirements" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      hash = { :user => "mwunsch", :repo => "weary" }
+      resource = described_class.new "GET", url
+      resource.should be_meets_requirements hash
+    end
+
+    it "is false if the parameters do not meet requirements" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      hash = { :user => "mwunsch" }
+      resource = described_class.new "GET", url
+      resource.should_not be_meets_requirements hash
     end
   end
-  
-  it 'can convert to a hash' do
-    @test.to_hash.has_key?(:test).should == true
+
+  describe "#request" do
+    it "builds a request object" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      req = resource.request(:repo => "weary", :user => "mwunsch")
+      req.should be_a Weary::Request
+    end
+
+    it "expands templated urls" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      req = resource.request(:repo => "weary", :user => "mwunsch")
+      req.uri.to_s.should eql "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+    end
+
+    it "raises an exception for missing requirements" do
+      url = "http://github.com/api/v2/json/repos/show/{user}/{repo}"
+      resource = described_class.new "GET", url
+      expect { resource.request }.to raise_error Weary::Resource::UnmetRequirementsError
+    end
+
+    it "passes headers along to the request" do
+      url = "http://github.com/api/v2/json/repos/show/mwunsch/weary"
+      resource = described_class.new "GET", url
+      resource.headers 'User-Agent' => 'RSpec'
+      resource.request.headers.should eql 'User-Agent' => 'RSpec'
+    end
+
+    it "passes parameters into the request body" do
+      resource = described_class.new "GET", "http://api.twitter.com/version/users/show.json"
+      resource.required :user_id
+      req = resource.request :user_id => "markwunsch"
+      req.params.should eql "user_id=markwunsch"
+    end
   end
-  
-  
-  
 end