deltacloud-core 0.5.0 → 1.0.0

data/tests/drivers/mock/images_test.rb

@@ -1,138 +1,197 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.  The
-# ASF licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the
-# License.  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
 $:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-require 'tests/common'
+require 'tests/drivers/mock/common'
 
-module DeltacloudUnitTest
-  class HardwareProfilesTest < Test::Unit::TestCase
-    include Rack::Test::Methods
+describe 'Deltacloud API Images' do
+  include Deltacloud::Test
 
-    def app
-      Sinatra::Application
-    end
+  it 'must advertise have the images collection in API entrypoint' do
+    get root_url
+    (xml_response/'api/link[@rel=images]').wont_be_empty
+  end
 
-    def test_it_require_authentication
-      require_authentication?('/api/images').should == true
-    end
+  it 'must require authentication to access the "image" collection' do
+    get collection_url(:images)
+    last_response.status.must_equal 401
+  end
 
-    def test_it_returns_images
-      get_auth_url '/api/images', {}
-      (last_xml_response/'images/image').length.should > 0
-    end
+  it 'should respond with HTTP_OK when accessing the :images collection with authentication' do
+    authenticate
+    get collection_url(:images)
+    last_response.status.must_equal 200
+  end
 
-    def test_it_has_correct_attributes_set
-      get_auth_url '/api/images', {}
-      (last_xml_response/'images/image').each do |image|
-        image.attributes.keys.sort.should == [ 'href', 'id' ]
-      end
+  it 'should support the JSON media type' do
+    authenticate
+    header 'Accept', 'application/json'
+    get collection_url(:images)
+    last_response.status.must_equal 200
+    last_response.headers['Content-Type'].must_equal 'application/json'
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    authenticate
+    get collection_url(:images)
+    last_response.headers['ETag'].wont_be_nil
+  end
+
+  it 'must have the "images" element on top level' do
+    authenticate
+    get collection_url(:images)
+    xml_response.root.name.must_equal 'images'
+  end
+
+  it 'must have some "image" elements inside "images"' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').wont_be_empty
+  end
+
+  it 'must provide the :id attribute for each image in collection' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      r[:id].wont_be_nil
     end
+  end
 
-    def test_img1_has_correct_attributes
-      get_auth_url '/api/images', {}
-      image = (last_xml_response/'images/image[@id="img1"]')
-      test_image_attributes(image)
+  it 'must include the :href attribute for each "image" element in collection' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      r[:href].wont_be_nil
     end
+  end
 
-    def test_it_returns_valid_image
-      get_auth_url '/api/images/img1', {}
-      image = (last_xml_response/'image')
-      test_image_attributes(image)
+  it 'must use the absolute URL in each :href attribute' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      r[:href].must_match /^http/
     end
+  end
 
-    def test_it_has_unique_ids
-      get_auth_url '/api/images', {}
-      ids = []
-      (last_xml_response/'images/image').each do |image|
-        ids << image['id'].to_s
-      end
-      ids.sort.should == ids.sort.uniq
+  it 'must have the URL ending with the :id of the image' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      r[:href].must_match /#{r[:id]}$/
     end
+  end
 
-    def test_it_has_valid_urls
-      get_auth_url '/api/images', {}
-      ids = []
-      images = (last_xml_response/'images/image')
-      images.each do |image|
-        get_auth_url image['href'].to_s, {}
-        (last_xml_response/'image').first['href'].should == image['href'].to_s
-      end
+  it 'must return the list of valid parameters for the :index action' do
+    authenticate
+    options collection_url(:images) + '/index'
+    last_response.headers['Allow'].wont_be_nil
+  end
+
+  it 'must have the "name" element defined for each image in collection' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      (r/'name').wont_be_empty
     end
+  end
 
-    def test_it_can_filter_using_owner_id
-      get_auth_url '/api/images', { :owner_id => 'mockuser' }
-      (last_xml_response/'images/image').length.should == 1
-      (last_xml_response/'images/image/owner_id').first.text.should == 'mockuser'
+  it 'must have the "state" element defined for each image in collection' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      (r/'state').wont_be_empty
     end
+  end
 
-    def test_it_can_filter_using_unknown_owner_id
-      get_auth_url '/api/images', { :architecture => 'unknown_user' }
-      (last_xml_response/'images/image').length.should == 0
+  it 'must return the full "image" when following the URL in image element' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      last_response.status.must_equal 200
     end
+  end
 
-    def test_it_can_filter_using_architecture
-      get_auth_url '/api/images', { :architecture => 'x86_64' }
-      (last_xml_response/'images/image').length.should == 1
-      (last_xml_response/'images/image/architecture').first.text.should == 'x86_64'
+  it 'must have the "name" element for the image and it should match with the one in collection' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'name').wont_be_empty
+      (xml_response/'name').first.text.must_equal((r/'name').first.text)
     end
+  end
 
-    def test_it_can_filter_using_unknown_architecture
-      get_auth_url '/api/images', { :architecture => 'unknown_arch' }
-      (last_xml_response/'images/image').length.should == 0
+  it 'must have the "name" element for the image and it should match with the one in collection' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'state').wont_be_empty
+      (xml_response/'state').first.text.must_equal((r/'state').first.text)
     end
+  end
 
-    def test_it_responses_to_json
-      get_auth_url '/api/images', {}, { :format => :json }
-      JSON::parse(last_response.body).class.should == Hash
-      JSON::parse(last_response.body)['images'].class.should == Array
-      get_auth_url '/api/images/img1', {}, { :format => :json }
-      last_response.status.should == 200
-      JSON::parse(last_response.body).class.should == Hash
-      JSON::parse(last_response.body)['image'].class.should == Hash
+  it 'should have the "owner_id" element for each image' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'owner_id').wont_be_empty
     end
+  end
 
-    def test_it_responses_to_html
-      get_auth_url '/api/images', {}, { :format => :html }
-      last_response.status.should == 200
-      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
-      get_auth_url '/api/images/img1', {}, { :format => :html }
-      last_response.status.should == 200
-      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
+  it 'should have the "description" element for each image' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'description').wont_be_empty
     end
+  end
 
-    def test_it_creates_and_destroys_image_from_instance
-      post_url "/api/images", { :name => "img4", :description => "Test::Unit image", :instance_id => "inst1"}
-      last_response.status.should == 201
-      last_response.headers['Location'].should_not == nil
-      get_auth_url last_response.headers['Location'], {}
-      (last_xml_response/'instance/name').should_not == nil
-      delete_url "/api/images/img4", {}
-      last_response.status.should == 204
-      get_auth_url "/api/images/img4", {}
-      last_response.status.should == 404
+  it 'should have the "architecture" element for each image' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'architecture').wont_be_empty
     end
+  end
 
-    private
+  it 'should include the list of compatible hardware_profiles for each image' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'hardware_profiles/hardware_profile').wont_be_empty
+      (xml_response/'hardware_profiles/hardware_profile').each do |hwp|
+        hwp[:href].wont_be_nil
+        hwp[:href].must_match /^http/
+        hwp[:id].wont_be_nil
+        hwp[:href].must_match /\/#{hwp[:id]}$/
+        hwp[:rel].must_equal 'hardware_profile'
+      end
+    end
+  end
 
-    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
+  it 'should advertise the list of actions that can be executed for each image' do
+    authenticate
+    get collection_url(:images)
+    (xml_response/'images/image').each do |r|
+      get collection_url(:images) + '/' + r[:id]
+      (xml_response/'actions/link').wont_be_empty
+      (xml_response/'actions/link').each do |l|
+        l[:href].wont_be_nil
+        l[:href].must_match /^http/
+        l[:method].wont_be_nil
+        l[:rel].wont_be_nil
+      end
     end
+  end
 
+  it 'should give client HTML form to create new image' do
+    authenticate
+    header 'Accept', 'text/html'
+    get collection_url(:images) + '/new'
+    last_response.status.must_equal 200
   end
+
 end

data/tests/drivers/mock/instances_test.rb

@@ -1,253 +1,343 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.  The
-# ASF licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the
-# License.  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-
 $:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-require 'tests/common'
+require 'tests/drivers/mock/common'
+
+describe 'Deltacloud API instances' do
+  include Deltacloud::Test
+
+  it 'must advertise have the instances collection in API entrypoint' do
+    get root_url
+    (xml_response/'api/link[@rel=instances]').wont_be_empty
+  end
+
+  it 'must require authentication to access the "instance" collection' do
+    get collection_url(:instances)
+    last_response.status.must_equal 401
+  end
+
+  it 'should respond with HTTP_OK when accessing the :instances collection with authentication' do
+    authenticate
+    get collection_url(:instances)
+    last_response.status.must_equal 200
+  end
 
-module DeltacloudUnitTest
-  class InstancesTest < Test::Unit::TestCase
-    include Rack::Test::Methods
+  it 'should support the JSON media type' do
+    authenticate
+    header 'Accept', 'application/json'
+    get collection_url(:instances)
+    last_response.status.must_equal 200
+    last_response.headers['Content-Type'].must_equal 'application/json'
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    authenticate
+    get collection_url(:instances)
+    last_response.headers['ETag'].wont_be_nil
+  end
+
+  it 'must have the "instances" element on top level' do
+    authenticate
+    get collection_url(:instances)
+    xml_response.root.name.must_equal 'instances'
+  end
+
+  it 'must have some "instance" elements inside "instances"' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').wont_be_empty
+  end
 
-    def app
-      Sinatra::Application
+  it 'must provide the :id attribute for each instance in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      r[:id].wont_be_nil
     end
+  end
 
-    def test_it_require_authentication
-      require_authentication?('/api/instances').should == true
+  it 'must include the :href attribute for each "instance" element in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      r[:href].wont_be_nil
     end
+  end
 
-    def test_it_returns_instances
-      get_auth_url '/api/instances', {}
-      (last_xml_response/'instances/instance').length.should > 0
+  it 'must use the absolute URL in each :href attribute' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      r[:href].must_match /^http/
     end
+  end
 
-    def test_it_has_correct_attributes_set
-      get_auth_url '/api/images', {}
-      (last_xml_response/'images/image').each do |image|
-        image.attributes.keys.sort.should == [ 'href', 'id' ]
-      end
+  it 'must have the URL ending with the :id of the instance' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      r[:href].must_match /#{r[:id]}$/
     end
+  end
 
-    def test_it_has_unique_ids
-      get_auth_url '/api/instances', {}
-      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
-      get_auth_url '/api/instances', {}
-      instance = (last_xml_response/'instances/instance[@id="inst1"]')
-      test_instance_attributes(instance)
-    end
-
-    def test_it_returns_valid_realm
-      get_auth_url '/api/instances/inst1', {}
-      instance = (last_xml_response/'instance')
-      test_instance_attributes(instance)
-    end
-
-    def test_it_responses_to_json
-      get_auth_url '/api/instances', {}, { :format => :json }
-      JSON::parse(last_response.body).class.should == Hash
-      JSON::parse(last_response.body)['instances'].class.should == Array
-
-      get_auth_url '/api/instances/inst1', {}, { :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
-      get_auth_url '/api/instances', {}, { :format => :html }
-      last_response.status.should == 200
-      Nokogiri::HTML(last_response.body).search('html').first.name.should == 'html'
-      get_auth_url '/api/instances/inst1', {}, { :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_url '/api/instances', params
-      last_response.status.should == 201
-      last_response.headers['Location'].should_not == nil
-      get_auth_url last_response.headers['Location'], {}
-      (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_url '/api/instances', params
-      last_response.status.should == 201
-      last_response.headers['Location'].should_not == nil
-      get_auth_url last_response.headers['Location'], {}
-      (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_storage_and_hwp_cpu
-      params = {
-        :image_id => 'img1',
-        :realm_id => '',
-        :name => "unit_test_instance3",
-        :hwp_id => "m1-large",
-        :hwp_storage => '850',
-        :hwp_memory => '7680.0',
-        :hwp_cpu => "1.0",
-      }
-      post_url '/api/instances', params
-      last_response.status.should == 400
-    end
-
-    def test_it_create_a_new_instance_using_image_id_and_name_and_hwp_storage
-      params = {
-        :image_id => 'img1',
-        :name => "unit_test_instance2",
-        :hwp_id => "m1-small",
-        :hwp_storage => "160"
-      }
-      post_url '/api/instances', params
-      last_response.status.should == 201
-      last_response.headers['Location'].should_not == nil
-      get_auth_url last_response.headers['Location'], {}
-      (last_xml_response/'instance/name').text.should == 'unit_test_instance2'
-      (last_xml_response/'instance/hardware_profile').first['id'].should == 'm1-small'
-      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|
-        get_auth_url "/api/instances/#{instance_id}", {}
-        stop_url = (last_xml_response/'actions/link[@rel="stop"]').first['href']
-        stop_url.should_not == nil
-        post_url stop_url
-        last_response.status.should == 200
-        instance = Nokogiri::XML(last_response.body)
-        test_instance_attributes(instance)
-        (instance/'state').text.should == 'STOPPED'
-        get_auth_url "/api/instances/#{instance_id}", {}
-        start_url = (last_xml_response/'actions/link[@rel="start"]').first['href']
-        start_url.should_not == nil
-        post_url start_url
-        last_response.status.should == 200
-        instance = Nokogiri::XML(last_response.body)
-        test_instance_attributes(instance)
-        (instance/'state').text.should == 'RUNNING'
-      end
+  it 'must return the list of valid parameters for the :index action' do
+    authenticate
+    options collection_url(:instances) + '/index'
+    last_response.headers['Allow'].wont_be_nil
+  end
+
+  it 'must have the "name" element defined for each instance in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      (r/'name').wont_be_empty
     end
+  end
 
-    def test_z0_reboot_instance
-      $created_instances.each do |instance_id|
-        get_auth_url "/api/instances/#{instance_id}", {}
-        reboot_url = (last_xml_response/'actions/link[@rel="reboot"]').first['href']
-        reboot_url.should_not == nil
-        post_url reboot_url
-        last_response.status.should == 200
-        instance = Nokogiri::XML(last_response.body)
-        test_instance_attributes(instance)
-        (instance/'state').text.should == 'RUNNING'
-      end
+  it 'must have the "state" element defined for each instance in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      (r/'state').wont_be_empty
+      (r/'state').first.must_match /(RUNNING|STOPPED|PENDING)/
     end
+  end
 
-    def test_z1_stop_created_instances
-      $created_instances.each do |instance_id|
-        get_auth_url "/api/instances/#{instance_id}", {}
-        stop_url = (last_xml_response/'actions/link[@rel="stop"]').first['href']
-        stop_url.should_not == nil
-        post_url stop_url, {}
-        last_response.status.should == 200
-        instance = Nokogiri::XML(last_response.body)
-        test_instance_attributes(instance)
-        (instance/'state').text.should == 'STOPPED'
-      end
+  it 'must return the full "instance" when following the URL in instance element' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      last_response.status.must_equal 200
     end
+  end
 
-    def test_z2_destroy_created_instances
-      $created_instances.each do |instance_id|
-        get_auth_url "/api/instances/#{instance_id}", {}
-        destroy_url = (last_xml_response/'actions/link[@rel="destroy"]').first['href']
-        destroy_url.should_not == nil
-        delete_url destroy_url, {}
-        last_response.status.should == 204
-      end
+  it 'must have the "name" element for the instance and it should match with the one in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'name').wont_be_empty
+      (xml_response/'name').first.text.must_equal((r/'name').first.text)
+    end
+  end
+
+  it 'must have the "name" element for the instance and it should match with the one in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'state').wont_be_empty
+      (xml_response/'state').first.text.must_equal((r/'state').first.text)
+    end
+  end
+
+  it 'must have the "owner_id" element for the instance and it should match with the one in collection' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'owner_id').wont_be_empty
+      (xml_response/'owner_id').first.text.must_equal((r/'owner_id').first.text)
     end
+  end
 
-    def test_create_key_returns_201
-      post_url '/api/keys', {:name => Time.now.to_f.to_s}
-      last_response.status.should == 201
+  it 'must link to the realm that was used to during instance creation' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'realm').wont_be_empty
+      (xml_response/'realm').size.must_equal 1
+      (xml_response/'realm').first[:id].wont_be_nil
+      (xml_response/'realm').first[:href].wont_be_nil
+      (xml_response/'realm').first[:href].must_match /\/#{(xml_response/'realm').first[:id]}$/
     end
+  end
 
-    private
+  it 'must link to the image that was used to during instance creation' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'image').wont_be_empty
+      (xml_response/'image').size.must_equal 1
+      (xml_response/'image').first[:id].wont_be_nil
+      (xml_response/'image').first[:href].wont_be_nil
+      (xml_response/'image').first[:href].must_match /\/#{(xml_response/'image').first[:id]}$/
+    end
+  end
 
-    def test_instance_attributes(instance)
-      (instance/'name').should_not == nil
-      (instance/'owner_id').should_not == nil
-      ['RUNNING', 'STOPPED'].include?((instance/'state').text).should == true
+  it 'must link to the hardware_profile that was used to during instance creation' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'hardware_profile').wont_be_empty
+      (xml_response/'hardware_profile').size.must_equal 1
+      (xml_response/'hardware_profile').first[:id].wont_be_nil
+      (xml_response/'hardware_profile').first[:href].wont_be_nil
+      (xml_response/'hardware_profile').first[:href].must_match /\/#{(xml_response/'hardware_profile').first[:id]}$/
+    end
+  end
 
-      (instance/'public_addreses').should_not == nil
-      (instance/'public_addresses/address').to_a.size.should > 0
-      (instance/'public_addresses/address').first.text.should_not == ""
-      (instance/'public_addresses/address').first[:type].should == "hostname"
+  it 'should advertise the public and private addresses of the instance' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'public_addresses').wont_be_empty
+      (xml_response/'public_addresses').size.must_equal 1
+      (xml_response/'public_addresses/address').each do |a|
+        a[:type].wont_be_nil
+        a.text.strip.wont_be_empty
+      end
+      (xml_response/'private_addresses').wont_be_empty
+      (xml_response/'private_addresses').size.must_equal 1
+      (xml_response/'private_addresses/address').each do |a|
+        a[:type].wont_be_nil
+        a.text.strip.wont_be_empty
+      end
+    end
+  end
 
-      (instance/'private_addresses').should_not == nil
-      (instance/'private_addresses/address').to_a.size.should > 0
-      (instance/'private_addresses/address').first.text.should_not == ""
-      (instance/'private_addresses/address').first[:type].should == "hostname"
+  it 'should advertise the storage volumes used by the instance' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'storage_volumes').wont_be_empty
+    end
+  end
 
-      (instance/'actions/link').to_a.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
+  it 'should advertise the list of actions that can be executed for each instance' do
+    authenticate
+    get collection_url(:instances)
+    (xml_response/'instances/instance').each do |r|
+      get collection_url(:instances) + '/' + r[:id]
+      (xml_response/'actions/link').wont_be_empty
+      (xml_response/'actions/link').each do |l|
+        l[:href].wont_be_nil
+        l[:href].must_match /^http/
+        l[:method].wont_be_nil
+        l[:rel].wont_be_nil
       end
+    end
+  end
 
-      (instance/'image').size.should > 0
-      (instance/'image').first['href'].should_not == ""
-      (instance/'image').first['id'].should_not == ""
-      get_auth_url (instance/'image').first['href'], {}
-      (last_xml_response/'image').should_not == nil
-      (last_xml_response/'image').first['href'] == (instance/'image').first['href']
+  it 'should allow to create and destroy new instance using the first available image without realm' do
+    authenticate
+    get collection_url(:images)
+    image_id = (xml_response/'images/image').first[:id]
+    image_id.wont_be_nil
+    post collection_url(:instances), {
+      :image_id => image_id
+    }
+    last_response.status.must_equal 201 # HTTP_CREATED
+    last_response.headers['Location'].wont_be_nil # Location header must be set, pointing to new the instance
+    instance_id = last_response.headers['Location'].split('/').last
+    # Get the instance and check if ID and image is set correctly
+    get collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 200 # HTTP_OK
+    (xml_response/'instance').first[:id].must_equal instance_id
+    (xml_response/'instance/image').first[:id].must_equal image_id
+    # If instance is RUNNING then stop it
+    if (xml_response/'instance/state').first.text == 'RUNNING'
+      post collection_url(:instances) + '/' + instance_id + '/stop'
+      last_response.status.must_equal 202 # HTTP_NO_CONTENT
+    end
+    # Delete created instance
+    delete collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 204 # HTTP_NO_CONTENT
+  end
 
-      (instance/'realm').size.should > 0
-      (instance/'realm').first['href'].should_not == ""
-      (instance/'realm').first['id'].should_not == ""
-      get_auth_url (instance/'realm').first['href']
-      (last_xml_response/'realm').should_not == nil
-      (last_xml_response/'realm').first['href'] == (instance/'realm').first['href']
+  it 'should allow to create and destroy new instance using the first available image within first realm' do
+    authenticate
+    get collection_url(:images)
+    image_id = (xml_response/'images/image').first[:id]
+    get collection_url(:realms)
+    realm_id = (xml_response/'realms/realm').first[:id]
+    image_id.wont_be_nil
+    realm_id.wont_be_nil
+    post collection_url(:instances), {
+      :image_id => image_id,
+      :realm_id => realm_id,
+    }
+    last_response.status.must_equal 201 # HTTP_CREATED
+    last_response.headers['Location'].wont_be_nil # Location header must be set, pointing to new the instance
+    instance_id = last_response.headers['Location'].split('/').last
+    # Get the instance and check if ID and image is set correctly
+    get collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 200 # HTTP_OK
+    (xml_response/'instance').first[:id].must_equal instance_id
+    (xml_response/'instance/image').first[:id].must_equal image_id
+    (xml_response/'instance/realm').first[:id].must_equal realm_id
+    # If instance is RUNNING then stop it
+    if (xml_response/'instance/state').first.text == 'RUNNING'
+      post collection_url(:instances) + '/' + instance_id + '/stop'
+      last_response.status.must_equal 202 # HTTP_NO_CONTENT
+    end
+    # Delete created instance
+    delete collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 204 # HTTP_NO_CONTENT
+  end
 
-      (instance/'hardware_profile').size.should > 0
-      (instance/'hardware_profile').first['href'].should_not == ""
-      (instance/'hardware_profile').first['id'].should_not == ""
-      get_auth_url (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']
+  it 'should allow to create and destroy new instance using the first available image with user defined name' do
+    authenticate
+    get collection_url(:images)
+    image_id = (xml_response/'images/image').first[:id]
+    image_id.wont_be_nil
+    name = "i#{Time.now.to_i}"
+    post collection_url(:instances), {
+      :image_id => image_id,
+      :name => name
+    }
+    last_response.status.must_equal 201 # HTTP_CREATED
+    last_response.headers['Location'].wont_be_nil # Location header must be set, pointing to new the instance
+    instance_id = last_response.headers['Location'].split('/').last
+    # Get the instance and check if ID and image is set correctly
+    get collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 200 # HTTP_OK
+    (xml_response/'instance').first[:id].must_equal instance_id
+    (xml_response/'instance/image').first[:id].must_equal image_id
+    (xml_response/'instance/name').first.text.must_equal name
+    # If instance is RUNNING then stop it
+    if (xml_response/'instance/state').first.text == 'RUNNING'
+      post collection_url(:instances) + '/' + instance_id + '/stop'
+      last_response.status.must_equal 202 # HTTP_NO_CONTENT
     end
+    # Delete created instance
+    delete collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 204 # HTTP_NO_CONTENT
+  end
 
+  it 'should allow to create and destroy new instance using the first available image and first hardware_profile' do
+    authenticate
+    get collection_url(:images)
+    image_id = (xml_response/'images/image').first[:id]
+    get collection_url(:hardware_profiles)
+    hwp_id = (xml_response/'hardware_profiles/hardware_profile').first[:id]
+    image_id.wont_be_nil
+    name = "i#{Time.now.to_i}"
+    post collection_url(:instances), {
+      :image_id => image_id,
+      :hwp_id => hwp_id
+    }
+    last_response.status.must_equal 201 # HTTP_CREATED
+    last_response.headers['Location'].wont_be_nil # Location header must be set, pointing to new the instance
+    instance_id = last_response.headers['Location'].split('/').last
+    # Get the instance and check if ID and image is set correctly
+    get collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 200 # HTTP_OK
+    (xml_response/'instance').first[:id].must_equal instance_id
+    (xml_response/'instance/image').first[:id].must_equal image_id
+    (xml_response/'instance/hardware_profile').first[:id].must_equal hwp_id
+    # If instance is RUNNING then stop it
+    if (xml_response/'instance/state').first.text == 'RUNNING'
+      post collection_url(:instances) + '/' + instance_id + '/stop'
+      last_response.status.must_equal 202 # HTTP_NO_CONTENT
+    end
+    # Delete created instance
+    delete collection_url(:instances) + '/' + instance_id
+    last_response.status.must_equal 204 # HTTP_NO_CONTENT
   end
+
 end