right_api_client 1.6.1 → 1.6.2

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'pp'
+require 'yaml'
+
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'right_api_client'
+
+RSpec.configure do |config|
+  #
+  # include helpers
+
+  $config = config
+
+  Dir[File.expand_path('../support/**/*.rb', __FILE__)].each do |path|
+    require(path)
+  end
+
+  #
+  # misc
+
+  config.mock_with :flexmock
+end

data/spec/support/mock_spec_helper.rb

@@ -0,0 +1,40 @@
+module MockSpecHelper
+
+  def mock_rest_client
+    @api_version = RightApi::Client::API_VERSION
+    @test_account_id = '1'
+    @rest_client = RestClient::Resource.new(RightApi::Client::DEFAULT_API_URL)
+    flexmock(RestClient::Resource).should_receive(:new).and_return(@rest_client)
+    @session = flexmock(:cookies => {})
+    @header = {'X-Api-Version' => @api_version, 'X-Account' => @test_account_id, :cookies => {}, :accept => :json}
+  end
+
+  def given_user_facing_client
+    mock_rest_client
+    flexmock(@rest_client).should_receive(:post).with(
+        {'email' => 'email', 'password' => 'password', 'account_href' => '/api/accounts/1'},
+        {'X-Api-Version' => @api_version}, Proc).and_return(@session)
+    flexmock(@rest_client).should_receive(:get).with(@header, Proc).once.and_return(['', '{"links": [
+        {
+          "href": "/api/servers",
+          "rel": "servers"
+        }]}'])
+    @client = RightApi::Client.new(:email => 'email', :password => 'password', :account_id => @test_account_id)
+  end
+
+  def given_instance_facing_client
+    mock_rest_client
+    flexmock(@rest_client).should_receive(:post).with(
+        {'instance_token' => 'instance_token', 'account_href' => '/api/accounts/1'},
+        {'X-Api-Version' => @api_version}, Proc).and_return(@session)
+    flexmock(@rest_client).should_receive(:get).with(@header, Proc).once.and_return(['', '{"links": [
+        {
+          "href": "/api/clouds/1/instances/1",
+          "rel": "self"
+        }]}'])
+    @client = RightApi::Client.new(:instance_token => 'instance_token', :account_id => @test_account_id)
+  end
+end
+
+$config.include MockSpecHelper
+

data/spec/unit/client_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe RightApi::Client, :unit=>true do
+  context 'when the RightScale API misbehaves by sending empty bodies with 200 response' do
+    before(:each) do
+      given_user_facing_client
+      @result = Net::HTTPOK.new('1.1', '200', 'OK')
+      @result.set_content_type('application/vnd.rightscale.server+json')
+      @request = RestClient::Request.new(:method => 'GET', :headers => {}, :url => '/api/servers/1')
+      @response = RestClient::Response.create('', @result, {}, @request)
+      flexmock(@rest_client).should_receive(:get).with(Hash, Proc).and_yield(@response, @request, @result)
+      flexmock(@rest_client).should_receive(:post).with(Hash, Hash, Proc).and_yield(@response, @request, @result)
+    end
+
+    it 'raises an empty body error for a GET' do
+      expect { @client.servers(:id => 1).show }.to raise_error(RightApi::EmptyBodyError)
+    end
+
+    it 'raises an empty body error for a POST' do
+      expect { @client.servers.create }.to raise_error(RightApi::EmptyBodyError)
+    end
+  end
+end

data/spec/unit/helper_spec.rb

@@ -0,0 +1,214 @@
+require File.expand_path('../../spec_helper', __FILE__)
+include RightApi::Helper
+
+describe RightApi::Helper, :unit=>true do
+
+  API_MEDIA_TYPES = %w{audit_entry ip_address process server}
+
+  context ".define_instance_method" do
+    it "defines method" do
+      flexmock(RightApi::Helper).should_receive(:define_method)
+      define_instance_method('show') {1}
+    end
+  end
+
+  context ".api_methods" do
+    it "returns api methods" do
+      api_methods.should == RightApi::Helper.methods(false)
+    end
+  end
+
+  context ".has_id" do
+    it "returns false when params have no :id" do
+      params = {}
+      has_id(params).should == false
+    end
+
+    it "returns true when params have no :id" do
+      params = {:id => 1}
+      has_id(params).should == true
+    end
+  end
+
+  context ".add_id_and_params_to_path" do
+    it "adds id to the path" do
+      path = "/api/hello"
+      params = {:id => 1}
+      result = "/api/hello/1"
+      add_id_and_params_to_path(path,params).should == result
+    end
+
+    it "adds params to the path" do
+      path = "/api/hello"
+      params = {:right => "scale"}
+      result = "/api/hello?right=scale"
+      add_id_and_params_to_path(path,params).should == result
+    end
+
+    it "adds filters to the path" do
+      path = "/api/hello"
+      params = {:filter => ["first_name==Right", "last_name==Scale"]}
+      result = "/api/hello?filter[]=first_name%3D%3DRight&filter[]=last_name%3D%3DScale"
+      add_id_and_params_to_path(path,params).should == result
+    end
+
+    it "adds id/params/filters to the path" do
+      path = "/api/hello"
+      params = {
+        :id     => 1,
+        :param  => "params",
+        :filter => ["first_name==Right", "last_name==Scale"]
+      }
+      result = "/api/hello/1?filter[]=first_name%3D%3DRight&filter[]=last_name%3D%3DScale&param=params"
+      add_id_and_params_to_path(path,params).should == result
+    end
+  end
+
+  context ".insert_in_path" do
+    it "inserts term in front of first ? in path" do
+      path = "aa?bb?cc?dd???"
+      term = "term"
+      result = "aa/term?bb?cc?dd???"
+      insert_in_path(path,term).should == result
+    end
+
+    it "appends term to the end of path" do
+      path = "helloThisIsAPath"
+      term = "term"
+      result = "helloThisIsAPath/term"
+      insert_in_path(path,term).should == result
+    end
+  end
+
+  context ".is_singular?" do
+    API_MEDIA_TYPES.each do |media_type|
+      it "identifies media type #{media_type} as singular" do
+        is_singular?(media_type).should == true
+      end
+    end
+  end
+
+  context ".get_href_from_links" do
+    it "returns nil for empty links" do
+      links = []
+      get_href_from_links(links).should == nil
+    end
+
+    it "returns href of self link" do
+      links = [
+        {"rel" => "network", "href" => "/api/networks/aaa"},
+        {"rel" => "self", "href" => "/api/self"}
+      ]
+      get_href_from_links(links).should == "/api/self"
+
+      links.should == [
+                       {"rel" => "network", "href" => "/api/networks/aaa"},
+                       {"rel" => "self", "href" => "/api/self"}
+                      ]
+    end
+  end
+
+  context ".get_and_delete_href_from_links" do
+    it "returns nil for empty links " do
+      links = []
+      get_and_delete_href_from_links(links).should == nil
+    end
+
+    it "returns and delete href of self link from links" do
+      links = [
+        {"rel" => "network", "href" => "/api/networks/aaa"},
+        {"rel" => "self", "href" => "/api/self"}
+      ]
+      get_and_delete_href_from_links(links).should == "/api/self"
+
+      links.should == [{"rel" => "network", "href" => "/api/networks/aaa"}]
+    end
+  end
+
+  context ".simple_singularize" do
+    it "returns hardcoded values for special words" do
+      pair = {
+        "audit_entries" => "audit_entry",
+        "ip_addresses" => "ip_address",
+        "processes" => "process"
+      }
+      pair.keys.each do |key|
+        simple_singularize(key).should == pair[key]
+      end
+    end
+
+    it "returns choped word for general work" do
+      word = "RightScale"
+      simple_singularize(word).should == word.chop
+    end
+  end
+
+  context ".get_singular" do
+    it "returns downcased singular form of word" do
+      word = "RightScale"
+      get_singular(word).should == simple_singularize(word.to_s.downcase)
+    end
+  end
+
+  context ".fix_array_of_hashes" do
+    it "fixes all the keys that have the value as array of hashes" do
+      res = fix_array_of_hashes(
+          'a' => '1',
+          'b' => [1, 2, 3],
+          'c' => {1 => 2, 3 => 4},
+          'd' => [
+              {5 => 6, 7 => 8},
+              {9 => 10, 11 => 12}
+          ]
+      )
+
+      res.should == {
+          'a' => '1',
+          'b' => [1, 2, 3],
+          'c' => {1 => 2, 3 => 4},
+          'd[]' => [
+              {5 => 6, 7 => 8},
+              {9 => 10, 11 => 12}
+          ]
+      }
+    end
+
+    it "fixes key that have a top-level array of hashes as value" do
+      res = fix_array_of_hashes(
+          'a' => [
+              {1 => 2},
+              {3 => 4}
+          ]
+      )
+
+      res.should == {
+          'a[]' => [
+              {1 => 2},
+              {3 => 4}
+          ]
+      }
+    end
+
+    it "fixes key that have a nested array of hashes as value" do
+      res = fix_array_of_hashes(
+          'a' => {
+              'b' => [
+                  {1 => 2},
+                  {3 => 4}
+              ]
+          }
+      )
+
+      res.should == {
+          'a' => {
+              'b' => {
+                  '' => [
+                      {1 => 2},
+                      {3 => 4}
+                  ]
+              }
+          }
+      }
+    end
+  end
+end

data/spec/unit/instance_facing_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe RightApi::Client, :unit=>true do
+  context "given an instance-facing logged in RightScale user" do
+    before(:each) do
+      given_instance_facing_client
+    end
+
+    it "has the required methods for the client" do
+      @client.api_methods.sort.collect{|s| s.to_s}.should == ["backups", "get_instance", "live_tasks", "tags","volume_attachments", "volume_snapshots", "volume_types", "volumes"]
+    end
+
+    it "returns an instance of the Resource class when user provides an id" do
+      @client.volumes(:id => 1).class.should    == RightApi::Resource
+      @client.backups(:id => 1).class.should    == RightApi::Resource
+      @client.live_tasks(:id => 1).class.should == RightApi::Resource
+    end
+
+    it "returns an instance of the Resources class when user does not provide an id" do
+      @client.volumes.class.should == RightApi::Resources
+      @client.backups.class.should == RightApi::Resources
+      @client.tags.class.should == RightApi::Resources
+    end
+  end
+end

data/spec/unit/resource_detail_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe RightApi::ResourceDetail, :unit=>true do
+  before(:each) do
+    given_user_facing_client
+  end
+
+  subject {RightApi::ResourceDetail.new(@client, 'resource_detail', '/api/resource_detail', {})}
+
+  context "attributes" do
+    its(:client) {should eq @client}
+    its(:attributes) {should eq Set.new << :links}
+    its(:resource_type) {should eq 'resource_detail'}
+    its(:associations) {should eq Set.new}
+    its(:actions) {should eq Set.new}
+    its(:raw) {should eq Hash.new}
+  end
+
+  context ".inspect" do
+    let(:resource_detail){RightApi::ResourceDetail.new(@client, 'resource_detail', '/api/resource_detail', {})}
+    it "returns correct inspect infos" do
+      inspect_text = "#<#{resource_detail.class.name} resource_type=\"#{resource_detail.resource_type}\">"
+      resource_detail.inspect.should == inspect_text
+    end
+  end
+
+  context "given a logged in RightScale user" do
+
+    it "has the required methods for instances of the ResourceDetail class" do
+      resource = RightApi::ResourceDetail.new(@client, 'deployment', '/api/deployments/1', {})
+      resource.api_methods.sort.collect{|s| s.to_s}.should == ["destroy", "links", "show", "update"]
+    end
+
+    it "has resource-specific methods for instances of the ResourceDetail class" do
+      resource = RightApi::ResourceDetail.new(@client, 'deployment', '/api/deployments/1',
+                                              {:attribute1 => 'value1', :attribute2 => 'value2'})
+      resource.api_methods.sort.collect{|s| s.to_s}.should == ["attribute1", "attribute2", "destroy", "links", "show", "update"]
+    end
+
+    it "has the links for instances of the ResourceDetail class" do
+      resource = RightApi::ResourceDetail.new(@client, 'deployment', '/api/deployments/1',
+                                              {'links' => [{'rel' => 'link1', 'href' => 'link1_href'},
+                                                           {'rel' => 'link2', 'href' => 'link2_href'}]})
+      resource.api_methods.sort.collect{|s| s.to_s}.should == ["destroy", "link1", "link2", "links", "show", "update"]
+    end
+
+    it "has the actions for instances of the ResourceDetail class" do
+      resource = RightApi::ResourceDetail.new(@client, 'deployment', '/api/deployments/1',
+                                              {'links' => [{'rel' => 'self', 'href' => 'self'}],
+                                               'actions' => [{'rel' => 'action1'}, {'rel' => 'action2'}]})
+      resource.api_methods.sort.collect{|s| s.to_s}.should == ["action1", "action2", "destroy", "href", "links", "show", "update"]
+
+      flexmock(@rest_client).should_receive(:post).with({}, @header, Proc).and_return('ok')
+      resource.action1.should == 'ok'
+    end
+
+    it "has live_tasks for the 'instance' resource" do
+      resource = RightApi::ResourceDetail.new(@client, 'instance', '/api/instances/1', {})
+      resource.api_methods.sort.collect{|s| s.to_s}.should == ["destroy", "links", "live_tasks", "show", "update"]
+      flexmock(RightApi::Resource).should_receive(:process).with(@client, 'live_task', '/api/instances/1/live/tasks/1').and_return('ok')
+      resource.live_tasks(:id => '1').should == 'ok'
+    end
+
+    it "adds methods for child resources from detailed views" do
+      resource = RightApi::ResourceDetail.new(@client, 'server', '/api/servers/1', {
+          'links' => [
+              {'href' => '/api/servers/1', 'rel' => 'self'},
+              {'href' => '/api/clouds/1/instances/1', 'rel' => 'current_instance'}],
+          'current_instance' => {'links' => [{'href' => '/api/clouds/1/instances/1', 'rel' => 'self'}]}})
+      resource.api_methods.collect{|s| s.to_s}.sort.should == ["current_instance", "destroy", "href", "links", "show", "update"]
+    end
+  end
+
+  context ".[]" do
+    let(:resource) { RightApi::ResourceDetail.new(@client, 'deployment', '/api/deployments/1',
+                                            {'links' => [{'rel' => 'link1', 'href' => 'link1_href'}],
+                                             'real_attribute'=>'hi mom',
+                                             'link1' => 'sneaky'}) }
+
+    it 'reads attributes whose name overlaps with a link' do
+      resource['link1'].should == 'sneaky'
+      resource.link1.should_not == resource['link1']
+    end
+
+    it 'accepts String keys' do
+      resource['real_attribute'].should == 'hi mom'
+    end
+
+    it 'accepts Symbol keys' do
+      resource[:real_attribute].should == 'hi mom'
+    end
+  end
+end

data/spec/unit/resource_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe RightApi::Resource, :unit=>true do
+  before(:each) do
+    given_user_facing_client
+  end
+
+  subject {RightApi::Resource.new(@client, 'resource', '/api/resource')}
+
+  context "attributes" do
+    its(:client) {should eq @client}
+    its(:href) {should eq '/api/resource'}
+    its(:resource_type) {should eq 'resource'}
+  end
+
+  context "#process" do
+    it "creates resource_detail with data" do
+      flexmock(RightApi::ResourceDetail).should_receive(:new)
+      RightApi::Resource.process(@client, 'resource', '/api/resource', :right => ['scale'])
+    end
+
+    it "creates resource without data" do
+      flexmock(RightApi::Resource).should_receive(:new)
+      RightApi::Resource.process(@client, 'resource', '/api/resource')
+    end
+  end
+
+  context "#process_detailed" do
+    it "calls process with data array" do
+      flexmock(RightApi::Resource).should_receive(:process)
+      RightApi::Resource.process(@client, 'resource', '/api/resource', :right => ['scale'])
+    end
+
+    it "calls process with data array" do
+      flexmock(RightApi::Resource).should_receive(:process)
+      RightApi::Resource.process(@client, 'resource', '/api/resource')
+    end
+
+    it "creates new process detail with data links" do
+      flexmock(RightApi::ResourceDetail).should_receive(:new)
+      RightApi::Resource.process(@client, 'resource', '/api/resource', 'links' => 'scale')
+    end
+  end
+
+  context ".inspect" do
+    let(:resource) {RightApi::Resource.new(@client, 'resource', '/api/resource')}
+    it "returns correct inspect text" do
+      inspect_text = "#<#{resource.class.name} resource_type=\"#{resource.resource_type}\">"
+      resource.inspect.should == inspect_text
+    end
+  end
+
+  context ".method_missing" do
+    it "sends correct post request" do
+      client = flexmock(@client)
+      resource = RightApi::Resource.new(client, 'resource', '/api/resource')
+      client.should_receive(:send).with(:do_post, "#{resource.href}/method")
+      resource.method_missing('method')
+    end
+  end
+
+  context "given a logged in RightScale user" do
+    it "has the required methods for instances of the Resource class" do
+      resource = RightApi::Resource.process(@client, 'deployment', '/api/deployments/1')
+      resource.api_methods.sort.map(&:to_s).should == %w[ destroy show update ]
+    end
+
+    it "has destroy/show/update for all instances of the Resource class" do
+      resource = RightApi::Resource.process(@client, 'session', '/api/session')
+      resource.api_methods.sort.map(&:to_s).should == %w[ destroy show update ]
+    end
+
+    it "has an array of ResourceDetail instances for index calls" do
+      resources = RightApi::Resource.process(@client, 'deployment', '/api/deployments', [{}])
+      resources.first.class.should == RightApi::ResourceDetail
+    end
+  end
+end