bbrowning-deltacloud-core 0.0.4-java

data/tests/images_test.rb

@@ -0,0 +1,111 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class HardwareProfilesTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_require_authentication
+      require_authentication?('/api/images').should == true
+    end
+
+    def test_it_returns_images
+      do_xml_request '/api/images', {}, true
+      (last_xml_response/'images/image').map.size.should > 0
+    end
+
+    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
+
+    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_it_returns_valid_image
+      do_xml_request '/api/images/img1', {}, true
+      image = (last_xml_response/'image')
+      test_image_attributes(image)
+    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_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_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_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
+
+    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

data/tests/instances_test.rb

@@ -0,0 +1,219 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class InstancesTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_require_authentication
+      require_authentication?('/api/instances').should == true
+    end
+
+    def test_it_returns_instances
+      do_xml_request '/api/instances', {}, true
+      (last_xml_response/'instances/instance').map.size.should > 0
+    end
+
+    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
+
+    def test_it_has_unique_ids
+      do_xml_request '/api/instances', {}, true
+      ids = []
+      (last_xml_response/'instances/instance').each do |image|
+        ids << image['id'].to_s
+      end
+      ids.sort.should == ids.sort.uniq
+    end
+
+    def test_inst1_has_correct_attributes
+      do_xml_request '/api/instances', {}, true
+      instance = (last_xml_response/'instances/instance[@id="inst1"]')
+      test_instance_attributes(instance)
+    end
+
+    def test_it_returns_valid_realm
+      do_xml_request '/api/instances/inst1', {}, true
+      instance = (last_xml_response/'instance')
+      test_instance_attributes(instance)
+    end
+
+    def test_it_responses_to_json
+      do_request '/api/instances', {}, true, { :format => :json }
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['instances'].class.should == Array
+
+      do_request '/api/instances/inst1', {}, true, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['instance'].class.should == Hash
+    end
+
+    def test_it_responses_to_html
+      do_request '/api/instances', {}, true, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+
+      do_request '/api/instances/inst1', {}, true, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    def test_it_create_a_new_instance_using_image_id
+      params = {
+        :image_id => 'img1'
+      }
+      post '/api/instances', params, authenticate(:format => :xml)
+      last_response.status.should == 302
+      last_response.headers['Location'].should_not == nil
+      do_xml_request last_response.headers['Location'], {}, true
+      (last_xml_response/'instance/name').should_not == nil
+      add_created_instance (last_xml_response/'instance').first['id']
+      test_instance_attributes(last_xml_response/'instance')
+    end
+
+    def test_it_create_a_new_instance_using_image_id_and_name
+      params = {
+        :image_id => 'img1',
+        :name => "unit_test_instance1"
+      }
+      post '/api/instances', params, authenticate(:format => :xml)
+      last_response.status.should == 302
+      last_response.headers['Location'].should_not == nil
+      do_xml_request last_response.headers['Location'], {}, true
+      (last_xml_response/'instance/name').text.should == 'unit_test_instance1'
+      add_created_instance (last_xml_response/'instance').first['id']
+      test_instance_attributes(last_xml_response/'instance')
+    end
+
+    def test_it_create_a_new_instance_using_image_id_and_name_and_hwp
+      params = {
+        :image_id => 'img1',
+        :name => "unit_test_instance1",
+        :hwp_id => "m1-xlarge"
+      }
+      post '/api/instances', params, authenticate(:format => :xml)
+      last_response.status.should == 302
+      last_response.headers['Location'].should_not == nil
+      do_xml_request last_response.headers['Location'], {}, true
+      (last_xml_response/'instance/name').text.should == 'unit_test_instance1'
+      (last_xml_response/'instance/hardware_profile').first['id'].should == 'm1-xlarge'
+      add_created_instance (last_xml_response/'instance').first['id']
+      test_instance_attributes(last_xml_response/'instance')
+    end
+
+    def test_it_z0_stop_and_start_instance
+      $created_instances.each do |instance_id|
+        do_xml_request "/api/instances/#{instance_id}", {}, true
+        stop_url = (last_xml_response/'actions/link[@rel="stop"]').first['href']
+        stop_url.should_not == nil
+        post create_url(stop_url), {}, authenticate(:format => :xml)
+        last_response.status.should == 200
+        instance = Nokogiri::XML(last_response.body)
+        test_instance_attributes(instance)
+        (instance/'state').text.should == 'STOPPED'
+        do_xml_request "/api/instances/#{instance_id}", {}, true
+        start_url = (last_xml_response/'actions/link[@rel="start"]').first['href']
+        start_url.should_not == nil
+        post create_url(start_url), {}, authenticate(:format => :xml)
+        last_response.status.should == 200
+        instance = Nokogiri::XML(last_response.body)
+        test_instance_attributes(instance)
+        (instance/'state').text.should == 'RUNNING'
+      end
+    end
+
+    def test_z0_reboot_instance
+      $created_instances.each do |instance_id|
+        do_xml_request "/api/instances/#{instance_id}", {}, true
+        reboot_url = (last_xml_response/'actions/link[@rel="reboot"]').first['href']
+        reboot_url.should_not == nil
+        post create_url(reboot_url), {}, authenticate(:format => :xml)
+        last_response.status.should == 200
+        instance = Nokogiri::XML(last_response.body)
+        test_instance_attributes(instance)
+        (instance/'state').text.should == 'RUNNING'
+      end
+    end
+
+    def test_z1_stop_created_instances
+      $created_instances.each do |instance_id|
+        do_xml_request "/api/instances/#{instance_id}", {}, true
+        stop_url = (last_xml_response/'actions/link[@rel="stop"]').first['href']
+        stop_url.should_not == nil
+        post create_url(stop_url), {}, authenticate(:format => :xml)
+        last_response.status.should == 200
+        instance = Nokogiri::XML(last_response.body)
+        test_instance_attributes(instance)
+        (instance/'state').text.should == 'STOPPED'
+      end
+    end
+
+    def test_z2_destroy_created_instances
+      $created_instances.each do |instance_id|
+        do_xml_request "/api/instances/#{instance_id}", {}, true
+        destroy_url = (last_xml_response/'actions/link[@rel="destroy"]').first['href']
+        destroy_url.should_not == nil
+        delete create_url(destroy_url), {}, authenticate(:format => :xml)
+        last_response.status.should == 302
+        do_xml_request last_response.headers['Location'], {}, true
+        (last_xml_response/'instances').should_not == nil
+        do_xml_request "/api/instances/#{instance_id}", {}, true
+        last_response.status.should == 404
+      end
+    end
+
+    private
+
+    def test_instance_attributes(instance)
+      (instance/'name').should_not == nil
+      (instance/'owner_id').should_not == nil
+      ['RUNNING', 'STOPPED'].include?((instance/'state').text).should == true
+
+      (instance/'public_addreses').should_not == nil
+      (instance/'public_addresses/address').map.size.should > 0
+      (instance/'public_addresses/address').first.text.should_not == ""
+
+      (instance/'private_addresses').should_not == nil
+      (instance/'private_addresses/address').map.size.should > 0
+      (instance/'private_addresses/address').first.text.should_not == ""
+
+      (instance/'actions/link').map.size.should > 0
+      (instance/'actions/link').each do |link|
+        link['href'].should_not == ""
+        link['rel'].should_not == ""
+        link['method'].should_not == ""
+        ['get', 'post', 'delete', 'put'].include?(link['method']).should == true
+      end
+
+      (instance/'image').size.should > 0
+      (instance/'image').first['href'].should_not == ""
+      (instance/'image').first['id'].should_not == ""
+      do_xml_request (instance/'image').first['href'], {}, true
+      (last_xml_response/'image').should_not == nil
+      (last_xml_response/'image').first['href'] == (instance/'image').first['href']
+
+      (instance/'realm').size.should > 0
+      (instance/'realm').first['href'].should_not == ""
+      (instance/'realm').first['id'].should_not == ""
+      do_xml_request (instance/'realm').first['href']
+      (last_xml_response/'realm').should_not == nil
+      (last_xml_response/'realm').first['href'] == (instance/'realm').first['href']
+
+      (instance/'hardware_profile').size.should > 0
+      (instance/'hardware_profile').first['href'].should_not == ""
+      (instance/'hardware_profile').first['id'].should_not == ""
+      do_xml_request (instance/'hardware_profile').first['href']
+      (last_xml_response/'hardware_profile').should_not == nil
+      (last_xml_response/'hardware_profile').first['href'] == (instance/'hardware_profile').first['href']
+    end
+
+  end
+end

data/tests/realms_test.rb

@@ -0,0 +1,78 @@
+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_realms
+      do_xml_request '/api/realms', {}, true
+      (last_xml_response/'realms/realm').map.size.should > 0
+    end
+
+    def test_it_has_correct_attributes_set
+      do_xml_request '/api/realms', {}, true
+      (last_xml_response/'realms/realm').each do |realm|
+        realm.attributes.keys.sort.should == [ 'href', 'id' ]
+      end
+    end
+
+    def test_us_has_correct_attributes
+      do_xml_request '/api/realms', {}, true
+      realm = (last_xml_response/'realms/realm[@id="us"]')
+      test_realm_attributes(realm)
+    end
+
+    def test_it_returns_valid_realm
+      do_xml_request '/api/realms/us', {}, true
+      realm = (last_xml_response/'realm')
+      test_realm_attributes(realm)
+    end
+
+    def test_it_has_unique_ids
+      do_xml_request '/api/realms', {}, true
+      ids = []
+      (last_xml_response/'realms/realm').each do |realm|
+        ids << realm['id'].to_s
+      end
+      ids.sort.should == ids.sort.uniq
+    end
+
+    def test_it_responses_to_json
+      do_request '/api/realms', {}, false, { :format => :json }
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['realms'].class.should == Array
+
+      do_request '/api/realms/us', {}, false, { :format => :json }
+      last_response.status.should == 200
+      JSON::parse(last_response.body).class.should == Hash
+      JSON::parse(last_response.body)['realm'].class.should == Hash
+    end
+
+    def test_it_responses_to_html
+      do_request '/api/realms', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+
+      do_request '/api/realms/us', {}, false, { :format => :html }
+      last_response.status.should == 200
+      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+    end
+
+    private
+
+    def test_realm_attributes(realm)
+      (realm/'name').should_not == nil
+      (realm/'limit').should_not == nil
+      ['AVAILABLE'].include?((realm/'state').text).should == true
+    end
+
+  end
+end

data/tests/url_for_test.rb

@@ -0,0 +1,50 @@
+require 'tests/common'
+
+module DeltacloudUnitTest
+  class UrlForTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
+
+    def test_it_works_for_root
+      verify_url_for("/", "/")
+    end
+
+    def test_it_works_for_root_absolute
+      verify_url_for("/", "http://localhost/", :full)
+    end
+
+    def test_it_works_with_spaces
+      verify_url_for("/url with spaces", "/url%20with%20spaces")
+    end
+
+    def test_it_works_when_given_absolute
+      verify_url_for("http://test.com", "http://test.com")
+    end
+
+    def test_it_works_when_not_at_root_context
+      verify_url_for("/", "context/", :path_only, {}, {"SCRIPT_NAME" => "context"})
+    end
+
+    def verify_url_for(url, expected_url, mode=:path_only, params={}, rack_env={})
+      # generate a unique url for each test
+      test_url = "/url_for_test/#{expected_url.hash}/#{Time.now.to_f}"
+      # Create our sinatra test endpoint
+      self.class.create_test_url_content(test_url, url, mode)
+
+      # verify the generated url matches what we expect
+      get test_url, params, rack_env
+      last_response.body.should == expected_url
+    end
+
+    def self.create_test_url_content(test_url, url_content, mode)
+      get test_url do
+        content_type "text/plain"
+          url_for(url_content, mode)
+      end
+    end
+
+  end
+end

data/views/accounts/index.html.haml

@@ -0,0 +1,11 @@
+%h1 Accounts
+
+%table
+  %thead
+    %tr
+      %th ID
+  %tbody
+    - @accounts.each do |account|
+      %tr
+        %td
+          = link_to account, account

data/views/accounts/show.html.haml

@@ -0,0 +1,30 @@
+%h1
+  = @account[:id]
+
+%h2 Instances
+
+%table
+  %thead
+    %tr
+      %th Instance ID
+  %tbody
+    - @account[:instance_ids].each do |instance_id|
+      %tr
+        %td
+          = link_to instance_id, instance_url( instance_id )
+
+%h2 Images
+
+%table
+  %thead
+    %tr
+      %th Image ID
+      %th Description
+  %tbody
+    %tbody
+      - @images.each do |image|
+        %tr
+          %td
+            = link_to image[:id], image_url( image[:id] )
+          %td
+            = image[:description]

data/views/api/show.html.haml

@@ -0,0 +1,15 @@
+%h1
+  API v#{@version}
+
+%ul
+  - collections.keys.sort_by { |k| k.to_s }.each do |key|
+    %li
+      = link_to key.to_s.gsub('_', ' ').titlecase, url_for("/api/#{key}")
+      %dl
+        - collections[key].operations.each_key do |op|
+          - next if [:index, :show].include?(op)
+          %dt
+            = op
+  %li
+    %strong
+      %a{:href => url_for("/api/docs")} Documentation (v#{@version})

data/views/api/show.xml.haml

@@ -0,0 +1,5 @@
+%api{ :version=>@version, :driver=>DRIVER }
+  - for entry_point in entry_points
+    %link{ :rel=>entry_point[0], :href=>entry_point[1] }
+      - for feature in driver.features(entry_point[0])
+        %feature{ :name=>feature.name }

data/views/docs/collection.html.haml

@@ -0,0 +1,37 @@
+%h2
+  = @collection.name.to_s.titlecase
+
+%p #{@collection.description}
+
+%br
+
+%h3 Operations:
+
+%table
+  %thead
+    %tr
+      %th Name
+      %th Description
+  %tbody
+    - @operations.keys.sort_by { |k| k.to_s }.each do |operation|
+      %tr
+        %td{:style => "width:15em"}
+          %a{:href => url_for("/api/docs/#{@collection.name.to_s}/#{operation}")} #{operation}
+        %td{:style => "width:10em"} #{@operations[operation].description}
+
+%h3 Features:
+
+%table
+  %thead
+    %tr
+      %th Name
+      %th Description
+      %th Modified Operations
+  %tbody
+    - @features.sort_by { |f| f.name.to_s }.each do |feature|
+      %tr
+        %td= feature.name
+        %td= feature.description
+        %td
+          - feature.operations.each do |op|
+            %a{:href => url_for("/api/docs/#{@collection.name.to_s}/#{op.name}")} #{op.name}

data/views/docs/collection.xml.haml

@@ -0,0 +1,14 @@
+%docs{:status => "unsupported"}
+  %collection{:url => url_for("/api/docs/#{@collection.name}"), :name => "#{@collection.name}"}
+    %description #{@collection.description}
+    %operations
+      - @operations.keys.sort_by { |k| k.to_s }.each do |operation|
+        %operation{:url => url_for("/api/#{@collection.name.to_s}"), :name => "#{operation}", :href => url_for("#{@operations[operation].path}"), :method => "#{@operations[operation].method}"}
+          %description #{@operations[operation].description}
+          - @operations[operation].each_param do |param|
+            %parameter{:name => "#{param.name}", :type => "#{param.type}"}
+              %class #{param.klass}
+              - unless param.options.empty?
+                %values
+                  - param.options.each do |v|
+                    %value #{v}

data/views/docs/index.html.haml

@@ -0,0 +1,15 @@
+%h2 API Documentation
+
+%h3 Collections:
+
+%table
+  %thead
+    %tr
+      %th Name
+      %th Description
+  %tbody
+    - collections.keys.sort_by { |k| k.to_s }.each do |collection|
+      %tr
+        %td{:style => "width:15em"}
+          %a{:href => url_for("/api/docs/#{collection}")} #{collection}
+        %td{:style => "width:10em"} #{collections[collection].description}

data/views/docs/index.xml.haml

@@ -0,0 +1,5 @@
+%docs{:status => "unsupported"}
+  - collections.keys.sort_by { |k| k.to_s }.each do |collection|
+    %collection{:url => url_for("/api/docs/#{collection}")}
+      %name #{collection}
+      %description  #{collections[collection].description}