restfully 0.6.3 → 0.7.0.pre

data/spec/restfully/media_type_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Restfully::MediaType do  
+  
+  class NewMediaType < Restfully::MediaType::AbstractMediaType
+    set :signature, "application/whatever"
+    set :parser, JSON
+  end
+  class BadMediaType < Restfully::MediaType::AbstractMediaType; end
+
+  describe "class methods" do
+    it "should refuse to add a media type without signature" do
+      lambda{
+        Restfully::MediaType.register BadMediaType
+      }.should raise_error(ArgumentError, "The given MediaType (BadMediaType) has no signature")
+    end
+    it "should refuse to add a media type without parser" do
+      BadMediaType.set :signature, "application/whatever"
+      lambda{
+        Restfully::MediaType.register BadMediaType
+      }.should raise_error(ArgumentError, "The given MediaType (BadMediaType) has no parser")
+    end
+    it "should add the media_type to the catalog" do
+      length_before = Restfully::MediaType.catalog.length
+      Restfully::MediaType.register NewMediaType
+      Restfully::MediaType.catalog.length.should == length_before+1
+    end
+
+    it "should find the corresponding media_type [application/json]" do
+      Restfully::MediaType.register Restfully::MediaType::ApplicationJson
+      Restfully::MediaType.find("application/json").should == Restfully::MediaType::ApplicationJson
+    end
+
+    it "should find the corresponding media_type [application/vnd.grid5000+json]" do
+      Restfully::MediaType.register Restfully::MediaType::Grid5000
+      Restfully::MediaType.find('application/vnd.grid5000+json; charset=utf-8').should == Restfully::MediaType::Grid5000
+    end
+    
+    it "should find the corresponding media_type from the less generic to the most generic [application/json]" do
+      Restfully::MediaType.catalog.clear
+      Restfully::MediaType.register Restfully::MediaType::Wildcard
+      Restfully::MediaType.register Restfully::MediaType::ApplicationJson
+      Restfully::MediaType.register Restfully::MediaType::Grid5000
+      Restfully::MediaType.find('application/json').should == Restfully::MediaType::ApplicationJson
+    end
+
+    it "should fall back to wildcard" do
+      Restfully::MediaType.find("whatever/whatever").should == Restfully::MediaType::Wildcard
+    end
+  end
+
+  describe Restfully::MediaType::Wildcard do
+    ["text/plain", "text/*", "*/*"].each do |type|
+      it "should match everything [#{type}]" do
+        Restfully::MediaType::Wildcard.supports?(type).should == "*/*"
+      end
+    end
+    it "should not match invalid content types" do
+      Restfully::MediaType::Wildcard.supports?("whatever").should be_nil
+    end
+    it "should correctly initialize with a payload" do
+      media_type = Restfully::MediaType::Wildcard.new(
+        "some string", 
+        mock(Restfully::Session)
+      )
+      media_type.property("some").should == "some"
+      media_type.links.should == []
+    end
+  end
+
+  describe Restfully::MediaType::Grid5000 do
+    before do
+      @session = 
+      @media_type =  Restfully::MediaType::Grid5000.new(
+        StringIO.new(fixture('grid5000-rennes.json')),
+        @session
+      )
+    end
+    it "should correctly extract the links" do
+      @media_type.links.map(&:rel).should == ["self", "parent", "versions", "clusters", "environments", "jobs", "deployments", "metrics", "status"]
+      @media_type.links.map(&:title).should == ["self", "parent", "versions", "clusters", "environments", "jobs", "deployments", "metrics", "status"]
+    end
+
+    it "should correctly find a property" do
+      @media_type.property("uid").should == "rennes"
+    end
+
+    it "should tell if it is a collection" do
+      @media_type.collection?.should be_false
+    end
+  end
+
+  describe Restfully::MediaType::ApplicationXWwwFormUrlencoded do
+    before do
+      @unserialized = {"k1" => 'value', "k2" => ['a','b','c']}
+      @serialized = "k1=value&k2[]=a&k2[]=b&k2[]=c"
+    end
+    it "should have the correct default type" do
+      Restfully::MediaType::ApplicationXWwwFormUrlencoded.
+        default_type.should == "application/x-www-form-urlencoded"
+    end
+    it "should be found" do
+      Restfully::MediaType.register Restfully::MediaType::ApplicationXWwwFormUrlencoded
+      Restfully::MediaType.find('application/x-www-form-urlencoded').
+        should == Restfully::MediaType::ApplicationXWwwFormUrlencoded
+    end
+    it "should correctly encode a hash" do
+      Restfully::MediaType::ApplicationXWwwFormUrlencoded.
+        serialize(@unserialized).should == @serialized
+    end
+    it "should correctly decode a string" do
+      Restfully::MediaType::ApplicationXWwwFormUrlencoded.
+        unserialize(@serialized).should == @unserialized
+    end
+  end
+
+end

data/spec/restfully/resource_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Restfully::Resource do
+  before do
+    @session = Restfully::Session.new(
+      :uri => "https://api.grid5000.fr"
+    )
+    @request = Restfully::HTTP::Request.new(
+      @session, :get, "/grid5000/sites/rennes",
+      :head => {'Accept' => 'application/vnd.grid5000+json'}
+    )
+    @response = Restfully::HTTP::Response.new(
+      @session, 200, {
+        'Content-Type' => 'application/vnd.grid5000+json; charset=utf-8',
+        'Allow' => 'GET'
+      }, fixture('grid5000-rennes.json')
+    )
+    Restfully::MediaType.register Restfully::MediaType::Grid5000
+  end
+  
+  it "should correctly initialize a resource" do
+    resource = Restfully::Resource.new(@session, @response, @request)
+    resource.uri.to_s.should == "https://api.grid5000.fr/grid5000/sites/rennes"
+    resource.should be_a(Restfully::Resource)
+    resource.load.should == resource
+    resource.media_type.should be_a(Restfully::MediaType::Grid5000)
+    resource['uid'].should == 'rennes'
+    %w{clusters jobs deployments status self parent}.each do |rel|
+      resource.should respond_to(rel.to_sym)
+    end
+  end
+  
+  describe "loaded" do
+    before do
+      @resource = Restfully::Resource.new(@session, @response, @request)
+      @resource.load
+    end
+    
+    it "should load the requested association" do
+      @session.should_receive(:get).once.with(
+        URI.parse("/grid5000/sites/rennes/clusters"),
+        :head=>{"Accept"=>"application/vnd.grid5000+json"}
+      ).and_return(association=mock(Restfully::Resource))
+      association.should_receive(:load)
+      @resource.clusters
+    end
+    
+    it "should not allow to submit if POST not allowed on the resource" do
+      lambda{
+        @resource.submit
+      }.should raise_error(Restfully::MethodNotAllowed)
+    end
+    it "should send a POST request if POST is allowed [payload argument]" do
+      @resource.should_receive(:allow?).with(:post).and_return(true)
+      @session.should_receive(:post).with(
+        @resource.uri,
+        'some payload',
+        :head => {'Content-Type' => 'text/plain'},
+        :query => {:k1 => 'v1'}
+      )
+      @resource.submit(
+        'some payload', 
+        :headers => {'Content-Type' => 'text/plain'},
+        :query => {:k1 => 'v1'}
+      )
+    end
+    it "should send a POST request if POST is allowed [payload as hash]" do
+      @resource.should_receive(:allow?).with(:post).and_return(true)
+      @session.should_receive(:post).with(
+        @resource.uri,
+        {:key => 'value'},
+        :head => {'Content-Type' => 'text/plain'},
+        :query => {:k1 => 'v1'}
+      )
+      @resource.submit(
+        :key => 'value', 
+        :headers => {'Content-Type' => 'text/plain'},
+        :query => {:k1 => 'v1'}
+      )
+    end
+    
+    it "should reload the resource" do
+      @resource.should_receive(:load).
+        with(:head => {'Cache-Control' => 'no-cache'}).
+        and_return(@resource)
+      @resource.reload.should == @resource
+    end
+    
+    it "should reload the resource even after having reloaded it once before" do
+      @session.should_receive(:execute).twice.with(@request).
+        and_return(@response)
+      @resource.reload
+      @resource.reload
+    end
+    
+    it "should raise an error if it cannot reload the resource" do
+      @session.should_receive(:execute).with(@request).
+        and_return(res=mock(Restfully::HTTP::Response))
+      @session.should_receive(:process).with(res, @request).
+        and_return(false)
+      lambda{
+        @resource.reload
+      }.should raise_error(Restfully::Error, "Cannot reload the resource")
+    end
+  end
+  
+  
+  
+end

data/spec/restfully/session_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe Restfully::Session do
+  before do
+    RestClient.components.clear
+    @logger = Logger.new(STDERR)
+    @uri = "https://api.grid5000.fr"
+    @config = {
+      :uri => @uri,
+      :logger => @logger
+    }
+  end
+  
+  it "should initialize a session with the correct properties" do
+    session = Restfully::Session.new(@config.merge("key" => "value"))
+    session.logger.should == @logger
+    session.uri.should == Addressable::URI.parse(@uri)
+    session.config.should == {:key => "value"}
+  end
+  
+  it "should raise an error if no URI given" do
+    lambda{
+      Restfully::Session.new(@config.merge(:uri => ""))
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should fetch the root path [no URI path]" do
+    session = Restfully::Session.new(@config)
+    session.should_receive(:get).with("").
+      and_return(res = mock(Restfully::Resource))
+    res.should_receive(:load).and_return(res)
+    session.root.should == res
+  end
+  
+  it "should fetch the root path [URI path present]" do
+    session = Restfully::Session.new(
+      @config.merge(:uri => "https://api.grid5000.fr/resource/path")
+    )
+    session.should_receive(:get).with("/resource/path").
+      and_return(res = mock(Restfully::Resource))
+    res.should_receive(:load).and_return(res)
+    session.root.should == res
+  end
+  
+  it "should add or replace additional headers to the default set" do
+    session = Restfully::Session.new(
+      @config.merge(:default_headers => {
+        'Accept' => 'application/xml', 
+        'Cache-Control' => 'no-cache'
+      })
+    )
+    session.default_headers.should == {
+      'Accept' => 'application/xml', 
+      'Cache-Control' => 'no-cache',
+      'Accept-Encoding' => 'gzip, deflate'
+    }
+  end
+  
+  describe "middleware" do
+    it "should only have Rack::Cache enabled by default" do
+      session = Restfully::Session.new(@config)
+      session.middleware.length.should == 1
+      session.middleware.should == [
+        Rack::Cache
+      ]
+    end
+    
+    it "should use Restfully::Rack::BasicAuth if basic authentication is used" do
+      session = Restfully::Session.new(@config.merge(
+        :username => "crohr", :password => "p4ssw0rd"
+      ))
+      session.middleware.length.should == 2
+      session.middleware.should == [
+        Rack::Cache,
+        Restfully::Rack::BasicAuth
+      ]
+    end
+  end
+  
+  describe "transmitting requests" do
+    before do
+      @session = Restfully::Session.new(@config)
+      @path = "/path"
+      @default_headers = @session.default_headers
+    end
+    
+    it "should make a get request" do  
+      stub_request(:get, @uri+@path+"?k1=v1&k2=v2").with(
+        :headers => @default_headers.merge({
+          'Accept' => '*/*',
+          'X-Header' => 'value'
+        })
+      ).to_return(
+        :status => 200,
+        :body => 'body',
+        :headers => {'X'=>'Y'}
+      )
+
+      Restfully::HTTP::Response.should_receive(:new).with(
+        @session, 200, hash_including({'X'=>'Y'}), ['body']
+      ).and_return(
+        @response = mock(Restfully::HTTP::Response)
+      )
+
+      @session.should_receive(:process).with(
+        @response,
+        instance_of(Restfully::HTTP::Request)
+      )
+      
+      @session.transmit :get, @path, {
+        :query => {:k1 => "v1", :k2 => "v2"},
+        :headers => {'X-Header' => 'value'}
+      }
+    end
+    
+    it "should make an authenticated get request" do
+      stub_request(:get, "https://crohr:p4ssw0rd@api.grid5000.fr"+@path+"?k1=v1&k2=v2").with(
+        :headers => @default_headers.merge({
+          'Accept' => '*/*',
+          'X-Header' => 'value'
+        })
+      )
+      @session.should_receive(:process)
+      @session.authenticate :username => 'crohr', :password => 'p4ssw0rd'
+      @session.transmit :get, @path, {
+        :query => {:k1 => "v1", :k2 => "v2"},
+        :headers => {'X-Header' => 'value'}
+      }
+    end
+  end
+  
+  describe "processing responses" do
+    before do
+      @session = Restfully::Session.new(@config)
+      @request = mock(
+        Restfully::HTTP::Request, 
+        :method => :get, 
+        :uri => @uri, 
+        :head => mock("head"),
+        :update! => nil
+      )
+      @response = Restfully::HTTP::Response.new(
+        @session,
+        200,
+        {'X' => 'Y'},
+        'body'
+      )
+    end
+    
+    it "should return true if status=204" do
+      @response.stub!(:code).and_return(204)
+      @session.process(@response, @request).should be_true
+    end
+    
+    it "should raise a Restfully::HTTP::ClientError if status in 400..499" do
+      @response.stub!(:code).and_return(400)
+      lambda{
+        @session.process(@response, @request)
+      }.should raise_error(Restfully::HTTP::ClientError)
+    end
+    
+    it "should raise a Restfully::HTTP::ServerError if status in 500..599" do
+      @response.stub!(:code).and_return(500)
+      lambda{
+        @session.process(@response, @request)
+      }.should raise_error(Restfully::HTTP::ServerError)
+    end
+    
+    it "should raise an error if the status is not supported" do
+      @response.stub!(:code).and_return(50)
+      lambda{
+        @session.process(@response, @request)
+      }.should raise_error(Restfully::Error)
+    end
+    
+    [201, 202].each do |status|
+      it "should fetch the resource specified in the Location header if status = #{status}" do
+        @response.stub!(:code).and_return(status)
+        @response.head['Location'] = @uri+"/path"
+        
+        @session.should_receive(:get).
+          with(@uri+"/path", :head => @request.head).
+          and_return(resource=mock("resource"))
+        @session.process(@response, @request).
+          should == resource
+      end
+    end
+    
+    it "should return a Restfully::Resource if successful" do
+      Restfully::MediaType.register Restfully::MediaType::ApplicationJson
+      body = {
+        :key1 => "value1",
+        :key2 => ["value2", "value3"]
+      }
+      @response = Restfully::HTTP::Response.new(
+        @session, 200,
+        {'Content-Type' => 'application/json'},
+        JSON.dump(body)
+      )
+      
+      resource = @session.process(
+        @response,
+        @request
+      )
+      
+      resource.should be_a(Restfully::Resource)
+      resource.uri.should == @request.uri
+      resource['key1'].should == body[:key1]
+      resource['key2'].should == body[:key2]
+    end
+    
+    it "should raise an error if the response content-type is not supported" do
+      @response = Restfully::HTTP::Response.new(
+        @session, 200,
+        {'Content-Type' => ''},
+        'body'
+      )
+      
+      lambda{ 
+        @session.process(@response,@request) 
+      }.should raise_error(
+        Restfully::Error, 
+        "Cannot find a media-type for content-type=\"\""
+      )
+    end
+  end
+  
+end
+