restfully 0.6.3 → 0.7.0.pre

data/spec/http/error_spec.rb

@@ -1,18 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/../spec_helper')
-describe Restfully::HTTP::Error do
-  it "should have a response reader" do
-    response = mock("restfully response", :status => 404, :body => {'title' => 'Not Found', 'message' => 'The requested resource cannot be found.', 'code' => 404})
-    error = Restfully::HTTP::Error.new(response)
-    error.response.should == response
-  end
-  it "should work properly" do
-    response = mock("restfully response", :status => 404, :body => {'title' => 'Not Found', 'message' => 'The requested resource cannot be found.', 'code' => 404})
-    begin
-      raise Restfully::HTTP::Error.new(response)
-    rescue Restfully::HTTP::Error => e
-      e.response.should == response
-      e.message.should == "404 Not Found. The requested resource cannot be found."
-      e.backtrace.should_not be_empty
-    end
-  end
-end

data/spec/http/headers_spec.rb

@@ -1,17 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/../spec_helper')
-describe Restfully::HTTP::Headers do
-  class IncludeHeadersModule
-    include Restfully::HTTP::Headers
-  end
-  
-  it "should correctly parse headers" do
-    sanitized_headers = IncludeHeadersModule.new.sanitize_http_headers('accept' => 'application/json', :x_remote_ident => 'crohr', 'X_GVI' => 'sid', 'CACHE-CONTROL' => ['max-age=0', 'no-cache'], 'Content-Length' => 22)
-    sanitized_headers.should == {
-      'Accept' => 'application/json',
-      'X-Remote-Ident' => 'crohr',
-      'X-Gvi' => 'sid',
-      'Cache-Control' => 'max-age=0, no-cache',
-      'Content-Length' => 22
-    }
-  end
-end

data/spec/http/request_spec.rb

@@ -1,49 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/../spec_helper')
-describe Restfully::HTTP::Request do
-
-  it "should correctly initialize the attributes" do
-    request = Restfully::HTTP::Request.new(
-      'https://api.grid5000.fr/sid/grid5000?q1=v1&q2=v2', 
-      :headers => {'accept' => 'application/xml', :cache_control => 'max-age=0', 'Content-Type' => 'application/json'}, 
-      :query => {'custom_param1' => [3, 4, 5, 6], 'custom_param2' => 'value_custom_param2'},
-      :body => {"key" => "value"}.to_json
-    )
-    request.uri.should be_a URI
-    request.uri.to_s.should == 'https://api.grid5000.fr/sid/grid5000?q1=v1&q2=v2&custom_param1%5B%5D=3&custom_param1%5B%5D=4&custom_param1%5B%5D=5&custom_param1%5B%5D=6&custom_param2=value_custom_param2'
-    request.uri.query.should == "q1=v1&q2=v2&custom_param1%5B%5D=3&custom_param1%5B%5D=4&custom_param1%5B%5D=5&custom_param1%5B%5D=6&custom_param2=value_custom_param2"
-    request.headers.should == {
-      "Content-Type"=>"application/json", 
-      'Accept' => 'application/xml',
-      'Cache-Control' => 'max-age=0'
-    }
-    request.body.should == {"key" => "value"}
-    request.raw_body.should == "{\"key\":\"value\"}"
-    request.retries.should == 0
-  end
-  
-  it "should accept a URI object as url" do
-    request = Restfully::HTTP::Request.new(uri=URI.parse('https://api.grid5000.fr/sid/grid5000'))
-    request.uri.to_s.should == 'https://api.grid5000.fr/sid/grid5000'
-  end
-  
-  it "should not fail if there are query parameters but no query string in the given URL" do
-    request = Restfully::HTTP::Request.new('https://api.grid5000.fr/grid5000', :query => {:q1 => 'v1'})
-    request.uri.query.should == "q1=v1"
-  end
-  
-  it "should not change the query string if none is given as an option" do
-    request = Restfully::HTTP::Request.new('https://api.grid5000.fr/grid5000?q1=v1&q2=v2')
-    request.uri.to_s.should == 'https://api.grid5000.fr/grid5000?q1=v1&q2=v2'
-    request.headers.should == {}
-  end
-  
-  it "should offer a function to add headers" do
-    request = Restfully::HTTP::Request.new('https://api.grid5000.fr/grid5000?q1=v1&q2=v2', :headers => {:accept => 'application/json'})
-    expected_headers = {
-      'Accept' => 'application/json',
-      'Cache-Control' => 'max-age=0'
-    }
-    request.add_headers(:cache_control => 'max-age=0').should == expected_headers
-    request.headers.should == expected_headers
-  end
-end

data/spec/http/response_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/../spec_helper')
-describe Restfully::HTTP::Response do
-
-  it "should correctly initialize the attributes" do
-    response = Restfully::HTTP::Response.new(404, {:content_type => 'application/json;charset=utf-8'}, '{"property1": "value1", "property2": "value2"}')
-    response.status.should == 404
-    response.headers.should == {
-      'Content-Type' => 'application/json;charset=utf-8'
-    }
-    response.body.should == {
-      'property1' => 'value1',
-      'property2' => 'value2'
-    }
-  end
-  it "should return the unserialized body" do
-    response = Restfully::HTTP::Response.new(404, {:content_type => 'application/json;charset=utf-8'}, '{"property1": "value1", "property2": "value2"}')
-    response.raw_body.should == "{\"property1\": \"value1\", \"property2\": \"value2\"}"
-  end
-end

data/spec/http/rest_client_adapter_spec.rb

@@ -1,35 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/../spec_helper')
-describe Restfully::HTTP::Adapters::RestClientAdapter do
-  it "should correctly get the resource corresponding to the request" do
-    adapter = Restfully::HTTP::Adapters::RestClientAdapter.new("https://api.grid5000.fr", :username => 'crohr', :password => 'password')
-    request = Restfully::HTTP::Request.new('http://api.local/sid/grid5000', :headers => {:accept => 'application/json'}, :query => {:q1 => 'v1'})
-    RestClient::Resource.should_receive(:new).with('http://api.local/sid/grid5000?q1=v1', :password => 'password', :user => 'crohr').and_return(resource = mock("restclient resource"))
-    resource.should_receive(:get).with({:accept => 'application/json'}).and_return(mock("restclient response", :headers => {:content_type => 'application/json;charset=utf-8'}, :to_s => "", :code => 200))
-    response = adapter.get(request)
-    response.status.should == 200
-    response.body.should be_nil
-    response.headers.should == {
-      'Content-Type' => 'application/json;charset=utf-8'
-    }
-  end
-  it "should transform the username option into a user option" do
-    adapter = Restfully::HTTP::Adapters::RestClientAdapter.new("https://api.grid5000.fr", :username => 'crohr', :password => 'password')
-    adapter.options[:user].should == 'crohr'
-    adapter.options[:username].should be_nil
-  end
-  it "should raise a not implemented error when trying to use functions not implemented yet" do
-    require 'restfully/http/adapters/patron_adapter'
-    adapter = Restfully::HTTP::Adapters::PatronAdapter.new("https://api.grid5000.fr")
-    lambda{adapter.put(mock("restfully request"))}.should raise_error NotImplementedError, "PUT is not supported by your adapter."
-  end
-  it "should rescue any RestClient::Exception and correctly populate the response" do
-    res = mock(RestClient::Response, :code => 404, :to_s => '{"message":"whatever"}', :headers => {:content_type => 'application/json;charset=utf-8', :content_length => 22})
-    RestClient::Resource.should_receive(:new).and_raise RestClient::ResourceNotFound.new(res)
-    adapter = Restfully::HTTP::Adapters::RestClientAdapter.new("https://api.grid5000.fr", :username => 'crohr', :password => 'password')
-    response = adapter.get(mock("request", :uri => "uri"))
-    response.status.should == 404
-    response.headers.should == {'Content-Type' => 'application/json;charset=utf-8', 'Content-Length' => 22}
-    response.raw_body.should == '{"message":"whatever"}'
-    response.body.should == {"message"=>"whatever"}
-  end
-end

data/spec/link_spec.rb

@@ -1,61 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/spec_helper')
-
-include Restfully
-describe Link do
-  before do
-    @uri = URI.parse('/x/y/z')
-  end
-  it "should have a rel reader" do
-    link = Link.new
-    link.should_not respond_to(:rel=)
-    link.should respond_to(:rel)
-  end
-  it "should have a href reader" do
-    link = Link.new
-    link.should_not respond_to(:href=)
-    link.should respond_to(:href)
-  end
-  it "should have a title reader" do
-    link = Link.new
-    link.should_not respond_to(:title=)
-    link.should respond_to(:title)
-  end
-  it "should have a errors reader" do
-    link = Link.new
-    link.should_not respond_to(:errors=)
-    link.should respond_to(:errors)
-  end
-  it "should respond to valid?" do
-    link = Link.new
-    link.should respond_to(:valid?)    
-  end
-  it "should respond to resolved?" do
-    link = Link.new("href" => @uri)
-    link.should respond_to(:resolved?)
-  end
-  it "should respond to resolvable?" do
-    link = Link.new
-    link.should respond_to(:resolvable?)
-  end
-  it "by default, should not be resolvable" do
-    link = Link.new
-    link.should_not be_resolvable
-  end
-  it "by default, should not be resolved" do    
-    link = Link.new
-    link.should_not be_resolved
-  end
-  it "should be valid even if the href is ''" do
-    link = Link.new 'rel' => 'collection', 'title' => 'my collection'
-    link.should be_valid
-    link.href.should == URI.parse("")
-  end
-  it "should not be valid if there is no rel" do
-    link = Link.new 'href' => '/', 'title' => 'my collection'
-    link.should_not be_valid
-  end
-  it "should not be valid if the rel is valid but requires a title that is not given" do
-    link = Link.new 'rel' => 'collection', 'href' => '/'
-    link.should_not be_valid
-  end
-end

data/spec/parsing_spec.rb

@@ -1,40 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/spec_helper')
-
-include Restfully::Parsing
-
-describe Restfully::Parsing do
-  class IncludesParsingModule
-    include Restfully::Parsing
-  end
-  it "should make available the serialize and unserialize methods" do
-    klass = IncludesParsingModule.new
-    klass.should respond_to(:unserialize)
-    klass.should respond_to(:serialize)
-  end
-  it "should raise a ParserNotFound error if the object cannot be parsed" do
-    lambda{unserialize("whatever", :content_type => 'unknown')}.should raise_error(Restfully::Parsing::ParserNotFound, "Cannot find a parser to parse 'unknown' content.")
-  end
-  it "should correctly unserialize json content" do
-    object = {'p1' => 'v1'}
-    unserialize(object.to_json, :content_type => 'application/json;charset=utf-8').should == object
-  end
-  it "should correctly serialize an object into json" do
-    object = {'p1' => 'v1'}
-    serialize(object, :content_type => 'application/json;charset=utf-8').should == object.to_json
-  end
-  it "should correctly unserialize text content" do
-    object = "anything"
-    unserialize(object, :content_type => 'text/plain;charset=utf-8').should == object
-  end
-  it "should allow to define its own parser" do
-    Restfully::Parsing::PARSERS.push({
-      :supported_types => "text/unknown",
-      :parse => lambda{|object, options| object.gsub(/x/, "y")},
-      :dump => lambda{|object, options| object.gsub(/y/, "x")}
-    })
-    object = "xyz"
-    parsed = unserialize(object, :content_type => 'text/unknown')
-    parsed.should == "yyz"
-    serialize(parsed, :content_type => 'text/unknown').should == "xxz"
-  end
-end

data/spec/resource_spec.rb

@@ -1,320 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)+'/spec_helper')
-
-include Restfully
-
-describe Resource do
-  before do
-    @logger = Logger.new(STDOUT)
-    @uri = URI.parse("http://api.local/x/y/z")
-  end
-  
-  describe "accessors" do
-    before(:each) do
-      @resource = Resource.new(@uri, @session=mock("session"))
-    end
-    it "should have a reader on the session" do
-      @resource.should_not respond_to(:session=)
-      @resource.session.should == @session
-    end
-    it "should have a reader on the uri" do
-      @resource.should_not respond_to(:uri=)
-      @resource.uri.should == @uri
-    end
-  end
-  
-  describe "reloading" do
-    it "should reload the resource" do
-      resource = Resource.new(@uri, mock('session'))
-      resource.should_receive(:load).with(:reload => true)
-      resource.reload
-    end
-  end
-  
-  describe "loading" do
-    before do
-      @session = Restfully::Session.new(:base_uri => "http://api.local")
-      @raw = {
-        'links' => [
-          {'rel' => 'self', 'href' => '/grid5000/sites/rennes'},
-          {'rel' => 'parent', 'href' => '/grid5000'},
-          {'rel' => 'invalid_rel', 'href' => '/whatever'},
-          {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/status', 'title' => 'status'},
-          {'rel' => 'member', 'href' => '/grid5000/sites/rennes/versions/123', 'title' => 'version'},
-          {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/versions', 'resolvable' => false, 'title' => 'versions'},
-          {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters', 'resolvable' => true, 'resolved' => true, 'title' => 'clusters'},
-          {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/environments/versions/123', 'resolvable' => true, 'resolved' => false, 'title' => 'environments'},
-          {'rel' => 'collection', 'href' => '/has/no/title'} 
-        ],
-        'uid' => 'rennes',
-        'whatever' => 'whatever',
-        'an_array' => [1, 2, 3],
-        'clusters' => {
-          'paradent' => {
-            'uid' => 'paradent',
-            'links' => [
-              {'rel' => 'self', 'href' => '/grid5000/sites/rennes/clusters/paradent'},
-              {'rel' => 'parent', 'href' => '/grid5000/sites/rennes'},
-              {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters/paradent/nodes', 'title' => 'nodes', 'resolvable' => true, 'resolved' => false},
-              {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters/paradent/versions', 'resolvable' => false, 'title' => 'versions'},
-              {'rel' => 'member', 'href' => '/grid5000/sites/rennes/clusters/paradent/versions/123', 'title' => 'version'},
-              {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters/paradent/status', 'title' => 'status'}
-            ],
-            'model' => 'XYZ'
-          },
-          'paramount' => {
-            'uid' => 'paramount',
-            'links' => [
-              {'rel' => 'self', 'href' => '/grid5000/sites/rennes/clusters/paramount'},
-              {'rel' => 'parent', 'href' => '/grid5000/sites/rennes'},
-              {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters/paramount/nodes', 'title' => 'nodes', 'resolvable' => true, 'resolved' => false},
-              {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters/paramount/versions', 'resolvable' => false, 'title' => 'versions'},
-              {'rel' => 'member', 'href' => '/grid5000/sites/rennes/clusters/paramount/versions/123', 'title' => 'version'},
-              {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/clusters/paramount/status', 'title' => 'status'}
-            ],
-            'model' => 'XYZ1b'
-          }
-        }
-      }
-      @response_200 = Restfully::HTTP::Response.new(200, {'Content-Type' => 'application/json;utf-8', 'Content-Length' => @raw.length}, @raw.to_json)
-    end
-    
-    it "should not be loaded in its initial state" do
-      resource = Resource.new(@uri, mock('session'))
-      resource.executed_requests.should == {}
-    end
-    it "should get the raw representation of the resource via the session if it doesn't have it" do
-      resource = Resource.new(@uri, session = mock("session", :logger => Logger.new(STDOUT)))
-      resource.stub!(:define_link) # do not define links
-      session.should_receive(:get).with(@uri, {}).and_return(@response_200)
-      resource.load
-    end
-    it "should get the raw representation of the resource via the session if there are query parameters" do
-      resource = Resource.new(@uri, session = mock("session", :logger => Logger.new(STDOUT)))
-      resource.stub!(:define_link) # do not define links
-      session.should_receive(:get).with(@uri, {:query => {:q1 => 'v1'}}).and_return(@response_200)
-      resource.load(:query => {:q1 => 'v1'})
-    end
-    it "should get the raw representation of the resource if forced to do so" do
-      resource = Resource.new(@uri, session = mock("session", :logger => Logger.new(STDOUT)))
-      resource.stub!(:define_link) # do not define links
-      session.should_receive(:get).with(@uri, {}).and_return(@response_200)
-      resource.load(:reload => true)
-    end
-    it "should correctly define the functions to access simple values" do
-      stub_request(:get, @uri.to_s).to_return(
-        :status => 200,
-        :body => @raw.to_json,
-        :headers => {'Content-Type' => 'application/json', 'Content-Length' => @raw.length}
-      )
-      resource = Resource.new(@uri, @session)
-      resource.stub!(:define_link) # do not define links
-      resource.load
-      resource['whatever'].should == 'whatever'
-      resource.uri.should == @uri
-      resource["uid"].should == 'rennes'
-      resource['an_array'].should be_a(SpecialArray)
-      resource['an_array'].should == [1,2,3]
-    end
-    
-    it "should correctly send custom headers" do
-      stub_request(:get, @uri.to_s).with(:headers => {
-        'User-Agent'=>"Restfully/#{Restfully::VERSION}", 
-        'Accept-Encoding'=>'gzip, deflate', 
-        'Accept'=>'application/json'
-      }).to_return(
-        :status => 200,
-        :body => @raw.to_json,
-        :headers => {'Content-Type' => 'application/json', 'Content-Length' => @raw.length}
-      )
-      resource = Resource.new(@uri, @session)
-      resource.load(:headers => {:accept => 'application/json'})
-    end
-    
-    it "should correctly define a collection link" do
-      resource = Resource.new(@uri, session = mock("session", :get => mock("restfully response", :body => {
-        'links' => [
-          {'rel' => 'self', 'href' => '/grid5000/sites/rennes'},
-          {'rel' => 'collection', 'href' => '/grid5000/sites/rennes/versions', 'resolvable' => false, 'title' => 'versions'}
-        ],
-        'uid' => 'rennes'
-      }, :headers => {}), :logger => @logger))
-      Collection.should_receive(:new).with(@uri.merge('/grid5000/sites/rennes/versions'), session, :title => 'versions').and_return(collection=mock("restfully collection"))
-      resource.load
-      resource.links['versions'].should == collection
-    end
-    it "should NOT update the URI with the self link" do
-      resource = Resource.new(@uri, session = mock("session", :get => mock("restfully response", :body => {
-        'links' => [
-          {'rel' => 'self', 'href' => '/grid5000/sites/rennes'}
-        ],
-        'uid' => 'rennes'
-      }, :headers => {}), :logger => @logger))
-      resource.uri.should == @uri
-      resource.load
-      resource.uri.should == @uri
-    end
-    it "should correctly define a member association" do
-      resource = Resource.new(@uri, session = mock("session", :get => mock("restfully response", :body => {
-        'links' => [
-          {'rel' => 'member', 'href' => '/grid5000/sites/rennes/versions/123', 'title' => 'version'}
-        ],
-        'uid' => 'rennes'
-      }, :headers => {}), :logger => @logger))
-      Resource.should_receive(:new).with(@uri.merge('/grid5000/sites/rennes/versions/123'), session, :title => 'version').and_return(member=mock("restfully resource"))
-      resource.load
-      resource.links['version'].should == member
-    end
-    it "should correctly define a parent association" do
-      resource = Resource.new(@uri, session = mock("session", :get => mock("restfully response", :body => {
-        'links' => [
-          {'rel' => 'self', 'href' => '/grid5000/sites/rennes'},
-          {'rel' => 'parent', 'href' => '/grid5000'}
-        ],
-        'uid' => 'rennes'
-      }, :headers => {}), :logger => @logger))
-      Resource.should_receive(:new).with(@uri.merge('/grid5000'), session).and_return(parent=mock("restfully resource"))
-      resource.load
-      resource.links['parent'].should == parent
-    end
-    it "should ignore bad links" do
-      resource = Resource.new(@uri, session = mock("session", :get => mock("restfully response", :body => {
-        'links' => [
-          {'rel' => 'self', 'href' => '/grid5000/sites/rennes'},
-          {'rel' => 'invalid_rel', 'href' => '/whatever'},
-          {'rel' => 'collection', 'href' => '/has/no/title'} 
-        ],
-        'uid' => 'rennes'
-      }, :headers => {}), :logger => @logger))
-      resource.load
-      resource.links.should be_empty
-    end
-    
-    it "should correctly define the functions to access links [integration test]" do
-      resource = Resource.new(@uri, session = mock("session", :get => @response_200, :logger => @logger))
-      @logger.should_receive(:warn).with(/collection \/has\/no\/title has no title/)
-      @logger.should_receive(:warn).with(/invalid_rel is not a valid link relationship/)
-      resource.load
-      resource.links.keys.should =~ ['versions', 'clusters', 'environments', 'status', 'parent', 'version']
-    end
-    
-    it "should reload the resource if user forces reload [first loading]" do
-      resource = Resource.new(@uri, session = mock("session"))
-      session.should_receive(:get).and_return(response = mock("response", :headers => {}, :body => {}))
-      resource.load(:reload => true, :body => mock("body"))
-    end
-    it "should reload the resource when user forces reload [has been loaded at least once before]" do
-      resource = Resource.new(@uri, session = mock("session"))
-      resource.instance_variable_set "@status", :loaded
-      resource.should_not be_stale
-      resource.should_receive(:executed_requests).at_least(1).and_return({
-        'GET' => {'options' => {:query => {:q=>1}}, 'body' => {'a' => 'b'}}
-      })
-      session.should_receive(:get).and_return(response = mock("response", :headers => {}, :body => {}))
-      resource.load(:reload => true, :query => {:q => 1})
-    end
-  end
-  
-  
-  describe "submitting" do
-    before do
-      @resource = Resource.new(@uri, @session = mock("session", :logger => @logger))
-      @resource.stub!(:http_methods).and_return(['GET', 'POST'])
-      @resource.stub!(:executed_requests).and_return({
-        'GET' => {'headers' => {'Content-Type' => 'application/vnd.fr.grid5000.api.Job+json;level=1,application/json'}, 'options' => {:query => {:q1 => 'v1'}}}
-      })
-    end
-    describe "setting input body and options" do
-      before do
-        @resource.stub!(:reload).and_return(@resource)
-        @response = mock("http response", :status => 200)
-      end
-      it "should raise a NotImplementedError if the resource does not allow POST" do
-        @resource.should_receive(:http_methods).and_return(['GET'])
-        lambda{@resource.submit("whatever")}.should raise_error(NotImplementedError, /POST method is not allowed for this resource/)
-      end
-      it "should raise an error if the input body is nil" do
-        lambda{@resource.submit(nil)}.should raise_error(ArgumentError, /You must pass a payload/)
-      end
-      it "should pass the body as-is if the given body is a string" do
-        @session.should_receive(:post).with(@resource.uri, "whatever", :headers => {
-          :accept => 'application/vnd.fr.grid5000.api.Job+json;level=1,application/json', 
-          :content_type => 'application/json'}
-          ).and_return(@response)
-        @resource.submit("whatever")
-      end
-      it "should also pass the body as-is if the given body is an object" do
-        body = {:key => 'value'}
-        @session.should_receive(:post).with(@resource.uri, body, :headers => {
-          :accept => 'application/vnd.fr.grid5000.api.Job+json;level=1,application/json', 
-          :content_type => 'application/json'}).and_return(@response)
-        @resource.submit(body)
-      end
-      it "should set the Content-Type header to the specified mime-type if given" do
-        @session.should_receive(:post).with(@resource.uri, "whatever", :headers => {
-          :accept => 'application/vnd.fr.grid5000.api.Job+json;level=1,application/json', 
-          :content_type => 'application/xml'}).and_return(@response)
-        @resource.submit("whatever", :headers => {:content_type => 'application/xml'})
-      end
-    end
-    [201, 202].each do |status|
-      it "should return the resource referenced in the Location header after a successful submit (status=#{status})" do
-        @session.should_receive(:post).and_return(response = mock("http response", :status => status, :headers => {'Location' => '/path/to/new/resource'}))
-        @resource.should_receive(:uri_for).with('/path/to/new/resource').and_return(new_resource_uri = mock("uri"))
-        Resource.should_receive(:new).with(new_resource_uri, @session).and_return(new_resource = mock("resource"))
-        new_resource.should_receive(:load).and_return(new_resource)
-        @resource.submit("whatever").should == new_resource
-      end
-    end
-    it "should reload the resource if the response status is 2xx (and not 201 or 202)" do
-      @session.should_receive(:post).and_return(response = mock("http response", :status => 200, :headers => {'Location' => '/path/to/new/resource'}))
-      @resource.should_receive(:reload).and_return(@resource)
-      @resource.submit("whatever").should == @resource
-    end
-  end
-  
-  describe "deleting" do
-    before do
-      @resource = Resource.new(@uri, @session = mock("session", :logger => @logger))
-      @resource.stub!(:http_methods).and_return(['GET', 'DELETE'])
-    end
-    it "should raise an error if the DELETE method is not supported by the service" do
-      @resource.stub!(:http_methods).and_return(['GET'])
-      lambda{@resource.delete}.should raise_error(NotImplementedError, /DELETE method is not allowed/)
-    end
-    it "should send a DELETE request to the resource URI" do
-      @session.should_receive(:delete).with(@uri, :query => {:q => 'v'}, :headers => {'Accept' => 'application/json'}).and_return(response = mock("http response", :status => 204))
-      @resource.delete(:query => {:q => 'v'}, :headers => {'Accept' => 'application/json'}).should be_true
-    end
-  end
-  
-  describe "supported http methodes" do
-    before do
-      @resource = Resource.new(@uri, @session = mock("session", :logger => @logger))
-    end
-    it "should reload if a GET request has not been executed before" do
-      @resource.should_receive(:executed_requests).ordered.and_return({})
-      @resource.should_receive(:reload).ordered
-      @resource.should_receive(:executed_requests).ordered.and_return({
-        'GET' => {'body' => "xxx", "headers" => {'Allow' => 'POST, PUT'}}
-      })
-      @resource.http_methods.should == ['POST','PUT']
-    end
-    it "should reload if the headers are empty" do
-      @resource.should_receive(:executed_requests).exactly(3).ordered.and_return({
-        'GET' => {'body' => "xxx", "headers" => {}}
-      })
-      @resource.should_receive(:reload).ordered
-      @resource.should_receive(:executed_requests).once.ordered.and_return({
-        'GET' => {'body' => "xxx", "headers" => {'Allow' => 'POST, PUT'}}
-      })
-      @resource.http_methods.should == ['POST','PUT']
-    end
-    it "should not reload if the headers are not empty" do
-      @resource.should_receive(:executed_requests).exactly(4).and_return({
-        'GET' => {'body' => "xxx", "headers" => {'Allow' => 'POST, PUT'}}
-      })
-      @resource.should_not_receive(:reload)
-      @resource.http_methods.should == ['POST','PUT']
-    end
-  end
-end