abiquo-etk 0.4.13

data/vendor/resourceful-1.0.1/spec/old_acceptance_specs.rb

@@ -0,0 +1,378 @@
+require 'pathname'
+require Pathname(__FILE__).dirname + 'spec_helper'
+require 'resourceful'
+
+require Pathname(__FILE__).dirname + 'acceptance_shared_specs'
+
+
+describe Resourceful do
+
+  describe 'working with a resource' do
+    before do
+      @accessor = Resourceful::HttpAccessor.new
+    end
+
+    it 'should set additional headers on the #get' do
+      resource = @accessor.resource('http://localhost:3000/echo_header')
+      resp = resource.get(:foo => :bar)
+      resp.should be_instance_of(Resourceful::Response)
+      resp.code.should == 200
+      resp.body.should =~ /"HTTP_FOO"=>"bar"/
+    end
+
+    it 'should take an optional default header for reads' do
+      resource = @accessor.resource('http://localhost:3000/echo_header', :foo => :bar)
+      resp = resource.get
+      resp.should be_instance_of(Resourceful::Response)
+      resp.code.should == 200
+      resp.body.should =~ /"HTTP_FOO"=>"bar"/
+    end
+
+    it 'should take an optional default header for writes' do
+      resource = @accessor.resource('http://localhost:3000/echo_header', :foo => :bar)
+      resp = resource.post("data", :content_type => 'text/plain')
+      resp.should be_instance_of(Resourceful::Response)
+      resp.code.should == 200
+      resp.body.should =~ /"HTTP_FOO"=>"bar"/
+    end
+
+    it 'should override the default header with any set on a read action' do
+      resource = @accessor.resource('http://localhost:3000/echo_header', :foo => :bar)
+      resp = resource.get(:foo => :baz)
+      resp.should be_instance_of(Resourceful::Response)
+      resp.code.should == 200
+      resp.body.should =~ /"HTTP_FOO"=>"baz"/
+    end
+
+    it 'should override the default header with any set on a write action' do
+      resource = @accessor.resource('http://localhost:3000/echo_header', :foo => :bar)
+      resp = resource.post("data", :foo => :baz, :content_type => 'text/plain')
+      resp.should be_instance_of(Resourceful::Response)
+      resp.code.should == 200
+      resp.body.should =~ /"HTTP_FOO"=>"baz"/
+    end
+
+    describe 'redirecting' do
+
+      describe 'registering callback' do
+        before do
+          @resource = @accessor.resource('http://localhost:3000/redirect/301?http://localhost:3000/get')
+        end
+
+        it 'should allow a callback to be registered' do
+          @resource.should respond_to(:on_redirect)
+        end
+
+        it 'should perform a redirect if the callback is true' do
+          @resource.on_redirect { true }
+          @resource.get.should be_successful
+        end
+
+        it 'should not perform the redirect if the callback returns false' do
+          @resource.on_redirect { false }
+          @resource.get
+          @resource.get.should be_redirect
+        end
+      end
+
+      describe 'permanent redirect' do
+        before do
+          @redirect_code = 301
+          @resource = @accessor.resource('http://localhost:3000/redirect/301?http://localhost:3000/get')
+        end
+
+        it_should_behave_like 'redirect'
+
+        it 'should change the effective uri of the resource' do
+          @resource.get
+          @resource.effective_uri.should == 'http://localhost:3000/get'
+        end
+      end
+
+      describe 'temporary redirect' do
+        before do
+          @redirect_code = 302
+          @resource = @accessor.resource('http://localhost:3000/redirect/302?http://localhost:3000/get')
+        end
+
+        it_should_behave_like 'redirect'
+
+        it 'should not change the effective uri of the resource' do
+          @resource.get
+          @resource.effective_uri.should == 'http://localhost:3000/redirect/302?http://localhost:3000/get'
+        end
+
+        describe '303 See Other' do
+          before do
+            @redirect_code = 303
+            @resource = @accessor.resource('http://localhost:3000/redirect/303?http://localhost:3000/method')
+            @resource.on_redirect { true }
+          end
+
+          it 'should GET the redirected resource, regardless of the initial method' do
+            resp = @resource.delete
+            resp.code.should == 200
+            resp.body.should == 'GET'
+          end
+        end
+      end
+
+    end
+
+    describe 'caching' do
+      before do
+        @accessor = Resourceful::HttpAccessor.new(:cache_manager => Resourceful::InMemoryCacheManager.new)
+      end
+
+      it 'should use the cached response' do
+        resource = @accessor.resource('http://localhost:3000/get')
+        resp = resource.get
+        resp.authoritative?.should be_true
+
+        resp2 = resource.get
+        resp2.authoritative?.should be_false
+
+        resp2.should == resp
+      end
+      
+      it 'should not store the representation if the server says not to' do
+        resource = @accessor.resource('http://localhost:3000/header?{Vary:%20*}')
+        resp = resource.get
+        resp.authoritative?.should be_true
+        resp.should_not be_cachable
+
+        resp2 = resource.get
+        resp2.should_not == resp
+      end
+
+      it 'should use the cached version of the representation if it has not expired' do
+        in_an_hour = (Time.now + (60*60)).httpdate
+        uri = URI.escape("http://localhost:3000/header?{Expire: \"#{in_an_hour}\"}")
+
+        resource = @accessor.resource(uri)
+        resp = resource.get
+        resp.should be_authoritative
+
+        resp2 = resource.get
+        resp2.should_not be_authoritative
+        resp2.should == resp
+      end
+
+      it 'should revalidate the cached response if it has expired' do
+        an_hour_ago = (Time.now - (60*60)).httpdate
+        uri = URI.escape("http://localhost:3000/header?{Expire: \"#{an_hour_ago}\"}")
+
+        resource = @accessor.resource(uri)
+        resp = resource.get
+        resp.should be_authoritative
+        resp.should be_expired
+
+        resp2 = resource.get
+        resp2.should be_authoritative
+      end
+
+      it 'should provide the cached version if the server responds with a 304 not modified' do
+        in_an_hour = (Time.now + (60*60)).httpdate
+        uri = URI.escape("http://localhost:3000/modified?#{in_an_hour}")
+
+        resource = @accessor.resource(uri)
+        resp = resource.get
+        resp.should be_authoritative
+
+        resp2 = resource.get(:cache_control => "max-age=0")
+        resp2.should be_authoritative
+        resp2.should == resp
+      end
+
+      it 'should not use a cached document for a resource that has been posted to' do
+        resource = @accessor.resource('http://localhost:3000/get')
+        resp = resource.get
+        resp.authoritative?.should be_true
+
+        resource.post("foo", :content_type => 'text/plain')
+
+        resp2 = resource.get
+        resp2.should_not == resp
+      end
+
+      describe 'Server provided Cache-Control' do
+
+        it 'should cache anything with "Cache-Control: public"' do
+          uri = URI.escape('http://localhost:3000/header?{Cache-Control: public}')
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp2 = resource.get
+          resp2.authoritative?.should be_false
+
+          resp2.should == resp
+        end
+
+        it 'should cache anything with "Cache-Control: private"' do
+          uri = URI.escape('http://localhost:3000/header?{Cache-Control: private}')
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.should be_authoritative
+
+          resp2 = resource.get
+          resp2.should_not be_authoritative
+
+          resp2.should == resp
+        end
+
+        it 'should cache but revalidate anything with "Cache-Control: no-cache"' do
+          uri = URI.escape('http://localhost:3000/header?{Cache-Control: no-cache}')
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp2 = resource.get
+          resp2.authoritative?.should be_true
+        end
+
+        it 'should revalidate anything that is older than "Cache-Control: max-age" value' do
+
+          uri = URI.escape('http://localhost:3000/header?{Cache-Control: max-age=1, Date: "Mon, 04 Aug 2008 18:00:00 GMT"}')
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp.expired?.should be_true
+
+          resp2 = resource.get
+          resp2.authoritative?.should be_true
+        end
+
+        it 'should cache but revalidate anything with "Cache-Control: must-revalidate"' do
+          uri = URI.escape('http://localhost:3000/header?{Cache-Control: must-revalidate}')
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp2 = resource.get
+          resp2.authoritative?.should be_true
+        end
+
+        it 'should not cache anything with "Cache-Control: no-store"' do
+          uri = URI.escape('http://localhost:3000/header?{Cache-Control: no-store}')
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp2 = resource.get
+          resp2.authoritative?.should be_true
+        end
+
+
+      end
+
+      describe 'Client provided Cache-Control' do
+
+        it 'should revalidate anything that is older than "Cache-Control: max-age" value' do
+          a_minute_ago = (Time.now - 60).httpdate
+          uri = URI.escape("http://localhost:3000/header?{Cache-Control: max-age=120, Date: \"#{a_minute_ago}\"}")
+          resource = @accessor.resource(uri)
+          resp = resource.get
+          resp.authoritative?.should be_true
+
+          resp.expired?.should be_false
+
+          resp2 = resource.get({:cache_control => "max-age=1"})
+          resp2.authoritative?.should be_true
+        end
+
+      end
+
+    end
+
+    describe 'authorization' do
+      before do
+        @uri = 'http://localhost:3000/auth?basic'
+      end
+
+      it 'should automatically add authorization info to the request if its available'
+
+      it 'should not authenticate if no auth handlers are set' do
+        resource = @accessor.resource(@uri)
+        lambda {
+          resource.get
+        }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+      end
+
+      it 'should not authenticate if no valid auth handlers are available' do
+        basic_handler = Resourceful::BasicAuthenticator.new('Not Test Auth', 'admin', 'secret')
+        @accessor.auth_manager.add_auth_handler(basic_handler)
+        resource = @accessor.resource(@uri)
+        lambda {
+          resource.get
+        }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+      end
+
+      describe 'basic' do
+        before do
+          @uri = 'http://localhost:3000/auth?basic'
+        end
+
+        it 'should be able to authenticate basic auth' do
+          basic_handler = Resourceful::BasicAuthenticator.new('Test Auth', 'admin', 'secret')
+          @accessor.auth_manager.add_auth_handler(basic_handler)
+          resource = @accessor.resource(@uri)
+          resp = resource.get
+
+          resp.code.should == 200
+        end
+
+        it 'should not keep trying to authenticate with incorrect credentials' do
+          basic_handler = Resourceful::BasicAuthenticator.new('Test Auth', 'admin', 'well-known')
+          @accessor.auth_manager.add_auth_handler(basic_handler)
+          resource = @accessor.resource(@uri)
+
+          lambda {
+            resource.get
+          }.should raise_error(Resourceful::UnsuccessfulHttpRequestError)
+        end
+
+      end
+
+      describe 'digest' do
+        before do
+          @uri = 'http://localhost:3000/auth/digest'
+        end
+
+        it 'should be able to authenticate digest auth' do
+          pending
+          digest_handler = Resourceful::DigestAuthenticator.new('Test Auth', 'admin', 'secret')
+          @accessor.auth_manager.add_auth_handler(digest_handler)
+          resource = @accessor.resource(@uri)
+          resp = resource.get
+
+          resp.code.should == 200
+        end
+
+      end
+
+    end
+
+    describe 'error checking' do
+
+      it 'should raise InvalidResponse when response code is invalid'
+
+      describe 'client errors' do
+
+        it 'should raise when there is one'
+
+      end
+
+      describe 'server errors' do
+
+        it 'should raise when there is one'
+
+      end
+
+    end
+
+  end
+
+end
+

data/vendor/resourceful-1.0.1/spec/resourceful/header_spec.rb

@@ -0,0 +1,153 @@
+require File.dirname(__FILE__) + "/../spec_helper.rb"
+
+module Resourceful
+  describe Header do 
+    def self.should_support_header(name)
+      const_name = name.upcase.gsub('-', '_')
+      meth_name  = name.downcase.gsub('-', '_')
+
+      eval <<-RUBY
+      it "should have constant `#{const_name}` for header `#{name}`" do 
+        Resourceful::Header::#{const_name}.should == '#{name}'
+      end
+
+      it "should have accessor method `#{meth_name}` for header `#{name}`" do 
+        Resourceful::Header.new.should respond_to(:#{meth_name})
+      end
+
+    RUBY
+    end
+
+    should_support_header('Accept')
+    should_support_header('Accept-Charset')
+    should_support_header('Accept-Encoding')
+    should_support_header('Accept-Language')
+    should_support_header('Accept-Ranges')
+    should_support_header('Age')
+    should_support_header('Allow')
+    should_support_header('Authorization')
+    should_support_header('Cache-Control')
+    should_support_header('Connection')
+    should_support_header('Content-Encoding')
+    should_support_header('Content-Language')
+    should_support_header('Content-Length')
+    should_support_header('Content-Location')
+    should_support_header('Content-MD5')
+    should_support_header('Content-Range')
+    should_support_header('Content-Type')
+    should_support_header('Date')
+    should_support_header('ETag')
+    should_support_header('Expect')
+    should_support_header('Expires')
+    should_support_header('From')
+    should_support_header('Host')
+    should_support_header('If-Match')
+    should_support_header('If-Modified-Since')
+    should_support_header('If-None-Match')
+    should_support_header('If-Range')
+    should_support_header('If-Unmodified-Since')
+    should_support_header('Keep-Alive')
+    should_support_header('Last-Modified')
+    should_support_header('Location')
+    should_support_header('Max-Forwards')
+    should_support_header('Pragma')
+    should_support_header('Proxy-Authenticate')
+    should_support_header('Proxy-Authorization')
+    should_support_header('Range')
+    should_support_header('Referer')
+    should_support_header('Retry-After')
+    should_support_header('Server')
+    should_support_header('TE')
+    should_support_header('Trailer')
+    should_support_header('Transfer-Encoding')
+    should_support_header('Upgrade')
+    should_support_header('User-Agent')
+    should_support_header('Vary')
+    should_support_header('Via')
+    should_support_header('Warning')
+    should_support_header('WWW-Authenticate')
+
+
+    it "should be instantiatable w/ single valued header fields" do 
+      Header.new('Host' => 'foo.example').
+        host.should eql('foo.example')
+    end
+
+    it "should gracefully handle repeated values for single valued header fields" do 
+      lambda {
+        Header.new('Host' => ['foo.example', 'bar.example'])
+      }.should raise_error(ArgumentError, 'Host field may only have one value')
+    end
+
+    it "should provide #each_fields to iterate through all header fields and values as strings" do 
+      field_names = []
+      Header.new('Accept' => "this", :content_type => "that", 'pragma' => 'test').each_field do |fname, _|
+        field_names << fname
+      end
+
+      field_names.should include('Accept')
+      field_names.should include('Content-Type')
+      field_names.should include('Pragma')
+      field_names.should have(3).items
+    end
+
+    it "should provide #to_hash as a way to dump the header fields" do 
+      Header.new('Accept' => "this", :content_type => "that", 'date' => 'today').to_hash.tap do |h|
+        h.should have_pair('Accept', ['this'])
+        h.should have_pair('Content-Type', 'that')
+        h.should have_pair('Date', 'today')
+      end
+    end
+
+    it "should provide a list of hop-by-hop fields" do
+      Header.header_field('X-Hop-By-Hop-Header', :hop_by_hop => true)
+      Header.hop_by_hop_fields.should include('X-Hop-By-Hop-Header')
+    end
+
+    it "should provide a list of not modified fields" do
+      Header.header_field('X-Dont-Modify-Me', :modifiable => false)
+      Header.non_modifiable_fields.should include('X-Dont-Modify-Me')
+    end
+
+    describe "multi-valued fields" do
+      it "should be instantiatable w/ repeated multi-valued header fields" do
+        Header.new('Accept' => ['application/foo', 'application/bar']).
+          accept.should eql(['application/foo', 'application/bar'])
+      end
+
+      it "should be instantiatable w/ repeated multi-valued header fields w/ multiple values" do
+        Header.new('Accept' => ['application/foo, application/bar', 'text/plain']).
+          accept.should eql(['application/foo', 'application/bar', 'text/plain'])
+      end
+
+      it "should be instantiatable w/ multi-valued header fields w/ multiple values" do
+        Header.new('Accept' => 'application/foo, application/bar').
+          accept.should eql(['application/foo', 'application/bar'])
+      end
+
+      it "should be instantiatable w/ multi-valued header fields w/ one value" do 
+        Header.new('Accept' => 'application/foo').
+          accept.should eql(['application/foo'])
+      end
+
+      it "should provide values to #each_field as a comma separated string" do 
+        Header.new('Accept' => ['this', 'that']).each_field do |fname, fval|
+          fval.should == 'this, that'
+        end
+      end
+
+      it "should provide #each as a way to iterate through fields as w/ higher level values" do
+        Header.new('Accept' => ['this', 'that']).each do |fname, fval|
+          fval.should == ['this', 'that']
+        end
+      end
+    end
+
+    Spec::Matchers.define :have_pair do |name, value|
+      match do |header_hash|
+        header_hash.has_key?(name)
+        header_hash[name] == value
+      end
+    end    
+  end
+end

data/vendor/resourceful-1.0.1/spec/resourceful/http_accessor_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+require "resourceful/http_accessor"
+
+module Resourceful
+  describe HttpAccessor do 
+    describe "instantiation" do 
+      it "should accept logger option" do 
+        test_logger = stub('logger', :debug => false)
+        ha = HttpAccessor.new(:logger => test_logger)
+        ha.logger.should equal(test_logger)
+      end
+
+      it "should accept array user_agent option" do 
+        ha = HttpAccessor.new(:user_agent => ['foo/3.2', 'bar/1.0'])
+        ha.user_agent_string.should match(/^foo\/3.2 bar\/1.0 Resourceful/)
+      end
+
+      it "should accept string user_agent option" do 
+        ha = HttpAccessor.new(:user_agent => 'foo')
+        ha.user_agent_string.should match(/^foo Resourceful/)
+      end
+
+      it "should accept cache_manager option" do 
+        test_cache_manager = stub('cache_manager', :debug => false)
+        ha = HttpAccessor.new(:cache_manager => test_cache_manager)
+        ha.cache_manager.should equal(test_cache_manager)
+      end
+
+      it "should accept http_adapter option" do 
+        test_http_adapter = stub('http_adapter', :debug => false)
+        ha = HttpAccessor.new(:http_adapter => test_http_adapter)
+        ha.http_adapter.should equal(test_http_adapter)
+      end
+
+      it "should accept authenticator option" do 
+        test_authenticator = stub('authenticator', :debug => false)
+        ha = HttpAccessor.new(:authenticator => test_authenticator)
+        # cannot really be tested safely so we just rely on the fact that the option was accepted
+      end
+
+      it "should accept authenticators option" do 
+        test_authenticator1 = stub('authenticator1', :debug => false)
+        test_authenticator2 = stub('authenticator2', :debug => false)
+        ha = HttpAccessor.new(:authenticator => [test_authenticator1, test_authenticator2])
+        # cannot really be tested safely so we just rely on the fact that the option was accepted
+      end
+
+      it "should reject unrecognized options" do 
+        lambda {
+          HttpAccessor.new(:not_a_valid_option => "this")
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/vendor/resourceful-1.0.1/spec/resourceful/multipart_form_data_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require 'tempfile'
+require "resourceful/multipart_form_data.rb"
+
+describe Resourceful::MultipartFormData do
+
+  before do 
+    @form_data = Resourceful::MultipartFormData.new
+  end
+
+  it "should know its content-type" do 
+    @form_data.content_type.should match(/^multipart\/form-data/i)
+  end
+
+  it "should know its boundary string" do 
+    @form_data.content_type.should match(/; boundary=[0-9A-Za-z]{10,}/i)
+  end
+
+
+  describe "with simple parameters" do 
+
+    it "should all simple parameters to be added" do 
+      @form_data.add(:foo, "testing")
+    end
+
+    it "should render a multipart form-data document when #read is called" do 
+      @form_data.add('foo', 'bar')
+      @form_data.add('baz', 'this')
+      
+      boundary = /boundary=(\w+)/.match(@form_data.content_type)[1]
+      @form_data.read.should eql(<<MPFD[0..-2])
+--#{boundary}\r
+Content-Disposition: form-data; name="foo"\r
+\r
+bar\r
+--#{boundary}\r
+Content-Disposition: form-data; name="baz"\r
+\r
+this\r
+--#{boundary}--
+MPFD
+
+    end
+
+    describe "with file parameter" do 
+      it "should add file parameters to be added" do 
+        Tempfile.open('resourceful-post-file-tests') do |file_to_upload|
+          file_to_upload << "This is a test"
+          file_to_upload.flush
+          
+          @form_data.add_file(:foo, file_to_upload.path)
+        end
+      end
+
+      it "should render a multipart form-data document when #read is called" do 
+        Tempfile.open('resourceful-post-file-tests') do |file_to_upload|
+          file_to_upload << "This is a test"
+          file_to_upload.flush
+          
+          @form_data.add_file(:foo, file_to_upload.path)
+      
+          boundary = /boundary=(\w+)/.match(@form_data.content_type)[1]
+          @form_data.read.should eql(<<MPFD[0..-2])
+--#{boundary}\r
+Content-Disposition: form-data; name="foo"; filename="#{File.basename(file_to_upload.path)}"\r
+Content-Type: application/octet-stream\r
+\r
+This is a test\r
+--#{boundary}--
+MPFD
+
+        end
+      
+      end
+    end
+  end
+end

data/vendor/resourceful-1.0.1/spec/resourceful/resource_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module Resourceful
+  describe Resource do 
+    before do 
+      @http_adapter = stub(:http_adapter)
+      http = Resourceful::HttpAccessor.new(:http_adapter => @http_adapter)
+      @resource = http.resource('http://foo.example')
+    end
+    
+    describe "POSTing" do 
+      it "should use bodies content type as the request content-type if it is known" do 
+        @http_adapter.should_receive(:make_request).with(anything, anything, anything, hash_including('Content-Type' => 'application/x-special-type')).and_return([200, {}, ""])
+        body = stub(:body, :content_type => 'application/x-special-type', :read => "hello there")
+        @resource.post(body)
+      end
+    end
+  
+  end
+end