fog 1.24.0 → 1.25.0

data/tests/helper.rb

@@ -29,7 +29,7 @@ end
 all_providers = Fog.registered_providers.map {|provider| provider.downcase}
 
 # Manually remove these providers since they are local applications, not lacking credentials
-all_providers = all_providers - ["libvirt", "vmfusion", "openvz"]
+all_providers = all_providers - ["libvirt", "openvz"]
 
 available_providers = Fog.available_providers.map {|provider| provider.downcase}
 

data/tests/helpers/mock_helper.rb

@@ -75,6 +75,8 @@ if Fog.mock?
     :ovirt_url                        => 'http://ovirt:8080/api',
     :ovirt_username                   => 'admin@internal',
     :ovirt_password                   => '123123',
+    :profitbricks_username            => 'profitbricks_username',
+    :profitbricks_password            => 'profitbricks_password',
     :libvirt_uri                      => 'qemu://libvirt/system',
     :rackspace_api_key                => 'rackspace_api_key',
     :rackspace_region                 => 'dfw',
@@ -91,8 +93,6 @@ if Fog.mock?
     :vcloud_director_host             => 'vcloud-director-host',
     :vcloud_director_password         => 'vcloud_director_password',
     :vcloud_director_username         => 'vcd_user@vcd_org_name',
-    :voxel_api_key                    => 'voxel_api_key',
-    :voxel_api_secret                 => 'voxel_api_secret',
     :zerigo_email                     => 'zerigo_email',
     :zerigo_token                     => 'zerigo_token',
     :dynect_customer                  => 'dynect_customer',

data/tests/opennebula/models/compute/flavor_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Fog::Compute[:opennebula] | flavor model', ['opennebula']) do
+
+  flavors = Fog::Compute[:opennebula].flavors
+  flavor = flavors.last
+
+  tests('The flavor model should') do
+    tests('have the action') do
+      test('reload') { flavor.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = flavor.attributes
+      attributes = 
+      tests("The flavor model should respond to") do
+        [:name, :id, :to_label, :to_s, :get_cpu, :get_vcpu, :get_memory, :get_raw, :get_disk, :get_os,
+          :get_graphics, :get_nic, :get_sched_ds_requirements, :get_sched_ds_rank, :get_sched_requirements,
+          :get_sched_rank, :get_context, :get_user_variables].each do |attribute|
+            test("#{attribute}") { flavor.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        [:name, :id, :content, :cpu, :vcpu, :memory, :os, :graphics, :raw, :context, :user_variables ].each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::OpenNebula::Flavor') { flavor.kind_of? Fog::Compute::OpenNebula::Flavor }
+  end
+
+end

data/tests/opennebula/models/compute/flavors_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Compute[:opennebula] | flavors collection', ['opennebula']) do
+
+  flavors = Fog::Compute[:opennebula].flavors
+
+  tests('The flavors collection should') do
+    test('should be a kind of Fog::Compute::OpenNebula::Flavors') { flavors.kind_of? Fog::Compute::OpenNebula::Flavors }
+    tests('should be able to reload itself').succeeds { flavors.reload }
+
+    tests('should be able to get models') do
+      tests('all').succeeds { flavors.all }
+      tests('by instance id').succeeds { flavors.get flavors.first.id }
+      tests('by name').succeeds { flavors.get_by_name "fogtest" }
+      tests('by filter').succeeds { flavors.get_by_filter ({:name => "fogtest", :id => flavors.first.id }) }
+    end
+  end
+
+end

data/tests/opennebula/models/compute/network_tests.rb

@@ -11,12 +11,12 @@ Shindo.tests('Fog::Compute[:opennebula] | network model', ['opennebula']) do
       model_attribute_hash = network.attributes
       attributes = 
       tests("The network model should respond to") do
-        [:name, :id, :vlan, :uid, :gid, :description].each do |attribute|
+        [:name, :id, :vlan, :uid, :uname, :gid, :description].each do |attribute|
           test("#{attribute}") { network.respond_to? attribute }
         end
       end
       tests("The attributes hash should have key") do
-        [:name, :id, :uid, :gid].each do |attribute|
+        [:name, :id, :uid, :uname, :gid ].each do |attribute|
           test("#{attribute}") { model_attribute_hash.has_key? attribute }
         end
       end

data/tests/opennebula/models/compute/networks_tests.rb

@@ -6,7 +6,9 @@ Shindo.tests('Fog::Compute[:opennebula] | networks collection', ['opennebula'])
     test('should be a kind of Fog::Compute::OpenNebula::Networks') { networks.kind_of? Fog::Compute::OpenNebula::Networks }
     tests('should be able to reload itself').succeeds { networks.reload }
     tests('should be able to get a model') do
+      tests('all').succeeds { networks.all }
       tests('by instance id').succeeds { networks.get networks.first.id }
+      tests('by filter').succeeds { networks.get_by_filter ({ :id => networks.first.id }) }
     end
   end
 

data/tests/openstack/requests/storage/object_tests.rb

@@ -31,6 +31,16 @@ Shindo.tests('Fog::Storage[:openstack] | object requests', ["openstack"]) do
       data == lorem_file.read
     end
 
+    tests("#public_url('fogobjectests', 'fog_object')").succeeds do
+      pending if Fog.mocking?
+      Fog::Storage[:openstack].directories.first.files.first.public_url
+    end
+
+    tests("#public_url('fogobjectests')").succeeds do
+      pending if Fog.mocking?
+      Fog::Storage[:openstack].directories.first.public_url
+    end
+
     tests("#head_object('fogobjectests', 'fog_object')").succeeds do
       pending if Fog.mocking?
       Fog::Storage[:openstack].head_object('fogobjecttests', 'fog_object')

data/tests/ovirt/compute_tests.rb

@@ -18,7 +18,7 @@ Shindo.tests('Fog::Compute[:ovirt]', ['ovirt']) do
     %w{ add_interface create_vm datacenters destroy_interface destroy_vm get_cluster get_template
         get_virtual_machine list_clusters list_networks list_template_interfaces list_templates
         list_virtual_machines list_vm_interfaces storage_domains update_interface update_vm vm_action
-        api_version}.each do |collection|
+        api_version update_volume}.each do |collection|
       test("it should respond to #{collection}") { compute.respond_to? collection }
     end
   end

data/tests/ovirt/requests/compute/update_volume_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::Compute[:ovirt] | update_volume request', ['ovirt']) do
+
+  compute = Fog::Compute[:ovirt]
+  if compute.servers.all(:search => 'fog-*').empty?
+    compute.create_vm(:name => 'fog-'+Time.now.to_i.to_s, :cluster_name => 'Default')
+  end
+  vm_id = compute.servers.all(:search => 'fog-*').last
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when vm id is missing') { compute.update_volume(nil, {:id => 1}) }
+    raises(ArgumentError, 'raises ArgumentError when disk_id option is missing') { compute.update_volume(1, {:any => 1}) }
+  end
+
+  tests('The response should') do
+    response = compute.update_volume(vm_id, :id => 1)
+    test('be a success') { response ? true: false }
+  end
+
+
+end

data/tests/rackspace/models/networking/network_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Rackspace::Networking | network', ['rackspace']) do
+  service = Fog::Rackspace::Networking.new
+
+  options = {
+    :label => "fog_network_#{Time.now.to_i.to_s}",
+    :cidr => '192.168.0.0/24'
+  }
+
+  model_tests(service.networks, options, true)
+end

data/tests/rackspace/models/networking/networks_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Rackspace::Networking | networks', ['rackspace']) do
+  service = Fog::Rackspace::Networking.new
+
+  options = {
+    :label => "fog_network_#{Time.now.to_i.to_s}",
+    :cidr => '192.168.0.0/24'
+  }
+
+  collection_tests(service.networks, options, true)
+end

data/tests/rackspace/models/networking/virtual_interface_tests.rb

@@ -0,0 +1,33 @@
+Shindo.tests('Fog::Rackspace::Networking | virtual_interface', ['rackspace']) do
+  service = Fog::Rackspace::Networking.new
+
+  net_options = {
+    :label => "fog_network_#{Time.now.to_i.to_s}",
+    :cidr => '192.168.0.0/24'
+  }
+
+  server_options = {
+    :name => "fog_server_#{Time.now.to_i.to_s}",
+    :flavor_id => rackspace_test_flavor_id(service),
+    :image_id => rackspace_test_image_id(service)
+  }
+
+  tests('virtual_interface') do
+    pending if Fog.mocking?
+    begin
+      @server = service.servers.create server_options
+      @network = service.networks.create net_options
+      @server.wait_for { ready? }
+
+      model_tests(@server.virtual_interfaces, {:network => @network}, false)
+
+    ensure
+      if @server
+        @server.destroy
+        # wait_for_server_deletion(@server) if @server
+        delete_test_network(@network) if @network
+      end
+    end
+  end
+
+end

data/tests/rackspace/models/networking/virtual_interfaces_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Rackspace::Networking | virtual_interfaces', ['rackspace']) do
+  service = Fog::Rackspace::Networking.new
+
+  options = {
+    :name => "fog_server_#{Time.now.to_i.to_s}",
+    :flavor_id => rackspace_test_flavor_id(service),
+    :image_id => rackspace_test_image_id(service)
+  }
+
+  tests('virtual_interfaces') do
+    pending if Fog.mocking?
+    begin
+      @server = service.servers.create options
+      @server.wait_for { ready? }
+
+      tests('#virtual_interfaces').succeeds do
+        @server.virtual_interfaces.all
+      end
+
+    ensure
+      @server.destroy if @server
+    end
+  end
+end

data/tests/rackspace/models/queues/queue_tests.rb

@@ -24,5 +24,14 @@ Shindo.tests('Fog::Rackspace::Queues | queue', ['rackspace']) do
       @instance.dequeue(60, 60) do |message|
       end
     end
+
+    tests('#dequeue(60, 60) => not passing block').returns(true) do
+      @instance.enqueue("msg", 60)
+      @instance.dequeue(60, 60)
+    end
+
+    tests('#dequeue(60, 60) => with not messages and not passing block').returns(false) do
+      @instance.dequeue(60, 60)
+    end
   end
 end

data/tests/rackspace/networking_tests.rb

@@ -0,0 +1,118 @@
+Shindo.tests('Fog::Rackspace::Networking', ['rackspace']) do
+
+  def assert_method(url, method)
+    @service.instance_variable_set "@rackspace_auth_url", url
+    returns(method) { @service.send :authentication_method }
+  end
+
+  tests('#authentication_method') do
+    @service = Fog::Rackspace::Networking.new
+
+    assert_method nil, :authenticate_v2
+
+    assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint
+
+    assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1
+    assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1
+    assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1
+    assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2
+
+    assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1
+    assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1
+    assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1
+    assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2
+  end
+
+  tests('legacy authentication') do
+    pending if Fog.mocking?
+
+    tests('variables populated').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0'
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? }
+      returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? }
+      @service.list_flavors
+    end
+
+    tests('custom endpoint') do
+      @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0',
+        :rackspace_compute_url => 'https://my-custom-endpoint.com'
+        returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+        returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
+    end
+  end
+
+  tests('current authentation') do
+    pending if Fog.mocking?
+
+    tests('variables populated').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true}
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? }
+      identity_service = @service.instance_variable_get("@identity_service")
+      returns(false, "identity service was used") { identity_service.nil? }
+      returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) }
+      @service.list_flavors
+    end
+    tests('dfw region').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
+      @service.list_flavors
+    end
+    tests('ord region').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil }
+      @service.list_flavors
+    end
+    tests('custom endpoint') do
+      @service = Fog::Rackspace::Networking.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0',
+        :rackspace_compute_url => 'https://my-custom-endpoint.com'
+        returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+        returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
+    end
+  end
+
+  tests('default auth') do
+    pending if Fog.mocking?
+
+    tests('no params').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_region => nil
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
+      @service.list_flavors
+    end
+    tests('specify old contstant style service endoint').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_endpoint => Fog::Rackspace::Networking::ORD_ENDPOINT
+      returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Rackspace::Networking::ORD_ENDPOINT}/ ) != nil }
+      @service.list_flavors
+    end
+    tests('specify region').succeeds do
+      @service = Fog::Rackspace::Networking.new :rackspace_region => :ord
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil }
+      @service.list_flavors
+    end
+    tests('custom endpoint') do
+      @service = Fog::Rackspace::Networking.new :rackspace_compute_url => 'https://my-custom-endpoint.com'
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
+    end
+  end
+
+  tests('reauthentication') do
+    pending if Fog.mocking?
+
+    tests('should reauth with valid credentials') do
+      @service = Fog::Rackspace::Networking.new
+      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
+      @service.instance_variable_set("@auth_token", "bad_token")
+      returns(true) { [200, 203].include? @service.list_flavors.status }
+    end
+    tests('should terminate with incorrect credentials') do
+      raises(Excon::Errors::Unauthorized) { Fog::Rackspace::Networking.new :rackspace_api_key => 'bad_key' }
+    end
+  end
+
+end

data/tests/rackspace/requests/networking/network_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Rackspace::Networking | network_tests', ['rackspace']) do
+  service = Fog::Rackspace::Networking.new
+
+  network_format = {
+    'id' => String,
+    'label' => String,
+    'cidr' => Fog::Nullable::String
+  }
+
+  get_network_format = {
+    'network' => network_format
+  }
+
+  list_networks_format = {
+    'networks' => [network_format]
+  }
+
+  tests('success') do
+    network_id = nil
+
+    tests('#create_network').formats(get_network_format) do
+      service.create_network("fog_#{Time.now.to_i.to_s}", '192.168.0.0/24').body.tap do |r|
+        network_id = r['network']['id']
+      end
+    end
+
+    tests('#list_networks').formats(list_networks_format) do
+      service.list_networks.body
+    end
+
+    tests('#get_network').formats(get_network_format) do
+      service.get_network(network_id).body
+    end
+
+    tests('#delete_network').succeeds do
+      service.delete_network(network_id)
+    end
+  end
+
+  test('failure') do
+    tests('#get_network').raises(Fog::Rackspace::Networking::NotFound) do
+      service.get_network(0)
+    end
+
+    tests('#delete_network').raises(Fog::Rackspace::Networking::NotFound) do
+      service.delete_network(0)
+    end
+  end
+end

data/tests/rackspace/requests/networking/virtual_interface_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Rackspace::Networking | virtual_interface_tests', ['rackspace']) do
+  @service = Fog::Rackspace::Networking.new
+
+  virtual_interface_format = {
+    "virtual_interfaces"=> [{
+      "ip_addresses"=> [{
+        "network_id"=> String,
+        "network_label"=> String,
+        "address"=> String
+      }],
+      "id"=> String,
+      "mac_address"=> String
+    }]
+  }
+
+  begin
+    unless Fog.mocking?
+      network_id = nil
+
+      @server = @service.servers.create(:name => "fog_virtual_interface_test_#{Time.now.to_i.to_s}",
+                                        :flavor_id => rackspace_test_flavor_id(@service),
+                                        :image_id => rackspace_test_image_id(@service))
+      @server.wait_for { ready? }
+
+      @network = @service.networks.create(:label => "fog_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24')
+    end
+
+    tests('success') do
+      pending if Fog.mocking?
+
+      tests('#create_virtual_interface').formats(virtual_interface_format) do
+        response = @service.create_virtual_interface @server.id, @network.id
+        body = response.body
+        @virtual_network_interface_id = body["virtual_interfaces"].first["id"]
+        body
+      end
+        tests('#list_virtual_interfaces').formats(virtual_interface_format) do
+          @service.list_virtual_interfaces(@server.id).body
+        end
+
+        tests('#delete_virtual_interfaces').succeeds do
+          @service.delete_virtual_interface(@server.id, @virtual_network_interface_id)
+        end
+      end
+  ensure
+    @server.destroy if @server
+    delete_test_network @network
+  end
+end