fog 1.11.1 → 1.12.0

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

@@ -46,6 +46,10 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
       Fog::Storage[:aws].head_object(@directory.identity, 'fog_object')
     end
 
+    tests("#post_object_restore('#{@directory.identity}', 'fog_object')").succeeds do
+      Fog::Storage[:aws].post_object_restore(@directory.identity, 'fog_object')
+    end
+
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', 'private')").succeeds do
       Fog::Storage[:aws].put_object_acl(@directory.identity, 'fog_object', 'private')
     end
@@ -160,6 +164,9 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
       Fog::Storage[:aws].put_object_acl('#{@directory.identity}', 'fog_object', 'invalid')
     end
 
+    tests("#post_object_restore('#{@directory.identity}', 'fog_non_object')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].post_object_restore(@directory.identity, 'fog_non_object')
+    end
   end
 
   @directory.destroy

data/tests/brightbox/oauth2_tests.rb

@@ -7,6 +7,7 @@ Shindo.tests("Fog::Brightbox::OAuth2", ["brightbox"]) do
     @password      = "__mushed_keys_321__"
     @access_token  = "12efde32fdfe4989"
     @refresh_token = "7894389f9074f071"
+    @expires_in    = 7200
 
     tests("with client credentials") do
       credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret)
@@ -30,11 +31,17 @@ Shindo.tests("Fog::Brightbox::OAuth2", ["brightbox"]) do
     end
 
     tests("with existing tokens") do
-      options = {:username => @username, :access_token => @access_token, :refresh_token => @refresh_token}
+      options = {
+        :username => @username,
+        :access_token => @access_token,
+        :refresh_token => @refresh_token,
+        :expires_in => @expires_in
+      }
       credentials = Fog::Brightbox::OAuth2::CredentialSet.new(@client_id, @client_secret, options)
       tests("#user_details?").returns(false) { credentials.user_details? }
       tests("#access_token?").returns(true) { credentials.access_token? }
       tests("#refresh_token?").returns(true) { credentials.refresh_token? }
+      tests("#expires_in").returns(7200) { credentials.expires_in }
       tests("#best_grant_strategy").returns(true) do
         credentials.best_grant_strategy.is_a?(Fog::Brightbox::OAuth2::RefreshTokenStrategy)
       end

data/tests/cloudsigma/models/server_tests.rb

@@ -0,0 +1,72 @@
+Shindo.tests('Fog::Compute[:cloudsigma] | server model', ['cloudsigma']) do
+  service = Fog::Compute[:cloudsigma]
+  servers = Fog::Compute[:cloudsigma].servers
+  server_create_args =  {:name => 'fogtest', :cpu => 2000, :mem => 512*1024**2, :vnc_password => 'myrandompass'}
+
+  model_tests(servers, server_create_args, true) do
+    tests('start_stop').succeeds do
+      @instance.start
+
+      @instance.wait_for(timeout=60)  { status == 'running' }
+
+      @instance.stop
+
+      @instance.wait_for(timeout=60)  { status == 'stopped' }
+    end
+
+    tests('attach_dhcp_nic').succeeds do
+      @instance.add_public_nic()
+      @instance.save
+
+      @instance.reload
+
+      returns('dhcp') { @instance.nics.first.ip_v4_conf.conf }
+      succeeds {/^([0-9a-f]{2}[:]){5}([0-9a-f]{2})$/ === @instance.nics.first.mac}
+    end
+
+    tests('attach_vlan') do
+      if Fog.mocking?
+        # Do not buy subscription with real account
+        service.subscriptions.create({:period=>"1 month", :amount=>1, :resource=>"vlan"})
+        vlan = service.vlans.first
+        vlan.meta['name'] = 'fog-test'
+        vlan.save
+      end
+
+      vlan = service.vlans.find {|vlan| vlan.meta['name'] == 'fog-test'}
+
+      # Skip if there is no vlan marked for fog tests
+      pending unless vlan
+
+      @instance.add_private_nic(vlan)
+      @instance.save
+
+      @instance.reload
+
+      returns(vlan.uuid) { @instance.nics.last.vlan['uuid'] || @instance.nics.last.vlan}
+      succeeds {/^([0-9a-f]{2}[:]){5}([0-9a-f]{2})$/ === @instance.nics.last.mac}
+    end
+
+    tests('attach_volume') do
+      volume_create_args = {:name => 'fogservermodeltest', :size => 1000**3, :media => :cdrom}
+      v = service.volumes.create(volume_create_args)
+      volume_uuid = v.uuid
+
+      @instance.mount_volume(v)
+      @instance.save
+      @instance.reload
+
+      returns(volume_uuid) { @instance.volumes.first.volume }
+
+      @instance.unmount_volume(v)
+      @instance.save
+      @instance.reload
+
+      succeeds { @instance.volumes.empty? }
+
+      v.delete
+
+    end
+  end
+
+end

data/tests/cloudsigma/models/servers_tests.rb

@@ -0,0 +1,7 @@
+Shindo.tests('Fog::Compute[:cloudsigma] | servers collection', ['cloudsigma']) do
+  servers = Fog::Compute[:cloudsigma].servers
+  server_create_args =  {:name => 'fogtest', :cpu => 2000, :mem => 512*1024**2, :vnc_password => 'myrandompass'}
+
+  collection_tests(servers, server_create_args, true)
+
+end

data/tests/cloudsigma/models/volume_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Fog::Compute[:cloudsigma] | volume model', ['cloudsigma']) do
+  volumes = Fog::Compute[:cloudsigma].volumes
+  volume_create_args = {:name => 'fogmodeltest', :size => 1000**3, :media => :cdrom}
+
+  model_tests(volumes, volume_create_args, true) do
+    @instance.wait_for(timeout=60) { status == 'unmounted' }
+
+    tests('#update').succeeds do
+      @instance.media = 'disk'
+      #@instance.size = 1024**3 # resizes disk
+      @instance.save
+
+      @instance.reload
+      @instance.wait_for(timeout=60) { status == 'unmounted' }
+
+      #returns(1024**3) { @instance.size }
+      returns('disk') { @instance.media }
+    end
+  end
+
+end

data/tests/cloudsigma/models/volumes_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests('Fog::Compute[:cloudsigma] | volumes collection', ['cloudsigma']) do
+  volumes = Fog::Compute[:cloudsigma].volumes
+  volume_create_args = {:name => 'fogtest', :size => 1024**3, :media => :cdrom}
+
+  collection_tests(volumes, volume_create_args, true) do
+    @instance.wait_for(timeout=60) { status == 'unmounted' }
+  end
+
+end

data/tests/cloudsigma/requests/server_tests.rb

@@ -0,0 +1,81 @@
+Shindo.tests('Fog::Compute[:cloudsigma] | server requests', ['cloudsigma']) do
+
+  @server_format = {
+      'uuid' => String,
+      'status' => String,
+      'vnc_password' => String,
+      'name' => String,
+      'cpus_instead_of_cores' => Fog::Boolean,
+      'tags' => Array,
+      'mem' => Integer,
+      'enable_numa' => Fog::Boolean,
+      'smp' => Integer,
+      'hv_relaxed'  => Fog::Boolean,
+      'hv_tsc' => Fog::Boolean,
+      'meta' => Fog::Nullable::Hash,
+      'owner' => Fog::Nullable::Hash,
+      'runtime' => Fog::Nullable::Hash,
+      'cpu' => Integer,
+      'resource_uri' => Fog::Nullable::String,
+      'drives' => Array,
+      'nics' => Array
+  }
+
+  @server_create_args = {:name => 'fogtest', :cpu => 2000, :mem => 512*1024**2, :vnc_password => 'myrandompass'}
+
+  tests('success') do
+
+    tests("#create_server(#@server_create_args)").formats(@server_format, false) do
+      server_def = Fog::Compute[:cloudsigma].create_server(@server_create_args).body['objects'].first
+      @server_uuid = server_def['uuid']
+
+      server_def
+    end
+
+    tests("#get_server(#@server_uuid)").formats(@server_format, false) do
+      @resp_server = Fog::Compute[:cloudsigma].get_server(@server_uuid).body
+    end
+
+    tests("#update_server(#@server_uuid)").formats(@server_format, false) do
+      @resp_server['cpu'] = 1000
+      @resp_server = Fog::Compute[:cloudsigma].update_server(@server_uuid, @resp_server).body
+
+      @resp_server
+
+    end
+
+    tests("#start_server(#@server_uuid)").succeeds do
+      response = Fog::Compute[:cloudsigma].start_server(@server_uuid)
+
+      response.body['result'] == "success"
+    end
+
+
+    server = Fog::Compute[:cloudsigma].servers.get(@server_uuid)
+    server.wait_for { status == 'running' }
+
+
+    tests("#stop_server(#@server_uuid)").succeeds do
+      response = Fog::Compute[:cloudsigma].stop_server(@server_uuid)
+
+      response.body['result'] == "success"
+    end
+
+
+    server = Fog::Compute[:cloudsigma].servers.get(@server_uuid)
+    server.wait_for { status == 'stopped' }
+
+
+    tests("#delete_server(#@server_uuid)").succeeds do
+      resp = Fog::Compute[:cloudsigma].delete_server(@server_uuid)
+
+      resp.body.empty? && resp.status == 204
+    end
+  end
+
+  tests('failure') do
+    tests("#get_server(#@server_uuid)|deleted|").raises(Fog::CloudSigma::Errors::NotFound) do
+      Fog::Compute[:cloudsigma].get_server(@server_uuid).body
+    end
+  end
+end

data/tests/cloudsigma/requests/volumes_tests.rb

@@ -0,0 +1,55 @@
+Shindo.tests('Fog::Compute[:cloudsigma] | volume requests', ['cloudsigma']) do
+
+  @volume_format = {
+      'uuid' => String,
+      'size' => Integer,
+      'status' => String,
+      'name' => String,
+      'tags' => Array,
+      'meta' => Fog::Nullable::Hash,
+      'owner' => Fog::Nullable::Hash,
+      'resource_uri' => Fog::Nullable::String,
+      'licenses' => Array,
+      'jobs' => Array,
+      'affinities' => Array,
+      'mounted_on' => Array,
+      'media' => String,
+      'allow_multimount' => Fog::Boolean
+  }
+
+  @volume_create_args = {:name => 'fogtest', :size => 1024**3, :media => :cdrom}
+
+  tests('success') do
+
+    tests("#create_volume(#@volume_create_args)").formats(@volume_format, false) do
+      @resp_volume = Fog::Compute[:cloudsigma].create_volume(@volume_create_args).body['objects'].first
+      @volume_uuid = @resp_volume['uuid']
+
+      @resp_volume
+    end
+
+    volume = Fog::Compute[:cloudsigma].volumes.get(@volume_uuid)
+    volume.wait_for { status == 'unmounted' }
+
+    tests("#update_volume(#@volume_uuid)").formats(@volume_format, false) do
+      @resp_volume['media'] = 'disk'
+      @resp_volume = Fog::Compute[:cloudsigma].update_volume(@volume_uuid, @resp_volume).body
+
+      @resp_volume
+    end
+
+    tests("#delete_volume(#@volume_uuid)").succeeds do
+      resp = Fog::Compute[:cloudsigma].delete_volume(@volume_uuid)
+
+      resp.body.empty? && resp.status == 204
+    end
+
+  end
+
+  tests('failure') do
+    tests("#get_volume(#@server_uuid)|deleted|").raises(Fog::CloudSigma::Errors::NotFound) do
+      Fog::Compute[:cloudsigma].get_volume(@volume_uuid).body
+    end
+  end
+
+end

data/tests/dynect/requests/dns/dns_tests.rb

@@ -175,7 +175,7 @@ Shindo.tests('Dynect::dns | DNS requests', ['dynect', 'dns']) do
       old_mock_value = Excon.defaults[:mock]
       Excon.stubs.clear
 
-      tests("returns final response from a complete job") do
+      tests("returns final response from a complete job").returns({"status" => "success"}) do
         begin
           Excon.defaults[:mock] = true
 
@@ -184,14 +184,14 @@ Shindo.tests('Dynect::dns | DNS requests', ['dynect', 'dns']) do
           Excon.stub({:method => :get, :path => "/REST/Zone/example.com"}, {:status => 307, :body => '/REST/Job/150576635', :headers => {'Content-Type' => 'text/html', 'Location' => '/REST/Job/150576635'}})
           Excon.stub({:method => :get, :path => "/REST/Job/150576635"}, {:status => 307, :body => '{"status":"success"}', :headers => {'Content-Type' => 'application/json'}})
 
-          Fog::DNS::Dynect::Real.new.request(:method => :get, :path => "Zone/example.com").body.should == { "status" => "success" }
+          Fog::DNS::Dynect::Real.new.request(:method => :get, :path => "Zone/example.com").body
         ensure
           Excon.stubs.clear
           Excon.defaults[:mock] = old_mock_value
         end
       end
 
-      tests("passes expects through when polling a job") do
+      tests("passes expects through when polling a job").returns({"status" => "success"}) do
         begin
           Excon.defaults[:mock] = true
 
@@ -200,7 +200,7 @@ Shindo.tests('Dynect::dns | DNS requests', ['dynect', 'dns']) do
           Excon.stub({:method => :get, :path => "/REST/Zone/example.com"}, {:status => 307, :body => '/REST/Job/150576635', :headers => {'Content-Type' => 'text/html', 'Location' => '/REST/Job/150576635'}})
           Excon.stub({:method => :get, :path => "/REST/Job/150576635"}, {:status => 404, :body => '{"status":"success"}', :headers => {'Content-Type' => 'application/json'}})
 
-          Fog::DNS::Dynect::Real.new.request(:method => :get, :expects => 404, :path => "Zone/example.com").body.should == { "status" => "success" }
+          Fog::DNS::Dynect::Real.new.request(:method => :get, :expects => 404, :path => "Zone/example.com").body
         ensure
           Excon.stubs.clear
           Excon.defaults[:mock] = old_mock_value

data/tests/helper.rb

@@ -4,6 +4,8 @@ ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
 require 'fog'
 require 'fog/bin' # for available_providers and registered_providers
 
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
 require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
 
 def lorem_file
@@ -18,7 +20,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"]
+all_providers = all_providers - ["libvirt", "vmfusion", "openvz"]
 
 available_providers = Fog.available_providers.map {|provider| provider.downcase}
 

data/tests/helpers/mock_helper.rb

@@ -93,6 +93,8 @@ if Fog.mock?
     :vsphere_expected_pubkey_hash     => 'abcdef1234567890',
     :libvirt_uri                      => 'qemu:///system',
     :libvirt_username                 => 'root',
-    :libvirt_password                 => 'password'
+    :libvirt_password                 => 'password',
+    :cloudsigma_username              => 'csuname',
+    :cloudsigma_password              => 'cspass'
   }.merge(Fog.credentials)
 end

data/tests/joyent/requests/compute/networks_tests.rb

@@ -0,0 +1,39 @@
+Shindo.tests("Fog::Compute[:joyent] | network requests", ["joyent"]) do
+  @provider = Fog::Compute[:joyent]
+  @network_format = {
+    "id" => String,
+    "name" => String,
+    "public" => Fog::Boolean
+  }
+
+  if Fog.mock?
+    @networks = Fog::Compute[:joyent].data[:networks] = {
+      "193d6804-256c-4e89-a4cd-46f045959993" => {
+        "id" => "193d6804-256c-4e89-a4cd-46f045959993",
+        "name" => "Joyent-SDC-Private",
+        "public" => false
+      },
+      "1e7bb0e1-25a9-43b6-bb19-f79ae9540b39" => {
+        "id" => "1e7bb0e1-25a9-43b6-bb19-f79ae9540b39",
+        "name" => "Joyent-SDC-Public",
+        "public" => true
+      }
+    }
+  end
+
+  tests("#list_networks") do
+    if Fog.mock?
+      returns(@networks.length, "correct number of networks") do
+        @provider.list_networks.body.length
+      end
+    end
+
+    returns(Array, "returns an Array of networks") do
+      @provider.list_networks.body.class
+    end
+
+    formats([@network_format]) do
+      @provider.list_networks.body
+    end
+  end
+end

data/tests/openstack/models/image/images_tests.rb

@@ -7,6 +7,11 @@ Shindo.tests("Fog::Image[:openstack] | images", ['openstack']) do
       image.id == @instance['image']['id']
     end
 
+    tests('#get').succeeds do
+      image = Fog::Image[:openstack].images.get(@instance['image']['id'])
+      image.id == @instance['image']['id']
+    end
+    
     tests('#destroy').succeeds do
       Fog::Image[:openstack].images.destroy(@instance['image']['id'])
     end

data/tests/openstack/models/network/lb_health_monitor_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests("Fog::Network[:openstack] | lb_health_monitor", ['openstack']) do
+
+  tests('success') do
+    before do
+      @lb_pool = Fog::Network[:openstack].lb_pools.create(:subnet_id => 'subnet_id',
+                                                          :protocol => 'HTTP',
+                                                          :lb_method => 'ROUND_ROBIN')
+    end
+
+    after do
+      @lb_pool.destroy
+    end
+
+    tests('#create').succeeds do
+      @instance = Fog::Network[:openstack].lb_health_monitors.create(:type => 'PING',
+                                                                     :delay => 1,
+                                                                     :timeout => 5,
+                                                                     :max_retries => 10,
+                                                                     :http_method => 'GET',
+                                                                     :url_path => '/',
+                                                                     :expected_codes => '200, 201',
+                                                                     :admin_state_up => true,
+                                                                     :tenant_id => 'tenant_id')
+      !@instance.id.nil?
+    end
+
+    tests('#update').succeeds do
+      @instance.delay = 5
+      @instance.timeout = 10
+      @instance.max_retries = 20
+      @instance.http_method = 'POST'
+      @instance.url_path = '/varz'
+      @instance.expected_codes = '200'
+      @instance.admin_state_up = false
+      @instance.update
+    end
+
+    tests('#associate_to_pool').succeeds do
+      @instance.associate_to_pool(@lb_pool.id)
+    end
+
+    tests('#disassociate_from_pool').succeeds do
+      @instance.disassociate_from_pool(@lb_pool.id)
+    end
+
+    tests('#destroy').succeeds do
+      @instance.destroy == true
+    end
+
+  end
+
+end