restfully 0.6.3 → 0.7.0.pre

data/spec/fixtures/grid5000-rennes.json

@@ -0,0 +1,63 @@
+{
+    "compilation_server":false,
+    "description":"",
+    "email_contact":"rennes-staff@lists.grid5000.fr",
+    "latitude":48.1,
+    "location":"Rennes,France",
+    "longitude":-1.6667,
+    "name":"Rennes",
+    "security_contact":"rennes-staff@lists.grid5000.fr",
+    "sys_admin_contact":"rennes-staff@lists.grid5000.fr",
+    "type":"site",
+    "uid":"rennes",
+    "user_support_contact":"rennes-staff@lists.grid5000.fr",
+    "web":"http://www.irisa.fr",
+    "version":"fe8e18aaf62cceff002252bcdfa83e4f4c4d9f63",
+    "links": [
+        {
+            "rel":"self",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes"
+        },
+        {
+            "rel":"parent",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000"
+        },
+        {
+            "rel":"versions",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/versions"
+        },
+        {
+            "rel":"clusters",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/clusters"
+        },
+        {
+            "rel":"environments",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/environments"
+        },
+        {
+            "rel":"jobs",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/jobs"
+        },
+        {
+            "rel":"deployments",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/deployments"
+        },
+        {
+            "rel":"metrics",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/metrics"
+        },
+        {
+            "rel":"status",
+            "type":"application/vnd.grid5000+json",
+            "href":"/grid5000/sites/rennes/status"
+        }
+    ]
+}

data/spec/restfully/collection_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Restfully::Collection do
+  before do
+    Restfully::MediaType.register Restfully::MediaType::ApplicationVndBonfireXml
+    
+    @session = Restfully::Session.new(
+      :uri => "https://api.grid5000.fr"
+    )
+    @request = Restfully::HTTP::Request.new(
+      @session, :get, "/grid5000/sites/rennes/jobs",
+      :head => {'Accept' => 'application/vnd.grid5000+json'}
+    )
+    @response = Restfully::HTTP::Response.new(
+      @session, 200, {
+        'Content-Type' => 'application/vnd.grid5000+json; charset=utf-8',
+        'Allow' => 'GET,POST'
+      }, fixture('grid5000-rennes-jobs.json')
+    )
+    Restfully::MediaType.register Restfully::MediaType::Grid5000
+    @resource = Restfully::Resource.new(@session, @response, @request)
+  end
+  
+  it "should include the Collection module if the resource is a collection" do
+    @resource.should_receive(:extend).with(Restfully::Collection)
+    @resource.load
+  end
+  
+  it "should return the total number of elements" do
+    @resource.load.total.should == 366486
+  end
+  
+  it "should return the offset" do
+    @resource.load.offset.should == 0
+  end
+  
+  it "should iterate over the collection" do
+    items = []
+    @resource.load.each{|i| items << i}
+    items.all?{|i| i.kind_of?(Restfully::Resource)}.should be_true
+    items[0].relationships.map(&:to_s).sort.should == ["parent", "self"]
+    items[0]['uid'].should == 376505
+  end
+  
+  it "should be empty if no item" do
+    @response = Restfully::HTTP::Response.new(
+      @session, 200, {
+        'Content-Type' => 'application/vnd.bonfire+xml; charset=utf-8'
+      }, fixture('bonfire-empty-collection.xml')
+    )
+    @resource = Restfully::Resource.new(@session, @response, @request).load
+    @resource.collection?.should be_true
+    @resource.should be_empty
+    @resource.total.should == 0
+    @resource.length.should == 0
+    @resource.offset.should == 0
+    @resource.map{|i| i}.should == []
+  end
+  
+  describe "finders" do
+    before do
+      @response = Restfully::HTTP::Response.new(
+        @session, 200, {
+          'Content-Type' => 'application/vnd.bonfire+xml; charset=utf-8'
+        }, fixture('bonfire-experiment-collection.xml')
+      )
+      @resource = Restfully::Resource.new(@session, @response, @request).load
+    end
+    it "should find an item by uid" do
+      @resource[:'3'].should_not be_nil
+    end
+    it "should find an item by index" do
+      @resource[0].should == @resource.first
+    end
+    it "should reload the item if not complete" do
+      @resource.map{|i| 
+        if i["id"] == "3"
+          i.media_type.should_receive(:complete?).and_return(false)
+          i.should_receive(:reload).once 
+        end
+      }
+      @resource[:'3'].should_not be_nil
+    end
+  end
+
+  
+end

data/spec/restfully/http/helper_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Restfully::HTTP::Helper do
+  include Restfully::HTTP::Helper
+  
+  it "should correctly sanitize the headers" do
+    sanitize_head({
+      'Cache-control' => 'no-cache',
+      :some_header => 'some value',
+      'accept' => 'application/json'
+    }).should == {
+      'Cache-Control' => 'no-cache',
+      'Some-Header' => 'some value',
+      'Accept' => 'application/json'
+    }
+  end
+  
+end

data/spec/restfully/http/request_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Restfully::HTTP::Request do
+  before do
+    @session = mock(
+      Restfully::Session, 
+      :default_headers => {
+        'Accept' => '*/*; application/xml',
+        :accept_encoding => "gzip, deflate"
+      }
+    )
+    
+    @options = {
+      :head => {
+        'Cache-control' => 'no-cache',
+        :some_header => 'some value',
+        'accept' => 'application/json'
+      },
+      :body => {:hello => 'world'}
+    }
+    
+    @session.should_receive(:uri_to).with("/path").
+      and_return(Addressable::URI.parse("https://api.grid5000.fr/path"))
+  end
+  
+  it "should correctly build the request [no body]" do
+    
+    request = Restfully::HTTP::Request.new(@session, :get, "/path", @options)
+    request.head.should == {
+      'Cache-Control' => 'no-cache',
+      'Some-Header' => 'some value',
+      'Accept' => 'application/json',
+      'Accept-Encoding' => 'gzip, deflate'
+    }
+    request.method.should == :get
+  end
+  
+  it "should correctly add the query parameters to the URI" do
+    @options[:query] = {:k1 => 'v1'}
+    request = Restfully::HTTP::Request.new(@session, :get, "/path", @options)
+    request.uri.to_s.should == "https://api.grid5000.fr/path?k1=v1"
+  end
+  
+  it "should correctly update the request with the given parameters" do
+    @options[:query] = {:k1 => 'v1', :k2 => [1,2,3]}
+    @options[:head]['Accept'] = 'text/plain'
+    request = Restfully::HTTP::Request.new(@session, :get, "/path", @options)
+    request.update!(:headers => {'whatever' => 'value'}, :query => {'k1' => 'xx'}).should_not be_nil
+    request.uri.to_s.should == 'https://api.grid5000.fr/path?k1=xx'
+    request.head.should include("Whatever"=>"value", 'Accept' => 'text/plain')
+  end
+  
+  it "should return nil if no changes were made when updating the request" do
+    @options[:query] = {:k1 => 'v1', :k2 => [1,2,3]}
+    request = Restfully::HTTP::Request.new(@session, :get, "/path", @options)
+    request.update!(@options).should be_nil
+  end
+  
+  it "should tell if the request is no-cache" do
+    @options[:head]['Cache-Control'] = 'no-cache, max-age=0'
+    request = Restfully::HTTP::Request.new(@session, :get, "/path", @options)
+    request.no_cache?.should be_true
+  end
+  
+  describe "with body" do
+    it "should correctly build the request [body as hash, no content-type]" do
+      @options[:body] = {"k1" => 'value1', 'k2' => ['a','b','c']}
+      request = Restfully::HTTP::Request.new(@session, :post, "/path", @options)
+      request.head['Content-Type'].
+        should == 'application/x-www-form-urlencoded'
+      request.method.should == :post
+      request.body.should == "k1=value1&k2[]=a&k2[]=b&k2[]=c"
+    end
+
+    it "should correctly build the request [body as hash, content-type=json]" do
+      @options[:body] = {"k1" => 'value1', 'k2' => ['a','b','c']}
+      @options[:head][:content_type] = 'application/json'
+
+      request = Restfully::HTTP::Request.new(@session, :post, "/path", @options)
+      request.head['Content-Type'].
+        should == 'application/json'
+      request.method.should == :post
+      request.body.should == JSON.dump(@options[:body])
+    end
+  
+    it "should correctly build the request [body as string, content-type=json]" do
+      @options[:body] = JSON.dump({"k1" => 'value1', 'k2' => ['a','b','c']})
+      @options[:head][:content_type] = 'application/json'
+      request = Restfully::HTTP::Request.new(@session, :post, "/path", @options)
+      
+      request.head['Content-Type'].
+        should == 'application/json'
+      request.body.should == @options[:body]
+    end
+  end
+
+end

data/spec/restfully/http/response_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Restfully::HTTP::Response do
+  before do
+    @session = mock(Restfully::Session, :logger => Logger.new(STDERR))
+    @io = StringIO.new(fixture('grid5000-rennes.json'))
+  end
+  it "should correctly initialize the response" do
+    content = @io.read
+    @io.rewind
+    response = Restfully::HTTP::Response.new(@session, 200, {
+      'Content-Type' => 'application/json'
+    }, @io)
+
+    response.code.should == 200
+    response.head.should == {"Content-Type"=>"application/json"}
+    response.media_type.should be_a(Restfully::MediaType::ApplicationJson)
+    response.io.should be_a(StringIO)
+    response.body.should == content
+    response.io.read.should == content
+  end
+  
+  
+  it "should always allow :get" do
+    response = Restfully::HTTP::Response.new(@session, 200, {
+      'Content-Type' => 'application/json'
+    }, @io)
+    response.allow?(:get).should be_true
+  end
+  
+  it "should find the allowed methods in the header (if any)" do
+    response = Restfully::HTTP::Response.new(@session, 200, {
+      'Content-Type' => 'application/json',
+      'Allow' => 'GET, POST'
+    }, @io)
+    
+    response.allow?(:get).should be_true
+    response.allow?(:post).should be_true
+  end
+  
+  it "should raise an error if it cannot find a corresponding media-type" do
+    response = Restfully::HTTP::Response.new(@session, 200, {
+      'Content-Type' => 'whatever'
+    }, @io)
+    lambda{
+      response.media_type
+    }.should raise_error(
+      Restfully::Error, 
+      "Cannot find a media-type for content-type=\"whatever\""
+    )
+    
+  end
+end

data/spec/restfully/link_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Restfully::Link do
+  before do
+    @uri = URI.parse('/x/y/z')
+    @valid_attributes = {
+      :rel => 'something',
+      :type => 'application/json',
+      :href => '/'
+    }
+  end
+
+  describe "accessors" do
+    it "should have a rel reader" do
+      link = Restfully::Link.new
+      link.should_not respond_to(:rel=)
+      link.should respond_to(:rel)
+    end
+    it "should have a href reader" do
+      link = Restfully::Link.new
+      link.should_not respond_to(:href=)
+      link.should respond_to(:href)
+    end
+    it "should have a title reader" do
+      link = Restfully::Link.new
+      link.should_not respond_to(:title=)
+      link.should respond_to(:title)
+    end
+    it "should have a errors reader" do
+      link = Restfully::Link.new
+      link.should_not respond_to(:errors=)
+      link.should respond_to(:errors)
+    end
+    it "should respond to valid?" do
+      link = Restfully::Link.new
+      link.should respond_to(:valid?)
+    end
+  end
+
+  describe "validations" do
+    before do
+      @media_type = mock(Restfully::MediaType::AbstractMediaType)
+    end
+    
+    it "should not be valid if there is no type" do
+      link = Restfully::Link.new(@valid_attributes.merge(:type => ''))
+      link.should_not be_valid
+      link.errors.should == ["type cannot be blank"]
+    end
+    
+    it "should not be valid if a media_type cannot be found" do
+      Restfully::MediaType.catalog.clear
+      link = Restfully::Link.new(@valid_attributes)
+      link.should_not be_valid
+      link.errors.should == ["cannot find a MediaType for type \"application/json\""]
+    end
+    
+
+    describe "with a valid catalog" do
+      before do
+        Restfully::MediaType.stub!(:find).and_return(@media_type)
+      end
+
+      it "should be valid" do
+        link = Restfully::Link.new(@valid_attributes)
+        link.should be_valid
+      end
+
+      it "should be valid even if the href is ''" do
+        link = Restfully::Link.new(@valid_attributes.merge(:href => ''))
+        link.should be_valid
+        link.href.should == URI.parse("")
+      end
+    end
+
+
+  end
+
+
+end

data/spec/restfully/media_type/application_vnd_bonfire_xml_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Restfully::MediaType::ApplicationVndBonfireXml do
+  before do
+    Restfully::MediaType.register Restfully::MediaType::ApplicationVndBonfireXml
+
+    @expected_compute_hash = {"name"=>"Compute name", "startup"=>{"href"=>"file:///path/to/startup-script/sh"}, "instance_type"=>"small", "__type__"=>"compute", "description"=>"Compute description", "nic"=>[{"device"=>"eth0", "mac"=>"AA:AA:AA:AA", "network"=>{"href"=>"/locations/fr-inria/networks/1"}, "ip"=>"123.123.123.123"}, {"device"=>"eth1", "mac"=>"BB:BB:BB:BB", "network"=>{"href"=>"/locations/fr-inria/networks/2"}, "ip"=>"123.123.124.2"}], "context"=>{"bonfire_credentials"=>"crohr:p4ssw0rd", "monitoring_ip"=>"123.123.123.2"}, "link"=>[{"href"=>"/locations/fr-inria", "rel"=>"location", "type"=>"application/vnd.bonfire+xml"}, {"href"=>"/locations/uk-epcc/computes/1", "rel"=>"self"}], "disk"=>[{"type"=>"OS", "storage"=>{"href"=>"/locations/fr-inria/storages/1"}, "target"=>"sda"}, {"type"=>"CDROM", "storage"=>{"href"=>"/locations/fr-inria/storages/2"}, "target"=>"sdc"}], "state"=>"ACTIVE"}
+    @fixture = fixture("bonfire-compute-existing.xml")
+    @collection = fixture("bonfire-network-collection.xml")
+    @session = Restfully::Session.new(:uri => "http://localhost:8000")
+  end
+
+  describe "loading from xml" do
+    it "should load the io into a Hash" do
+      media = Restfully::MediaType::ApplicationVndBonfireXml.new(@fixture, @session)
+      media.io.should == @fixture
+      media.unserialized.should be_a(Hash)
+    end
+  
+    it "should build the Hash from the XML doc [resource]" do
+      media = Restfully::MediaType::ApplicationVndBonfireXml.new(@fixture, @session)
+      media.property.should == @expected_compute_hash
+    end
+  
+    it "should build the Hash from the XML doc [resource] 2" do
+      media = Restfully::MediaType::ApplicationVndBonfireXml.new(
+        fixture("bonfire-network-existing.xml"), @session
+      )
+      media.property.should == {"name"=>"Private LAN", "public"=>"YES", "id"=>"29", "__type__"=>"network", "link"=>[{"href"=>"/locations/de-hlrs/networks/29", "rel"=>"self"}]}
+    end
+  
+    it "should build the Hash from the XML doc [collection]" do
+      media = Restfully::MediaType::ApplicationVndBonfireXml.new(@collection, @session)
+      media.should be_collection
+      media.property.should == {"items"=>[{"address"=>"10.0.0.1", "name"=>"Network1", "size"=>"C", "__type__"=>"network", "description"=>"Network1 description", "link"=>[{"href"=>"/locations/fr-inria", "rel"=>"location"}, {"href"=>"/locations/fr-inria/networks/1", "rel"=>"self"}], "visibility"=>"public"}, {"address"=>"10.0.0.1", "name"=>"Network2", "size"=>"C", "__type__"=>"network", "description"=>"Network2 description", "link"=>[{"href"=>"/locations/fr-inria", "rel"=>"location"}, {"href"=>"/locations/fr-inria/networks/2", "rel"=>"self"}], "visibility"=>"private"}], "total"=>2, "offset"=>0, "__type__"=>"collection", "link"=>[{"href"=>"/locations/fr-inria/networks?limit=20", "rel"=>"top", "type"=>"application/vnd.bonfire+xml"}, {"href"=>"/locations/fr-inria", "rel"=>"parent", "type"=>"application/vnd.bonfire+xml"}, {"href"=>"/locations/fr-inria/networks", "rel"=>"self"}]}
+    end
+  
+    it "should build the Hash from the XML doc [empty collection]" do
+      media = Restfully::MediaType::ApplicationVndBonfireXml.new(
+        fixture("bonfire-empty-collection.xml"), @session
+      )
+      media.should be_collection
+      items = []
+      media.each{|i| items << i}
+      items.should be_empty
+    end
+  
+    it "should be able to iterate over a collection" do
+      media = Restfully::MediaType::ApplicationVndBonfireXml.new(fixture("bonfire-experiment-collection.xml"), @session)
+      items = []
+      media.each{|i| items<<i}
+      items.length.should == 3
+    end
+  
+  
+  end
+
+  describe "restfully resource" do
+    it "should correctly load a resource" do
+      req = Restfully::HTTP::Request.new(@session, :get, "http://localhost:8000/locations/de-hlrs/networks/29", :head => {
+        'Accept' => 'application/vnd.bonfire+xml'
+      })
+    
+      res = Restfully::HTTP::Response.new(@session, 200, {
+        'Content-Type' => 'application/vnd.bonfire+xml'
+      }, fixture("bonfire-network-existing.xml"))
+    
+      res.media_type.should be_a(
+        Restfully::MediaType::ApplicationVndBonfireXml
+      )
+    
+      resource = Restfully::Resource.new(@session, res, req).load
+    
+      resource.uri.to_s.should == "http://localhost:8000/locations/de-hlrs/networks/29"
+      resource.collection?.should be_false
+      resource.properties.should == {"name"=>"Private LAN", "public"=>"YES", "id"=>"29"}
+    end
+    
+    it "should correctly load and iterate over a collection" do
+      req = Restfully::HTTP::Request.new(@session, :get, "http://localhost:8000/experiments", :head => {
+        'Accept' => 'application/vnd.bonfire+xml'
+      })
+    
+      res = Restfully::HTTP::Response.new(@session, 200, {
+        'Content-Type' => 'application/vnd.bonfire+xml'
+      }, fixture("bonfire-experiment-collection.xml"))
+    
+      res.media_type.should be_a(Restfully::MediaType::ApplicationVndBonfireXml)
+    
+      collection = Restfully::Resource.new(@session, res, req).load
+    
+      collection.uri.to_s.should == "http://localhost:8000/experiments"
+      collection.collection?.should be_true
+      collection.length.should == 3
+      collection.total.should == 3
+      collection.offset.should == 0
+      collection.all?{|i| i.kind_of? Restfully::Resource}.should be_true
+      collection[0].should == collection.first
+      collection[-1].uri.to_s.should == "http://localhost:8000/experiments/3"
+      collection[-1].should == collection[2]
+      collection[-1].should == collection.last
+      collection[10].should be_nil
+    end
+    
+    it "should correctly load an empty collection" do
+      req = Restfully::HTTP::Request.new(@session, :get, "http://localhost:8000/locations/uk-epcc/computes", :head => {
+        'Accept' => 'application/vnd.bonfire+xml'
+      })
+    
+      res = Restfully::HTTP::Response.new(@session, 200, {
+        'Content-Type' => 'application/vnd.bonfire+xml'
+      }, fixture("bonfire-empty-collection.xml"))
+    
+      res.media_type.should be_a(Restfully::MediaType::ApplicationVndBonfireXml)
+    
+      collection = Restfully::Resource.new(@session, res, req).load
+      collection.collection?.should be_true
+      collection.length.should == 0
+      collection.inspect.should == "[]"
+      collection.should be_empty
+    end
+
+    it "should correctly load a collection with non-detailed items" do
+      req = Restfully::HTTP::Request.new(@session, :get, "http://localhost:8000/locations/de-hlrs/networks", :head => {
+        'Accept' => 'application/vnd.bonfire+xml'
+      })
+
+      res = Restfully::HTTP::Response.new(@session, 200, {
+        'Content-Type' => 'application/vnd.bonfire+xml'
+      }, fixture("bonfire-collection-with-fragments.xml"))
+
+      collection = Restfully::Resource.new(@session, res, req).load
+      collection.any?{|item| item.media_type.complete?}.should be_false
+      collection.inspect.should == "[{...}]"
+
+      stub_request(:get, "http://localhost:8000/locations/de-hlrs/networks/29").
+        with(:headers => {'Accept'=>'application/vnd.bonfire+xml', 'Accept-Encoding'=>'gzip, deflate', 'Cache-Control'=>'no-cache'}).
+        to_return(:status => 200, :body => fixture("bonfire-network-existing.xml"), :headers => {'Content-Type' => 'application/vnd.bonfire+xml'})
+      network = collection[0]
+      network.properties.should == {"name"=>"Private LAN", "public"=>"YES", "id"=>"29"}
+    end
+  end
+
+  describe "serializing to xml" do
+    it "should correctly serialize a resource" do
+      serialized = Restfully::MediaType::ApplicationVndBonfireXml.serialize(
+        @expected_compute_hash,
+        :uri => Addressable::URI.parse('http://path/to/computes')
+      )
+      serialized.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<compute xmlns=\"http://api.bonfire-project.eu/doc/schemas/occi\">\n  <startup href=\"file:///path/to/startup-script/sh\"/>\n  <name>Compute name</name>\n  <instance_type>small</instance_type>\n  <link href=\"/locations/fr-inria\" rel=\"location\" type=\"application/vnd.bonfire+xml\"/>\n  <link href=\"/locations/uk-epcc/computes/1\" rel=\"self\"/>\n  <context>\n    <bonfire_credentials>crohr:p4ssw0rd</bonfire_credentials>\n    <monitoring_ip>123.123.123.2</monitoring_ip>\n  </context>\n  <nic>\n    <device>eth0</device>\n    <mac>AA:AA:AA:AA</mac>\n    <network href=\"/locations/fr-inria/networks/1\"/>\n    <ip>123.123.123.123</ip>\n  </nic>\n  <nic>\n    <device>eth1</device>\n    <mac>BB:BB:BB:BB</mac>\n    <network href=\"/locations/fr-inria/networks/2\"/>\n    <ip>123.123.124.2</ip>\n  </nic>\n  <description>Compute description</description>\n  <disk>\n    <type>OS</type>\n    <storage href=\"/locations/fr-inria/storages/1\"/>\n    <target>sda</target>\n  </disk>\n  <disk>\n    <type>CDROM</type>\n    <storage href=\"/locations/fr-inria/storages/2\"/>\n    <target>sdc</target>\n  </disk>\n  <state>ACTIVE</state>\n</compute>\n"
+    end
+  end
+end