bbrowning-deltacloud-core 0.0.1.1 → 0.0.3.1

data/server.rb

@@ -1,21 +1,18 @@
-require 'rubygems'
+require 'sinatra'
 require 'deltacloud'
+require 'drivers'
 require 'json'
-require 'sinatra'
 require 'sinatra/respond_to'
-require 'erb'
-require 'haml'
-require 'open3'
-require 'builder'
-require 'drivers'
 require 'sinatra/static_assets'
 require 'sinatra/rabbit'
 require 'sinatra/lazy_auth'
-require 'deltacloud/validation'
-require 'deltacloud/helpers'
+require 'erb'
+require 'haml'
+require 'open3'
 
 configure do
   set :raise_errors => false
+  set :show_exceptions, false
 end
 
 configure :development do
@@ -24,59 +21,10 @@ configure :development do
   $stderr.sync = true
 end
 
-DRIVER=ENV['API_DRIVER'] ? ENV['API_DRIVER'].to_sym : :mock
-
 # You could use $API_HOST environment variable to change your hostname to
 # whatever you want (eg. if you running API behind NAT)
 HOSTNAME=ENV['API_HOST'] ? ENV['API_HOST'] : nil
 
-Rack::Mime::MIME_TYPES.merge!({ ".gv" => "text/plain" })
-
-Sinatra::Application.register Sinatra::RespondTo
-
-# Common actions
-#
-
-def filter_all(model)
-    filter = {}
-    filter.merge!(:id => params[:id]) if params[:id]
-    filter.merge!(:architecture => params[:architecture]) if params[:architecture]
-    filter.merge!(:owner_id => params[:owner_id]) if params[:owner_id]
-    filter.merge!(:state => params[:state]) if params[:state]
-    filter = nil if filter.keys.size.eql?(0)
-    singular = model.to_s.singularize.to_sym
-    @elements = driver.send(model.to_sym, credentials, filter)
-    instance_variable_set(:"@#{model}", @elements)
-    respond_to do |format|
-      format.html { haml :"#{model}/index" }
-      format.xml { haml :"#{model}/index" }
-      format.json { convert_to_json(singular, @elements) }
-    end
-end
-
-def show(model)
-  @element = driver.send(model, credentials, { :id => params[:id]} )
-  instance_variable_set("@#{model}", @element)
-  respond_to do |format|
-    format.html { haml :"#{model.to_s.pluralize}/show" }
-    format.xml { haml :"#{model.to_s.pluralize}/show" }
-    format.json { convert_to_json(model, @element) }
-  end
-end
-
-
-#
-# Error handlers
-#
-def report_error(status, template)
-  @error = request.env['sinatra.error']
-  response.status = status
-  respond_to do |format|
-    format.xml { haml :"errors/#{template}", :layout => false }
-    format.html { haml :"errors/#{template}" }
-  end
-end
-
 error Deltacloud::Validation::Failure do
   report_error(400, "validation_failure")
 end
@@ -93,7 +41,7 @@ end
 get '/' do redirect url_for('/api'); end
 
 get '/api\/?' do
-    @version = 1.0
+    @version = 0.1
     respond_to do |format|
         format.xml { haml :"api/show" }
         format.json do
@@ -111,10 +59,20 @@ end
 # Rabbit DSL
 
 collection :realms do
-  description "Within a cloud provider a realm represents a boundary containing resources. The exact definition of a realm is left to the cloud provider. In some cases, a realm may represent different datacenters, different continents, or different pools of resources within a single datacenter. A cloud provider may insist that resources must all exist within a single realm in order to cooperate. For instance, storage volumes may only be allowed to be mounted to instances within the same realm."
+  description <<END
+  Within a cloud provider a realm represents a boundary containing resources.
+  The exact definition of a realm is left to the cloud provider.
+  In some cases, a realm may represent different datacenters, different continents,
+  or different pools of resources within a single datacenter.
+  A cloud provider may insist that resources must all exist within a single realm in
+  order to cooperate. For instance, storage volumes may only be allowed to be mounted to
+  instances within the same realm.
+END
 
   operation :index do
-    description 'Operation will list all available realms. For specific architecture use "architecture" parameter.'
+    description <<END
+    Operation will list all available realms. For specific architecture use "architecture" parameter.
+END
     param :id,            :string
     param :architecture,  :string,  :optional,  [ 'i386', 'x86_64' ]
     control { filter_all(:realms) }
@@ -130,10 +88,17 @@ collection :realms do
 end
 
 collection :images do
-  description "An image is a platonic form of a machine. Images are not directly executable, but are a template for creating actual instances of machines."
+  description <<END
+  An image is a platonic form of a machine. Images are not directly executable,
+  but are a template for creating actual instances of machines."
+END
 
   operation :index do
-    description 'The instances collection will return a set of all images available to the current use. You can filter images using "owner_id" and "architecture" parameter'
+    description <<END
+    The instances collection will return a set of all images
+    available to the current use. You can filter images using
+    "owner_id" and "architecture" parameter
+END
     param :id,            :string
     param :owner_id,      :string
     param :architecture,  :string,  :optional
@@ -196,20 +161,11 @@ get "/api/instances/new" do
   end
 end
 
-def instance_action(name)
-  @instance = driver.send(:"#{name}_instance", credentials, params["id"])
-
-  return redirect(instances_url) if name.eql?(:destroy) or @instance.class!=Instance
-
-  respond_to do |format|
-    format.html { haml :"instances/show" }
-    format.xml { haml :"instances/show" }
-    format.json {convert_to_json(:instance, @instance) }
-  end
-end
-
 collection :instances do
-  description "An instance is a concrete machine realized from an image. The images collection may be obtained by following the link from the primary entry-point."
+  description <<END
+  An instance is a concrete machine realized from an image.
+  The images collection may be obtained by following the link from the primary entry-point."
+END
 
   operation :index do
     description "List all instances"
@@ -299,10 +255,14 @@ END
     param :id,          :string,    :required
     control do
       @profile =  driver.hardware_profile(credentials, params[:id])
-      respond_to do |format|
-        format.xml { haml :'hardware_profiles/show', :layout => false }
-        format.html { haml :'hardware_profiles/show' }
-        format.json { convert_to_json(:hardware_profile, @profile) }
+      if @profile
+        respond_to do |format|
+          format.xml { haml :'hardware_profiles/show', :layout => false }
+          format.html { haml :'hardware_profiles/show' }
+          format.json { convert_to_json(:hardware_profile, @profile) }
+        end
+      else
+        report_error(404, 'not_found')
       end
     end
   end

data/tests/api_test.rb

@@ -0,0 +1,37 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class ApiTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_returns_entry_points
+      do_xml_request '/api'
+      (last_xml_response/'/api/link').map.size.should > 0
+    end
+
+    def test_it_has_correct_attributes_set
+      do_xml_request '/api'
+      (last_xml_response/'/api/link').each do |link|
+        link.attributes.keys.sort.should == [ 'href', 'rel' ]
+      end
+    end
+
+    def test_it_responses_to_html
+      do_request '/api', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    def test_it_responses_to_json
+      do_request '/api', {}, false, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['api'].class.should == Hash
+    end
+
+  end
+end

data/tests/hardware_profiles_test.rb

@@ -0,0 +1,120 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class HardwareProfilesTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_returns_hardware_profiles
+      do_xml_request '/api/hardware_profiles'
+      (last_xml_response/'hardware_profiles/hardware_profile').map.size.should > 0
+    end
+
+    def test_it_has_correct_attributes_set
+      do_xml_request '/api/hardware_profiles'
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        profile.attributes.keys.sort.should == [ 'href', 'id' ]
+      end
+    end
+
+    def test_hardware_profiles_have_name
+      do_xml_request '/api/hardware_profiles'
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        (profile/'name').text.should_not == nil
+      end
+    end
+
+    def test_hardware_profiles_have_unique_name
+      do_xml_request '/api/hardware_profiles'
+      names = []
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        names << (profile/'name').text
+      end
+      names.should == names.uniq
+    end
+
+    def test_hardware_profiles_have_unique_id
+      do_xml_request '/api/hardware_profiles'
+      ids = []
+      (last_xml_response/'hardware_profiles/hardware_profile').each do |profile|
+        ids << profile['id']
+      end
+      ids.should == ids.uniq
+    end
+
+    def test_m1_xlarge_profile_has_correct_attributes
+      do_xml_request '/api/hardware_profiles'
+      profile = (last_xml_response/'hardware_profiles/hardware_profile[@id="m1-xlarge"]')
+      test_profile_properties(profile)
+    end
+
+    def test_it_returns_valid_hardware_profile
+      do_xml_request '/api/hardware_profiles/m1-xlarge'
+      profile = (last_xml_response/'hardware_profile')
+      test_profile_properties(profile)
+    end
+
+    def test_it_responses_to_json
+      do_request '/api/hardware_profiles', {}, false, { :format => :json }
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['hardware_profiles'].class.should == Array
+
+      do_request '/api/hardware_profiles/m1-xlarge', {}, false, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['hardware_profile'].class.should == Hash
+    end
+
+    def test_it_responses_to_html
+      do_request '/api/hardware_profiles', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+
+      do_request '/api/hardware_profiles/m1-xlarge', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    def test_it_returns_error_on_wrong_name
+      do_request '/api/hardware_profiles/m1-unknown-wrongname', {}, false, { :format => :html }
+      last_response.status.should == 404
+      do_xml_request '/api/hardware_profiles/m1-unknown-wrongname'
+      last_response.status.should == 404
+      do_request '/api/hardware_profiles/m1-unknown-wrongname', {}, false, { :format => :json }
+      last_response.status.should == 404
+    end
+
+    private
+
+    def test_profile_properties(profile)
+      
+      (profile/'property').each do |properties|
+        properties.attributes.keys.sort.should == [ 'kind', 'name', 'unit', 'value' ]
+      end
+
+      (profile/'property[@name="architecture"]').first['kind'].should == 'fixed'
+      (profile/'property[@name="architecture"]').first['unit'].should == 'label'
+      
+      (profile/'property[@name="memory"]').first['kind'].should == 'range'
+      (profile/'property[@name="memory"]').first['unit'].should == 'MB'
+      (profile/'property[@name="memory"]/range').size.should == 1
+      (profile/'property[@name="memory"]/range').first.attributes.keys.sort.should == [ 'first', 'last' ]
+
+      (profile/'property[@name="cpu"]').first['kind'].should == 'fixed'
+      (profile/'property[@name="cpu"]').first['unit'].should == 'count'
+      
+      (profile/'property[@name="storage"]').first['kind'].should == 'enum'
+      (profile/'property[@name="storage"]').first['unit'].should == 'GB'
+      (profile/'property[@name="storage"]/enum').size.should == 1
+      (profile/'property[@name="storage"]/enum/entry').map.size.should == 3
+      (profile/'property[@name="storage"]/enum/entry').each do |entry|
+        entry.attributes.keys.should == [ 'value' ]
+        entry['value'].should_not == nil
+      end
+    end
+
+  end
+end

data/tests/images_test.rb

@@ -1,94 +1,111 @@
-require 'tests/deltacloud_test'
+require 'tests/common'
 
-class ImagesTest < Test::Unit::TestCase
+module DeltacloudUnitTest
+  class HardwareProfilesTest < Test::Unit::TestCase
+    include Rack::Test::Methods
 
-  def initialize(*args)
-    @collection = 'images'
-    @operations = [:index, :show]
-    @params = {}
-    super(*args)
-  end
+    def app
+      Sinatra::Application
+    end
 
-  def test_if_images_are_not_empty
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_not_equal 0, doc.xpath('/images/image').size
-  end
+    def test_it_require_authentication
+      require_authentication?('/api/images').should == true
+    end
 
-  [:id, :owner_id, :name, :description, :architecture].each do |option|
-    method_name = :"test_if_images_index_contain_#{option}"
-    send :define_method, method_name do
-      get '/api/images.xml', @params, rack_headers
-      doc = Nokogiri::XML.parse(last_response.body)
-      elt = doc.xpath('/images/image[1]').first
-      assert_not_nil elt.xpath(option.to_s).first
+    def test_it_returns_images
+      do_xml_request '/api/images', {}, true
+      (last_xml_response/'images/image').map.size.should > 0
     end
-  end
 
-  [:id, :owner_id, :name, :description, :architecture].each do |option|
-    method_name = :"test_if_image_show_contain_#{option}"
-    send :define_method, method_name do
-      get '/api/images/img1.xml', @params, rack_headers
-      doc = Nokogiri::XML.parse(last_response.body)
-      elt = doc.xpath('/image').first
-      assert_not_nil elt.xpath(option.to_s).first
+    def test_it_has_correct_attributes_set
+      do_xml_request '/api/images', {}, true
+      (last_xml_response/'images/image').each do |image|
+        image.attributes.keys.sort.should == [ 'href', 'id' ]
+      end
     end
-  end
 
-  def test_images_filtering_by_id
-    @params={ :id => 'img1' }
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_equal 1, doc.xpath('/images/image').size
-    assert_equal @params[:id], doc.xpath('/images/image/id').first.text
-  end
+    def test_img1_has_correct_attributes
+      do_xml_request '/api/images', {}, true
+      image = (last_xml_response/'images/image[@id="img1"]')
+      test_image_attributes(image)
+    end
 
-  def test_images_filtering_by_owner_id
-    @params={ :owner_id => 'fedoraproject' }
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_equal 2, doc.xpath('/images/image').size
-    assert_equal @params[:owner_id], doc.xpath('/images/image/owner_id')[0].text
-    assert_equal @params[:owner_id], doc.xpath('/images/image/owner_id')[1].text
-  end
+    def test_it_returns_valid_image
+      do_xml_request '/api/images/img1', {}, true
+      image = (last_xml_response/'image')
+      test_image_attributes(image)
+    end
 
-  def test_images_filtering_by_architecture
-    @params={ :architecture => 'i386' }
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_equal 2, doc.xpath('/images/image').size
-    assert_equal @params[:architecture], doc.xpath('/images/image/architecture')[0].text
-    assert_equal @params[:architecture], doc.xpath('/images/image/architecture')[1].text
-  end
+    def test_it_has_unique_ids
+      do_xml_request '/api/images', {}, true
+      ids = []
+      (last_xml_response/'images/image').each do |image|
+        ids << image['id'].to_s
+      end
+      ids.sort.should == ids.sort.uniq
+    end
 
-  def test_images_filtering_by_id_and_owner_id
-    @params={ :id => 'img1', :owner_id => 'fedoraproject' }
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_equal 1, doc.xpath('/images/image').size
-    assert_equal @params[:owner_id], doc.xpath('/images/image/owner_id')[0].text
-    assert_equal @params[:id], doc.xpath('/images/image/id')[0].text
-  end
+    def test_it_has_valid_urls
+      do_xml_request '/api/images', {}, true
+      ids = []
+      images = (last_xml_response/'images/image')
+      images.each do |image|
+        do_xml_request image['href'].to_s, {}, true
+        (last_xml_response/'image').first['href'].should == image['href'].to_s
+      end
+    end
 
-  def test_images_filtering_by_id_and_owner_id_and_architecture
-    @params={ :id => 'img1', :owner_id => 'fedoraproject', :architecture => 'x86_64' }
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_equal 1, doc.xpath('/images/image').size
-    assert_equal @params[:owner_id], doc.xpath('/images/image/owner_id')[0].text
-    assert_equal @params[:id], doc.xpath('/images/image/id')[0].text
-    assert_equal @params[:architecture], doc.xpath('/images/image/architecture')[0].text
-  end
+    def test_it_can_filter_using_owner_id
+      do_xml_request '/api/images', { :owner_id => 'mockuser' }, true
+      (last_xml_response/'images/image').size.should == 1
+      (last_xml_response/'images/image/owner_id').first.text.should == 'mockuser'
+    end
 
-  def test_images_filtering_by_id_and_architecture
-    @params={ :id => 'img1', :architecture => 'x86_64' }
-    get '/api/images.xml', @params, rack_headers
-    doc = Nokogiri::XML.parse(last_response.body)
-    assert_equal 1, doc.xpath('/images/image').size
-    assert_equal @params[:id], doc.xpath('/images/image/id')[0].text
-    assert_equal @params[:architecture], doc.xpath('/images/image/architecture')[0].text
-  end
+    def test_it_can_filter_using_unknown_owner_id
+      do_xml_request '/api/images', { :architecture => 'unknown_user' }, true
+      (last_xml_response/'images/image').size.should == 0
+    end
+
+    def test_it_can_filter_using_architecture
+      do_xml_request '/api/images', { :architecture => 'x86_64' }, true
+      (last_xml_response/'images/image').size.should == 1
+      (last_xml_response/'images/image/architecture').first.text.should == 'x86_64'
+    end
 
-  include DeltacloudTest
+    def test_it_can_filter_using_unknown_architecture
+      do_xml_request '/api/images', { :architecture => 'unknown_arch' }, true
+      (last_xml_response/'images/image').size.should == 0
+    end
+
+    def test_it_responses_to_json
+      do_request '/api/images', {}, true, { :format => :json }
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['images'].class.should == Array
+
+      do_request '/api/images/img1', {}, true, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['image'].class.should == Hash
+    end
 
+    def test_it_responses_to_html
+      do_request '/api/images', {}, true, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+
+      do_request '/api/images/img1', {}, true, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    private
+
+    def test_image_attributes(image)
+      (image/'name').text.should_not nil
+      (image/'owner_id').text.should_not nil
+      (image/'description').text.should_not nil
+      (image/'architecture').text.should_not nil
+    end
+
+  end
 end

data/tests/instance_states_test.rb

@@ -0,0 +1,52 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class RealmsTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_not_require_authentication
+      require_authentication?('/api/realms').should_not == true
+    end
+
+    def test_it_returns_instance_states
+      do_xml_request '/api/instance_states', {}, true
+      (last_xml_response/'states/state').map.size.should > 0
+    end
+
+    def test_each_state_has_transition
+      do_xml_request '/api/instance_states', {}, true
+      (last_xml_response/'states/state').each do |state|
+        next if state['name'].eql?('finish') # Finnish state doesn't have transitions
+        (state/'transition').map.size.should > 0
+        (state/'transition').each do |transition|
+          transition['to'].should_not == nil
+        end
+      end
+    end
+
+    def test_it_responses_to_json
+      do_request '/api/instance_states', {}, false, { :format => :json }
+      JSON::parse(last_response.body).class.should == Array
+      JSON::parse(last_response.body).first['transitions'].class.should == Array
+      JSON::parse(last_response.body).first['name'].should == 'start'
+    end
+
+    def test_it_responses_to_html
+      do_request '/api/instance_states', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    def test_it_responses_to_png
+      do_request '/api/instance_states', {}, false, { :format => :png }
+      last_response.status.should == 200
+      last_response.headers['Content-Type'].should == 'image/png'
+      #last_response.headers['Content-Length'].should == '4371'
+    end
+
+  end
+end