deltacloud-core 1.0.1 → 1.0.2

data/tests/deprecated/drivers/rhevm/common.rb

@@ -0,0 +1,21 @@
+load File.join(File.dirname(__FILE__), '..', '..', 'common.rb')
+
+ENV['API_USER']     = 'vdcadmin@rhev.lab.eng.brq.redhat.com'
+ENV['API_PASSWORD'] = '123456'
+ENV['API_PROVIDER'] = 'https://rhev30-dc.lab.eng.brq.redhat.com:8443/rhevm-api;645e425e-66fe-4ac9-8874-537bd10ef08d'
+
+require 'vcr'
+
+DeltacloudTestCommon::record!
+
+VCR.config do |c|
+  c.cassette_library_dir = File.join(File.dirname(__FILE__), 'fixtures')
+  c.stub_with :webmock
+  c.default_cassette_options = { :record => :none }
+end
+
+class WebMock::Config
+  def net_http_connect_on_start
+    true
+  end
+end

data/tests/deprecated/drivers/rhevm/images_test.rb

@@ -0,0 +1,48 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+require 'tests/drivers/rhevm/common'
+
+module RHEVMTest
+
+  class ImagesTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Rack::Builder.new {
+        map '/' do
+          use Rack::Static, :urls => ["/stylesheets", "/javascripts"], :root => "public"
+          run Rack::Cascade.new([Deltacloud::API])
+        end
+      }
+    end
+
+    def test_01_it_returns_images
+      get_auth_url '/api;driver=rhevm/images'
+      puts last_response.body
+      (last_xml_response/'images/image').length.should > 0
+    end
+
+    def test_02_each_image_has_correct_properties
+      get_auth_url '/api;driver=rhevm/images'
+      (last_xml_response/'images/image').each do |image|
+        (image/'name').should_not == nil
+        (image/'name').should_not == ''
+        (image/'description').should_not == nil
+        (image/'description').should_not == ''
+        (image/'architecture').should_not == nil
+        (image/'architecture').should_not == ''
+        (image/'state').text.should == 'OK'
+        (image/'owner_id').text.should == ENV['API_USER']
+        (image/'actions/link').length.should == 1
+        (image/'actions/link').first[:rel].should == 'create_instance'
+      end
+    end
+
+    def test_03_it_returns_single_image
+      get_auth_url '/api;driver=rhevm/images/3e82e2d5-913f-4095-ae72-ebcfa9d0571d'
+      (last_xml_response/'image').length.should == 1
+      (last_xml_response/'image/name').text.should == 'f15-minimal-2'
+      (last_xml_response/'image/state').text.should == 'OK'
+    end
+
+  end
+end

data/tests/deprecated/drivers/rhevm/realms_test.rb

@@ -0,0 +1,40 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+require 'tests/drivers/rhevm/common'
+
+module RHEVMTest
+
+  class RealmsTest < Test::Unit::TestCase
+    include Rack::Test::Methods
+
+    def app
+      Rack::Builder.new {
+        map '/' do
+          use Rack::Static, :urls => ["/stylesheets", "/javascripts"], :root => "public"
+          run Rack::Cascade.new([Deltacloud::API])
+        end
+      }
+    end
+
+    def test_01_it_returns_realms
+      get_auth_url '/api;driver=rhevm/realms'
+      (last_xml_response/'realms/realm').length.should == 1
+    end
+
+    def test_02_each_realm_has_a_name
+      get_auth_url '/api;driver=rhevm/realms'
+      (last_xml_response/'realms/realm').each do |profile|
+        (profile/'name').text.should_not == nil
+        (profile/'name').text.should_not == ''
+        (profile/'name').text.should_not == 'Default'
+      end
+    end
+
+    def test_03_it_returns_single_realm
+      get_auth_url '/api;driver=rhevm/realms/3c8af388-cff6-11e0-9267-52540013f702'
+      (last_xml_response/'realm').first[:id].should == '3c8af388-cff6-11e0-9267-52540013f702'
+      (last_xml_response/'realm/name').first.text.should == 'engops-nfs'
+      (last_xml_response/'realm/state').first.text.should == 'AVAILABLE'
+    end
+
+  end
+end

data/tests/drivers/base/base_driver_test.rb

@@ -0,0 +1,124 @@
+require 'minitest/autorun'
+require_relative File.join('..', '..', '..', 'lib', 'deltacloud', 'drivers', 'base_driver.rb')
+
+describe Deltacloud::BaseDriver do
+
+  before do
+    class TestDriver < Deltacloud::BaseDriver
+
+      define_hardware_profile('t1.micro') do
+        cpu                1
+        memory             613
+        storage            160
+        architecture       ['i386','x86_64']
+      end
+
+      feature :instances, :user_data
+      feature :instances, :user_name do
+        { :max_length => 50 }
+      end
+
+      define_instance_states do
+        start.to( :pending )          .automatically
+        pending.to( :running )        .automatically
+        pending.to( :stopping )       .on( :stop )
+        pending.to( :stopped )        .automatically
+        stopped.to( :running )        .on( :start )
+        running.to( :running )        .on( :reboot )
+        running.to( :stopping )       .on( :stop )
+        stopping.to(:stopped)         .automatically
+        stopping.to(:finish)          .automatically
+        stopped.to( :finish )         .automatically
+      end
+
+      def realms(credentials, opts={}); end
+    end
+    @driver = TestDriver.new
+  end
+
+  describe 'when creating a new driver' do
+
+    it 'must return the proper driver name' do
+      @driver.name.must_equal 'test'
+      TestDriver.name.must_equal 'TestDriver'
+    end
+
+  end
+
+  describe 'hardware profiles' do
+
+    it 'must allow to define custom hardware profiles' do
+      TestDriver.must_respond_to :define_hardware_profile
+    end
+
+    it 'should not allow to create duplicated profile' do
+      TestDriver.define_hardware_profile('t1.micro').must_be_nil
+      TestDriver.hardware_profiles.size.must_equal 1
+    end
+
+    it 'should return all defined hardware profiles' do
+      TestDriver.must_respond_to :hardware_profiles
+      TestDriver.hardware_profiles.wont_be_empty
+    end
+
+    it 'should allow to filter hardware profiles' do
+      @driver.filter_hardware_profiles(TestDriver.hardware_profiles, :architecture => 'i386').wont_be_empty
+      @driver.filter_hardware_profiles(TestDriver.hardware_profiles, :architecture => 'unknown').must_be_empty
+      @driver.filter_hardware_profiles(TestDriver.hardware_profiles, :id => 't1.micro').wont_be_empty
+      @driver.filter_hardware_profiles(TestDriver.hardware_profiles, :id => 'm1.unknown').must_be_empty
+    end
+
+  end
+
+  describe 'features' do
+
+    it 'should return all defined features' do
+      TestDriver.features.must_be_kind_of Hash
+      TestDriver.features.keys.must_include :instances
+      TestDriver.features[:instances].must_be_kind_of Array
+      TestDriver.features[:instances].must_include :user_data
+    end
+
+    it 'must have method to check if feature is defined' do
+      TestDriver.must_respond_to :'has_feature?'
+      TestDriver.has_feature?(:instances, :user_data).must_equal true
+      TestDriver.has_feature?(:instances, :user_unknown).must_equal false
+    end
+
+    it 'must return feature defined constraints' do
+      TestDriver.must_respond_to :'constraints'
+      TestDriver.constraints.must_be_kind_of Hash
+      TestDriver.constraints[:instances].must_be_kind_of Hash
+      TestDriver.constraints[:instances][:user_name].must_be_kind_of Hash
+      TestDriver.constraints[:instances][:user_name][:max_length].must_equal 50
+      TestDriver.constraints(:collection => :instances, :feature => :user_name).must_be_kind_of Hash
+      TestDriver.constraints(:collection => :instances, :feature => :user_name)[:max_length].must_equal 50
+    end
+
+  end
+
+  describe 'instance states' do
+
+    it 'should return defined instance state machine' do
+      TestDriver.must_respond_to :instance_state_machine
+      TestDriver.instance_state_machine.must_be_kind_of Deltacloud::StateMachine
+    end
+
+    it 'should return actions for given state' do
+      @driver.must_respond_to :instance_actions_for
+      @driver.instance_actions_for('RUNNING').must_be_kind_of Array
+      @driver.instance_actions_for('RUNNING').must_include :stop
+    end
+
+  end
+
+  describe 'capabilities' do
+
+    it 'should return if driver has given capability' do
+      @driver.has_capability?(:realms).must_equal true
+      @driver.has_capability?(:images).must_equal false
+    end
+
+  end
+
+end

data/tests/{api → drivers/base}/library_test.rb

@@ -1,7 +1,5 @@
-require_relative './common'
-require_relative '../../lib/deltacloud/api'
-
-require 'pp'
+require 'minitest/autorun'
+require_relative File.join('..', '..', '..', 'lib', 'deltacloud', 'api.rb')
 
 describe 'Deltacloud API Library' do
 
@@ -30,10 +28,6 @@ describe 'Deltacloud API Library' do
     Deltacloud.new(:mock).current_provider.must_be_nil
   end
 
-  it 'should return pre-defined providers for the driver' do
-    Deltacloud.new(:ec2).providers[:entrypoints].must_be_kind_of Hash
-  end
-
   it 'should yield the backend driver' do
     Deltacloud.new :mock do |mock|
       mock.must_be_instance_of Deltacloud::Drivers::Mock::MockDriver

data/tests/drivers/ec2/common.rb

@@ -1,23 +1,31 @@
-ENV['API_DRIVER']   = 'ec2'
-ENV['TESTS_API_USERNAME'] = 'AKIAIZ63KHGXIWDMBY6Q'
-ENV['TESTS_API_PASSWORD'] = 'zUfBCbML2S6pXKS44eEEXw0Cf/G8z9hMSxP2hcLV'
-ENV['RACK_ENV']     = 'test'
+# Warning: RightHttpConnection has to be required before WebMock is required !!!
+# Lets require that:
+require 'right_http_connection'
+require 'vcr'
 
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-require 'tests/minitest_common'
+# Freeze time, so EC2 signatures have all the same time
+# This will avoid IncorrectSignature exceptions
 
-require 'vcr'
-require 'timecop'
+# NOTE: This timestamp need to be changed when re-recording
+#       the fixtures.
+
+def credentials
+  {
+    :user => 'AKIAJYOQYLLOIWN5LQ3A',
+    :password => 'Ra2ViYaYgocAJqPAQHxMVU/l2sGGU2pifmWT4q3H'
+  }
+end
+
+unless Time.respond_to? :be
+  require_relative '../../test_helper.rb'
+end
+
+Time.be(DateTime.parse("2012-07-30 11:05:00 +0000").to_s)
 
 VCR.configure do |c|
+  # NOTE: Empty this directory before re-recording
   c.cassette_library_dir = File.join(File.dirname(__FILE__), 'fixtures')
   c.hook_into :webmock
+  # Set this to :new_episodes when you want to 're-record'
   c.default_cassette_options = { :record => :new_episodes }
-  #c.default_cassette_options = { :record => :none }
 end
-
-# Let's set time that timecop will use to freeze
-# Time.now will then return this time instead of 'real' system time
-
-FREEZED_TIME = DateTime.parse("2012-05-31 12:58:00 +0200")
-Timecop.freeze(FREEZED_TIME)

data/tests/drivers/ec2/images_test.rb

@@ -1,9 +1,12 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
-require 'tests/drivers/ec2/common'
+require 'minitest/autorun'
+
+require_relative File.join('..', '..', '..', 'lib', 'deltacloud', 'api.rb')
+require_relative 'common.rb'
+
+describe 'Ec2Driver Images' do
 
-describe 'Deltacloud API Images' do
   before do
-    Timecop.freeze(FREEZED_TIME)
+    @driver = Deltacloud::new(:ec2, credentials)
     VCR.insert_cassette __name__
   end
 
@@ -11,220 +14,36 @@ describe 'Deltacloud API Images' do
     VCR.eject_cassette
   end
 
-  include Deltacloud::Test
-
-  it 'must advertise have the images collection in API entrypoint' do
-    get root_url
-    (xml_response/'api/link[@rel=images]').wont_be_empty
-  end
-
-  it 'must require authentication to access the "image" collection' do
-    get collection_url(:images)
-    last_response.status.must_equal 401
-  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
-
-  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
-
-  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
-
-  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
+  it 'must throw error when wrong credentials' do
+    Proc.new do
+      @driver.backend.images(OpenStruct.new(:user => 'unknown', :password => 'wrong'))
+    end.must_raise Deltacloud::ExceptionHandler::AuthenticationFailure, 'Authentication Failure'
   end
 
-  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
+  it 'must return list of images' do
+    @driver.images.wont_be_empty
+    @driver.images.first.must_be_kind_of Image
   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
+  it 'must allow to filter images' do
+    @driver.images(:id => 'ami-aecd60c7').wont_be_empty
+    @driver.images(:id => 'ami-aecd60c7').must_be_kind_of Array
+    @driver.images(:id => 'ami-aecd60c7').size.must_equal 1
+    @driver.images(:id => 'ami-aecd60c7').first.id.must_equal 'ami-aecd60c7'
+    @driver.images(:owner_id => '137112412989').each do |img|
+      img.owner_id.must_equal '137112412989'
     end
+    @driver.images(:id => 'ami-aaaaaaaa').must_be_empty
+    @driver.images(:id => 'unknown').must_be_empty
   end
 
-  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
-
-  it 'must return the full "image" when following the URL in image element' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      last_response.status.must_equal 200
-    end
-  end
-
-  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').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (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 image and it should match with the one in collection' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (xml_response/'state').wont_be_empty
-      (xml_response/'state').first.text.must_equal((r/'state').first.text)
-    end
-  end
-
-  it 'should have the "owner_id" element for each image' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (xml_response/'owner_id').wont_be_empty
-    end
-  end
-
-  it 'should have the "description" element for each image' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (xml_response/'description').wont_be_empty
-    end
-  end
-
-  it 'should have the "architecture" element for each image' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (xml_response/'architecture').wont_be_empty
-    end
-  end
-
-  it 'should include the list of compatible hardware_profiles for each image' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (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
-
-  it 'should advertise the list of actions that can be executed for each image' do
-    authenticate
-    get collection_url(:images)
-    (xml_response/'images/image').wont_be_empty
-    (xml_response/'images/image')[0..10].each do |r|
-      VCR.use_cassette "#{__name__}_image_#{r[:id]}" do
-        get collection_url(:images) + '/' + r[:id]
-      end
-      (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
+  it 'must allow to retrieve single image' do
+    @driver.image(:id => 'ami-aecd60c7').wont_be_nil
+    @driver.image(:id => 'ami-aecd60c7').must_be_kind_of Image
+    @driver.image(:id => 'ami-aecd60c7').id.must_equal 'ami-aecd60c7'
+    @driver.image(:id => 'ami-aaaaaaaa').must_be_nil
+    @driver.image(:id => 'unknown').must_be_nil
   end
 
 end
+