restfulie-nosqlite 1.0.3

data/spec/integration/twitter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'fakeweb'
+
+require File.dirname(__FILE__) + '/twitter'
+
+describe Restfulie do
+
+  TWITTER_ENTRY_POINT = "http://twitter.com/statuses/public_timeline.xml"
+
+  before do
+    FakeWeb.allow_net_connect = false
+    FakeWeb.register_uri(:get, TWITTER_ENTRY_POINT, :response => Responses::Twitter.public_timeline)
+  end
+
+  it "should work with twitter" do
+    twitter = Restfulie.at(TWITTER_ENTRY_POINT).get
+    twitter.resource.statuses[0].user.screen_name.should == "fionnaps"
+  end
+  
+  after do
+    FakeWeb.allow_net_connect = true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+
+require 'restfulie'
+require 'ruby-debug'

data/spec/unit/client/base_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Restfulie do
+
+  it "should re-initiate entire request context when invoking Restfulie.at" do
+    Restfulie.at('http://guilhermesilveira.wordpress.com/').should_not == (Restfulie.at('http://guilhermesilveira.wordpress.com/'))
+  end
+
+end

data/spec/unit/client/cache/fake_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Cache::Fake do
+  
+  it "should always retrieve nil, even if it was put" do
+    req = Object.new
+    url = Object.new
+    response = mock Net::HTTPResponse
+    cache = Restfulie::Client::Cache::Fake.new
+    cache.put(url, req, response)
+    cache.get(url, req).should be_nil
+  end
+  
+  it "putting should return the response" do
+    req = Object.new
+    url = Object.new
+    response = mock Net::HTTPResponse
+    cache = Restfulie::Client::Cache::Fake.new
+    cache.put(url, req, response).should == response
+  end
+  
+end
+

data/spec/unit/client/cache/http_ext_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+class HashResponse
+  include Restfulie::Client::HTTP::ResponseStatus
+  attr_accessor :code
+end
+
+describe Restfulie::Client::HTTP::ResponseStatus do
+  
+  def check_complies_with(from, to, method)
+    o = HashResponse.new
+    (from..to).each do |code|
+      o.code = code
+      o.send(method).should be_true
+    end
+    [from-1,to+1].each do |code|
+      o.code = code
+      o.send(method).should be_false
+    end
+  end
+  
+  it "should return successful for 200~299" do
+    check_complies_with(200, 299, :is_successful?)
+  end
+
+  it "should return informational for 100~199" do
+    check_complies_with(100, 199, :is_informational?)
+  end
+
+  it "should return redirection for 300~399" do
+    check_complies_with(300, 399, :is_redirection?)
+  end
+
+  it "should return redirection for 400~499" do
+    check_complies_with(400, 499, :is_client_error?)
+  end
+
+  it "should return redirection for 500~599" do
+    check_complies_with(500, 599, :is_server_error?)
+  end
+
+end
+
+describe Restfulie::Client::HTTP::ResponseStatus do
+  
+  before do
+    @response = mock Net::HTTPResponse
+    @response.stub(:verb).and_return(:get)
+    @response.extend Restfulie::Client::HTTP::ResponseCacheCheck
+  end
+
+  context "while retrieving cache information" do
+    
+    it "should invoke may_ache_field with cache control" do
+      response = Object.new
+      controls = [:cache_headers]
+      @response.should_receive(:headers).and_return('cache-control' => controls)
+      @response.should_receive(:may_cache_field?).with(controls).and_return(response)
+      @response.may_cache?.should == response
+    end
+    
+    it "should not cache if Cache-Control is not available" do
+      @response.may_cache_field?(nil).should be_false
+    end
+
+    it "should not cache if Cache-Control's max-age is not available" do
+      @response.may_cache_field?('s-maxage=100000').should be_false
+    end
+
+    it "should cache if finds max-age" do
+      @response.may_cache_field?('max-age=100000, please-store').should be_true
+    end
+  
+    it "should not cache if Cache-Control's no-store is set" do
+      @response.may_cache_field?('max-age=100000, no-store').should be_false
+    end
+  
+    it "should use all headers if received more than one header" do
+      @response.may_cache_field?(['max-age=100000', 'no-store']).should be_false
+    end
+  
+    it "should extract max-age from start" do
+      @response.value_for('max-age=100', /^max-age=(\d+)/).should == "max-age=100"
+    end
+  
+    it "should extract max-age from the middle" do
+      @response.value_for('a=b,max-age=100', /^max-age=(\d+)/).should == "max-age=100"
+    end
+  
+    it "should extract max-age from the middle even with whitespace" do
+      @response.value_for('a=b, max-age=100', /^max-age=(\d+)/).should == " max-age=100"
+    end
+  
+    it "should return nil if not found" do
+      @response.value_for('a=b,s-max-age=100', /^max-age=(\d+)/).should be_nil
+    end
+  end
+  
+  context "when retrieving caching values" do
+    
+    it "should return 0 if the header value is not present" do
+      @response.should_receive(:header_value_from).with('cache-control', /^\s*max-age=(\d+)/).and_return(nil)
+      @response.cache_max_age.should == 0
+    end
+    
+    it "should return the parsed value if the header value is not present" do
+      @response.should_receive(:header_value_from).with('cache-control', /^\s*max-age=(\d+)/).and_return("57")
+      @response.cache_max_age.should == 57
+    end
+    
+    it "should return nothing if the header is not there" do
+      field = Object.new
+      @response.should_receive(:headers).and_return('header' => field)
+      @response.should_receive(:value_for).with(field, 'expression').and_return(nil)
+      @response.header_value_from('header','expression').should be_nil
+    end
+    
+    it "should return the matching expression when extracting the header value" do
+      field = Object.new
+      @response.should_receive(:headers).and_return('header' => field)
+      @response.should_receive(:value_for).with(field, /as(df)/).and_return("asdf")
+      @response.header_value_from('header', /as(df)/).should == "df"
+    end
+    
+  end
+  
+  context "when retrieving caching values" do
+    it "should expire the response if there is no date" do
+      @response.should_receive(:headers).and_return('date' => nil)
+      @response.should be_has_expired_cache
+    end
+
+    it "should expire the response if its in the past with" do
+      Time.should_receive(:now).and_return(201)
+      Time.should_receive(:rfc2822).and_return(100)
+      @response.should_receive(:cache_max_age).and_return(100)
+      @response.stub(:headers).and_return('date' => [Object.new])
+      @response.has_expired_cache?.should be_true
+    end
+
+    it "should expire the response if its in the future with" do
+      Time.should_receive(:now).and_return(199)
+      Time.should_receive(:rfc2822).and_return(100)
+      @response.should_receive(:cache_max_age).and_return(100)
+      @response.stub(:headers).and_return('date' => [Object.new])
+      @response.has_expired_cache?.should be_false
+    end
+
+  end
+
+  context "when checking response variants" do
+    
+    before do
+      @request = mock Net::HTTPResponse
+      @request.extend Restfulie::Client::HTTP::ResponseCacheCheck
+    end
+    
+    it "should answer with the header from the request matching vary header" do
+      @response.stub(:headers).and_return('vary' => 'accept')
+      @request.stub(:[]).with('accept').and_return('application/xml')
+      @response.vary_headers_for(@request).should == ['application/xml']
+    end
+
+    it "should answer with all headers from the request matching vary header" do
+      @response.stub(:headers).and_return('vary' => 'accept, accept-language')
+      @request.stub(:[]).with('accept').and_return('application/xml')
+      @request.stub(:[]).with('accept-language').and_return('de')
+      @response.vary_headers_for(@request).should == ['application/xml', 'de']
+    end
+
+    it "should answer with nil from the request matching vary header when non-existent" do
+      @response.stub(:headers).and_return('vary' => 'accept, accept-language')
+      @response.stub(:[]).with('vary').and_return('accept, accept-language')
+      @request.stub(:[]).with('accept').and_return(nil)
+      @request.stub(:[]).with('accept-language').and_return('de')
+      @response.vary_headers_for(@request).should == [nil, 'de']
+    end
+    
+    
+  end
+
+end

data/spec/unit/client/cache/restrictions_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Cache::Restrictions do
+
+  it "should cache if the response may be cached" do
+    request = Object.new
+    response = mock(Net::HTTPResponse)
+    response.should_receive(:may_cache?).and_return true
+        
+    Restfulie::Client::Cache::Restrictions.may_cache?(response).should be_true
+  end
+
+  it "should not cache if the response may not be cached" do
+    request = Object.new
+    response = mock(Net::HTTPResponse)
+    response.should_receive(:may_cache?).and_return false
+        
+    Restfulie::Client::Cache::Restrictions.may_cache?(response).should be_false
+  end
+
+  it "should not cache for nil" do
+    Restfulie::Client::Cache::Restrictions.may_cache?(nil).should be_false
+  end
+end

data/spec/unit/client/configuration_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Restfulie::Client::Configuration::Test
+  class XmlRepresentation; end
+end
+
+describe Restfulie::Client::Configuration do
+
+  let(:configuration) { Restfulie::Client::Configuration.new }
+
+  it "should be development as default environment" do
+    configuration.environment.should equal :development    
+  end
+  
+  it "should be a empty string as default entry point" do
+    configuration.entry_point.should eql ''
+  end
+
+  it "should be a empty hash as default representations" do
+    configuration.representations.should == {}
+  end
+  
+  it "should allow to set the test environment" do
+    configuration.environment = :test
+    configuration.environment.should equal :test
+  end
+  
+  it "should allow a xml representation" do
+    configuration.representations['application/xml'] = Restfulie::Client::Configuration::Test::XmlRepresentation
+    configuration.representations['application/xml'].should == Restfulie::Client::Configuration::Test::XmlRepresentation    
+  end
+  
+  it 'should allow change values for many environments' do
+    configuration.entry_point = "http://foo.com/bar"
+    configuration.entry_point.should == 'http://foo.com/bar'
+        
+    configuration.environment = :test
+    
+    configuration.entry_point.should be_empty
+    configuration.representations.should be_empty
+    
+    configuration.entry_point = "http://bar.com/foo"
+    
+    configuration.representations['application/xml'] = Restfulie::Client::Configuration::Test::XmlRepresentation
+    
+    configuration.environment = :development
+    configuration.entry_point.should == 'http://foo.com/bar'
+    
+    configuration.environment = :test
+    configuration.entry_point.should == 'http://bar.com/foo'
+  end
+
+end
+

data/spec/unit/client/ext/open_search_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'medie'
+
+describe Medie::OpenSearch::Descriptor do
+   
+  context "unmarshalling one url documents" do
+  
+    before do
+      xml = '<?xml version="1.0" encoding="UTF-8"?>
+      <OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
+        <ShortName>Restbuy</ShortName>
+        <Description>Restbuy search engine.</Description>
+        <Tags>restbuy</Tags>
+        <Contact>admin@restbuy.com</Contact>
+        <Url type="application/atom+xml"  template="http://localhost:3000/products?q={searchTerms}&amp;pw={startPage?}&amp;format=atom" />
+      </OpenSearchDescription>'
+      @descriptor = Medie::OpenSearch::Driver.new.unmarshal(xml)
+    end
+  
+    it "should unmarshall opensearch xml descriptions" do
+      @descriptor.use("application/atom+xml").host.should == URI.parse("http://localhost:3000/products")
+      @descriptor.use("application/atom+xml").params_pattern.should == "q={searchTerms}&pw={startPage?}&format=atom"
+      @descriptor.use("application/atom+xml").headers["Accept"].should == "application/atom+xml"
+    end
+  
+  end
+
+end

data/spec/unit/client/feature/conneg_when_unaccepted_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::ConnegWhenUnaccepted do
+  
+  before do
+    @feature = Restfulie::Client::Feature::ConnegWhenUnaccepted.new
+    @response = mock Net::HTTPResponse
+    @response.stub("headers").and_return("Accept"=>["application/xml"])
+    @request = Object.new
+    @chain = mock Restfulie::Client::StackNavigator
+    @chain.should_receive(:continue).and_return(@response)
+  end
+  
+  context "when executing a request" do
+    
+    it "should not retry execution by default if response code is not 406" do
+      @response.stub(:code).and_return(404)
+      @feature.execute(@chain, @request, {}).should == @response
+    end
+
+    it "should not retry execution if there is no content type agreed on" do
+      @response.stub(:code).and_return(406)
+      Medie.registry.should_receive(:for).with(["application/xml"]).and_return(nil)
+      @feature.execute(@chain, @request, {}).should == @response
+    end
+
+    it "should retry execution by default if response code is 503" do
+      env = {:payload => "my payload"}
+      
+      @response.stub(:code).and_return(406)
+      Medie.registry.should_receive(:for).with(["application/xml"]).and_return("application/xml")
+
+      @request.should_receive(:with).with("Content-type", "application/xml")
+      following = Object.new
+      Restfulie::Client::Feature::SerializeBody.should_receive(:new).and_return(following)
+
+      second_response = mock Net::HTTPResponse
+      following.should_receive(:execute).with(@chain, @request, env.dup.merge(:body => env[:payload])).and_return(second_response)
+      
+      @feature.execute(@chain, @request, env).should == second_response
+    end
+    
+  end
+
+end

data/spec/unit/client/feature/open_search/pattern_matcher_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::OpenSearch::PatternMatcher do
+  
+  context "matching patterns" do
+  
+    it "should unmarshall opensearch xml descriptions" do
+      pattern = "q={searchTerms}&pw={startPage?}&format=atom"
+      matcher = Restfulie::Client::Feature::OpenSearch::PatternMatcher.new
+      matcher.match({:searchTerms => 12, :startPage => 13},pattern).should == "q=12&pw=13&format=atom"
+    end
+  
+    it "should reset optional patterns" do
+      pattern = "q={searchTerms}&pw={startPage?}&format=atom"
+      matcher = Restfulie::Client::Feature::OpenSearch::PatternMatcher.new
+      matcher.match({:searchTerms => 12},pattern).should == "q=12&pw=&format=atom"
+    end
+  
+  end
+
+end

data/spec/unit/client/feature/rescue_exception_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::RescueException do
+  
+  before do
+    @feature = Restfulie::Client::Feature::RescueException.new
+    @request = Object.new
+    @chain = mock Restfulie::Client::StackNavigator
+  end
+  
+  context "when executing a request" do
+    
+    it "should return an exception if something bad occurs" do
+      exception = mock Exception
+      @chain.should_receive(:continue).and_raise(exception)
+      @feature.execute(@chain, @request, {})
+    end
+    
+    it "should return the response if everything goes fine" do
+      response = mock Net::HTTPResponse
+      @chain.should_receive(:continue).and_return(response)
+      @feature.execute(@chain, @request, {}).should == response
+    end
+    
+  end
+
+end

data/spec/unit/client/feature/retry_when_unavailable_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::RetryWhenUnavailable do
+  
+  before do
+    @feature = Restfulie::Client::Feature::RetryWhenUnavailable.new
+    @response = mock Net::HTTPResponse
+    @request = Object.new
+    @chain = mock Restfulie::Client::StackNavigator
+    @chain.should_receive(:continue).and_return(@response)
+  end
+  
+  context "when executing a request" do
+    
+    it "should retry execution by default if response code is 503" do
+      second_response = mock Net::HTTPResponse
+      @chain.should_receive(:continue).with(@request, {}).and_return(second_response)
+      @response.stub(:code).and_return(503)
+      @feature.execute(@chain, @request, {}).should == second_response
+    end
+    
+    it "should not retry execution by default if response code is not 503" do
+      @response.stub(:code).and_return(404)
+      @feature.execute(@chain, @request, {}).should == @response
+    end
+    
+    it "should retry execution with a custom behavior" do
+      def @feature.should_retry?(response, env)
+        env["force_retry"] == true
+      end
+      second_response = mock Net::HTTPResponse
+      @chain.should_receive(:continue).and_return(second_response)
+      @feature.execute(@chain, @request, {"force_retry" => true}).should == second_response
+    end
+    
+  end
+
+end

data/spec/unit/client/feature/verb_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Feature::Verb do
+  
+  before do
+    @request = Object.new
+    @request.extend Restfulie::Client::Feature::Verb
+  end
+  
+  context "when invoking throw error based methods" do
+    
+    it "should invoke throw error and delegate invocations on get" do
+      @request.should_receive(:request).with(:throw_error_request)
+      @request.should_receive(:get).with({:key => :value})
+      @request.get!({:key => :value})
+    end
+    
+    ["head", "delete"].each do |method|
+      it "should invoke throw error and delegate invocations on #{method}" do
+        @request.should_receive(:request).with(:throw_error_request)
+        @request.should_receive(method)
+        @request.send "#{method}!"
+      end
+    end
+
+    ["put", "post", "patch"].each do |method|
+      it "should invoke throw error and delegate invocations on #{method}" do
+        body = "{ 'data' : 'content' }"
+        @request.should_receive(:request).with(:throw_error_request)
+        @request.should_receive(method).with(body)
+        @request.send "#{method}!", body
+      end
+    end
+
+  end
+
+end

data/spec/unit/client/http/link_header_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Restfulie::Client::HTTP::LinkHeader do
+  
+  context "when parsing one link header" do
+    
+    it "returns all the parts if present" do
+      headers = {"link"=>["<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel=\"start\"; type=\"application/xml\""]}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      start = headers.link("start")
+      start.rel.should == "start"
+      start.href.should == "http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north"
+      start.content_type.should == "application/xml"
+    end
+    
+    it "returns empty if one part is not present" do
+      headers = {"link"=>["<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel=\"start\";"]}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      start = headers.link("start")
+      start.content_type.should be_nil
+    end
+    
+    it "returns nil if the link is not present" do
+      headers = {"link"=>["<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel=\"start\""]}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      headers.link("south").should be_nil
+    end
+    
+  end
+
+  context "when parsing multiple link headers" do
+    
+    it "should bring back all of them" do
+      headers = {"link"=>['<http://amundsen.com/examples/mazes/2d/ten-by-ten/0:north>; rel="current",<http://amundsen.com/examples/mazes/2d/ten-by-ten/10:east>; rel="east"']}
+      headers.extend Restfulie::Client::HTTP::LinkHeader
+      headers.links.size.should == 2
+      headers.link("current").should_not be_nil
+      headers.link("east").should_not be_nil
+    end
+    
+  end
+
+end

data/spec/unit/client/mikyung/concatenator_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Restfulie::Client::Mikyung::Concatenator do
+
+  it "should use the content if there are no extra args" do
+    Restfulie::Client::Mikyung::Concatenator.new("alive").content.should == "alive"
+  end
+  
+  it "should concatenate at the end if there is some extra content" do
+    Restfulie::Client::Mikyung::Concatenator.new("alive", Restfulie::Client::Mikyung::Concatenator.new("should")).content.should == "alive should"
+  end
+  
+end
+