restfully 0.2.1

data/spec/http/error_spec.rb

@@ -0,0 +1,18 @@
+require 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

@@ -0,0 +1,17 @@
+require 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

@@ -0,0 +1,45 @@
+require 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/json', :cache_control => 'max-age=0'}, 
+      :query => {'custom_param1' => [3, 4, 5, 6], 'custom_param2' => 'value_custom_param2'}
+    )
+    request.uri.should be_a URI
+    request.uri.to_s.should == 'https://api.grid5000.fr/sid/grid5000?q1=v1&q2=v2&custom_param1=3,4,5,6&custom_param2=value_custom_param2'
+    request.uri.query.should == "q1=v1&q2=v2&custom_param1=3,4,5,6&custom_param2=value_custom_param2"
+    request.headers.should == {
+      'Accept' => 'application/json',
+      'Cache-Control' => 'max-age=0'
+    }
+    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

@@ -0,0 +1,15 @@
+require 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
+end

data/spec/http/rest_client_adapter_spec.rb

@@ -0,0 +1,33 @@
+require 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(request.headers).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
+    adapter = Restfully::HTTP::Adapters::RestClientAdapter.new("https://api.grid5000.fr")
+    lambda{adapter.post(mock("restfully request"))}.should raise_error NotImplementedError, "POST is not supported by your adapter."
+  end
+  it "should rescue any RestClient::Exception and correctly populate the response" do
+    res = mock(Net::HTTPResponse, :code => 404, :body => '{"message":"whatever"}', :to_hash => {'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.body.should == {'message' => 'whatever'}
+  end
+end

data/spec/link_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+describe Link do
+
+  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
+    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 not be valid if there is no href" do
+    link = Link.new 'rel' => 'collection', 'title' => 'my collection'
+    link.should_not be_valid
+  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

@@ -0,0 +1,25 @@
+require 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, "Content-Type 'unknown' is not supported. Cannot parse the given object.")
+  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
+end

data/spec/resource_spec.rb

@@ -0,0 +1,198 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+
+describe Resource do
+  before do
+    @logger = Logger.new(STDOUT)
+  end
+  
+  it "should have all the methods of a hash" do
+    resource = Resource.new("uri", session=mock('session'))
+    resource.size.should == 0
+    resource['whatever'] = 'thing'
+    resource.size.should == 1
+    resource.should == {'whatever' => 'thing'}
+    resource.should respond_to(:each)
+    resource.should respond_to(:length)
+  end
+  
+  describe "accessors" do
+    it "should have a reader on the session" do
+      resource = Resource.new("uri", session=mock("session"))
+      resource.should_not respond_to(:session=)
+      resource.session.should == session
+    end
+    it "should have a reader on the uri" do
+      resource = Resource.new("uri", session=mock("session"))
+      resource.should_not respond_to(:uri=)
+      resource.uri.should == "uri"
+    end
+    it "should have a reader on the raw property" do
+      resource = Resource.new("uri", session=mock("session"), 'raw' => {})
+      resource.should_not respond_to(:raw=)
+      resource.raw.should == {}
+    end
+    it "should have a reader on the state property" do
+      resource = Resource.new("uri", session=mock("session"))
+      resource.should_not respond_to(:state=)
+      resource.state.should == :unloaded
+    end
+  end
+  
+  
+  describe "loading" do
+  
+    before do
+      @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'
+          }
+        }
+      }.to_json
+      @response_200 = Restfully::HTTP::Response.new(200, {'Content-Type' => 'application/json;utf-8', 'Content-Length' => @raw.length}, @raw)
+    end
+    it "should not be loaded in its initial state" do
+      resource = Resource.new(mock("uri"), mock('session'))
+      resource.should_not be_loaded
+    end
+    it "should get the raw representation of the resource via the session if it doesn't have it" do
+      resource = Resource.new(uri=mock("uri"), session = mock("session", :logger => Logger.new(STDOUT)))
+      resource.stub!(:define_link) # do not define links
+      resource.raw.should be_nil
+      session.should_receive(:get).with(uri, {}).and_return(@response_200)
+      resource.load
+      resource.should be_loaded
+    end
+    it "should get the raw representation of the resource via the session if there are query parameters" do
+      resource = Resource.new(uri=mock("uri"), session = mock("session", :logger => Logger.new(STDOUT)))
+      resource.stub!(:define_link) # do not define links
+      resource.stub!(:loaded?).and_return(true) # should force reload even if already loaded
+      resource.raw.should be_nil
+      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=mock("uri"), session = mock("session", :logger => Logger.new(STDOUT)))
+      resource.stub!(:define_link) # do not define links
+      resource.stub!(:loaded?).and_return(true) # should force reload even if already loaded
+      resource.raw.should be_nil
+      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
+      resource = Resource.new("uri", session = mock("session", :get => @response_200, :logger => @logger))
+      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]
+      lambda{resource.clusters}.should raise_error(NoMethodError)
+    end
+    
+    it "should correctly define a collection association" 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'
+      }), :logger => @logger))
+      Collection.should_receive(:new).with('/grid5000/sites/rennes/versions', session, :title => 'versions', :raw => nil).and_return(collection=mock("restfully collection"))
+      resource.load
+      resource.associations['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'
+      }), :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'
+      }), :logger => @logger))
+      Resource.should_receive(:new).with('/grid5000/sites/rennes/versions/123', session, :title => 'version', :raw => nil).and_return(member=mock("restfully resource"))
+      resource.load
+      resource.associations['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'
+      }), :logger => @logger))
+      Resource.should_receive(:new).with('/grid5000', session).and_return(parent=mock("restfully resource"))
+      resource.load
+      resource.associations['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'
+      }), :logger => @logger))
+      resource.load
+      resource.associations.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.associations.keys.should =~ ['versions', 'clusters', 'environments', 'status', 'parent', 'version']
+    end
+  end
+end

data/spec/restfully_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Restfully do
+  it "should have a default adapter" do
+    Restfully.adapter.should == Restfully::HTTP::Adapters::RestClientAdapter
+  end
+  
+  it "should allow setting other adapters" do
+    require 'restfully/http/adapters/patron_adapter'
+    Restfully.adapter = Restfully::HTTP::Adapters::PatronAdapter
+    Restfully.adapter.should == Restfully::HTTP::Adapters::PatronAdapter
+  end
+end

data/spec/session_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__)+'/spec_helper'
+
+include Restfully
+describe Session do
+  describe "initialization" do
+    it "should have a logger reader" do
+      session = Session.new('https://api.grid5000.fr')
+      session.should_not respond_to(:logger=)
+      session.should respond_to(:logger)
+    end
+    it "should have a base_uri reader" do
+      session = Session.new('https://api.grid5000.fr')
+      session.should_not respond_to(:base_uri=)
+      session.base_uri.should == 'https://api.grid5000.fr'
+    end
+    it "should have a root_path reader that returns the path of the root resource, relative to the base URI" do
+      session = Session.new('https://api.grid5000.fr/sid', 'root_path' => '/grid5000')
+      session.should_not respond_to(:root_path=)
+      session.root_path.should == '/grid5000'
+    end
+    it "should set the default root_path to /" do
+      session = Session.new('https://api.grid5000.fr')
+      session.root_path.should == '/'
+    end
+    it "should log to NullLogger by default" do
+      NullLogger.should_receive(:new).and_return(logger = mock(NullLogger))
+      session = Session.new('https://api.grid5000.fr')
+      session.logger.should == logger
+    end
+    it "should use the given logger" do
+      logger = mock("custom logger")
+      session = Session.new('https://api.grid5000.fr', 'logger' => logger)
+      session.logger.should == logger
+    end
+    it "should set a default Accept HTTP header if no default headers are given" do
+      session = Session.new('https://api.grid5000.fr')
+      session.default_headers.should == {
+        'Accept' => 'application/json'
+      }
+    end
+    it "should use the given default headers" do
+      session = Session.new('https://api.grid5000.fr', :default_headers => {:accept => 'application/xml'})
+      session.default_headers.should == {
+        :accept => 'application/xml'
+      }
+    end
+    it "should correctly initialize the connection" do
+      Restfully.adapter.should_receive(:new).with('https://api.grid5000.fr/sid', :user => 'crohr', :password => 'password').and_return(connection = mock("restfully connection"))
+      session = Session.new('https://api.grid5000.fr/sid', 'root_path' => '/grid5000', :user => 'crohr', :password => 'password')
+      session.connection.should == connection
+    end
+  
+    it "should initialize the root resource" do
+      session = Session.new('https://api.grid5000.fr', 'root_path' => '/grid5000', :user => 'crohr', :password => 'password')
+      session.root.should be_a Restfully::Resource
+      session.root.uri.to_s.should == '/grid5000'
+      session.root.should_not be_loaded
+    end
+  
+    it "should yield the loaded root resource and the session object" do
+      Restfully::Resource.stub!(:new).and_return(root_resource = mock(Restfully::Resource))
+      root_resource.should_receive(:load).and_return(root_resource)
+      Session.new('https://api.grid5000.fr', :root_path => '/grid5000', :user => 'crohr', :password => 'password') do |root, session|
+        session.root.should == root
+        root.should == root_resource
+      end
+    end
+  end
+  
+  describe "Getting resources" do
+    before(:each) do
+      @session = Session.new('https://api.grid5000.fr/sid', :root_path => '/grid5000', :user => 'crohr', :password => 'password', :default_headers => {})
+      @request = mock("restfully http request", :uri => mock("uri"), :headers => mock("headers"))
+      @response = mock("restfully http response", :status => 200, :headers => mock("headers"))
+    end
+    it "should create a new Request object and pass it to the connection" do
+      Restfully::HTTP::Request.should_receive(:new).with(URI.parse('https://api.grid5000.fr/sid/some/path'), :headers => {:cache_control => 'max-age=0'}, :query => {}).and_return(@request)
+      @session.connection.should_receive(:get).with(@request).and_return(@response)
+      @session.get('/some/path', :headers => {:cache_control => 'max-age=0'}).should == @response
+    end
+    it "should not use the base_url if the path is a complete url" do
+      Restfully::HTTP::Request.should_receive(:new).with(URI.parse('http://somehost.com/some/path'), :headers => {}, :query => {}).and_return(@request)
+      @session.connection.should_receive(:get).with(@request).and_return(@response)
+      @session.get('http://somehost.com/some/path').should == @response
+    end
+    it "should add the session's default headers to the request's headers" do
+      Restfully::HTTP::Request.should_receive(:new).with(URI.parse('http://somehost.com/some/path'), :headers => {}, :query => {}).and_return(@request)
+      @session.default_headers['cache-control'] = 'max-age=0'
+      @request.should_receive(:add_headers).with('cache-control' => 'max-age=0')
+      @session.connection.should_receive(:get).with(@request).and_return(@response)
+      @session.get('http://somehost.com/some/path').should == @response
+    end
+    it "should raise a Restfully::HTTP::ClientError error on 4xx errors" do
+      Restfully::HTTP::Request.should_receive(:new).with(URI.parse('http://somehost.com/some/path'), :headers => {}, :query => {}).and_return(@request)
+      @session.connection.should_receive(:get).with(@request).and_return(response = mock("404 response", :status => 404, :body => {'code' => 404, 'message' => 'The requested resource cannot be found.', 'title' => 'Not Found'}, :headers => mock("headers")))
+      lambda{ @session.get('http://somehost.com/some/path') }.should raise_error(Restfully::HTTP::ClientError, "404 Not Found. The requested resource cannot be found.")
+    end
+    it "should raise a Restfully::HTTP::ServerError error on 4xx errors" do
+      Restfully::HTTP::Request.should_receive(:new).with(URI.parse('http://somehost.com/some/path'), :headers => {}, :query => {}).and_return(@request)
+      @session.connection.should_receive(:get).with(@request).and_return(response = mock("404 response", :status => 500, :body => {'code' => 500, 'message' => 'Something went wrong.', 'title' => 'Internal Server Error'}, :headers => mock("headers")))
+      lambda{ @session.get('http://somehost.com/some/path') }.should raise_error(Restfully::HTTP::ServerError, "500 Internal Server Error. Something went wrong.")
+    end
+  end
+  
+end