fog 0.8.2 → 0.9.0

data/tests/compute/requests/ninefold/nat_tests.rb

@@ -0,0 +1,92 @@
+## Note:
+# If needed, these tests will create a new VM and public IP address. Because this is expensive, you
+# can optionally specify VM_ID and IP_ID as environment variables, and we will use those. Note:
+# The IP must not already have static nat enabled or any port mappings.
+
+Shindo.tests('Fog::Compute[:ninefold] | nat requests', ['ninefold']) do
+
+  if ENV['VM_ID'] && ENV['IP_ID']
+    @ipid, @vmid = ENV['IP_ID'], ENV['VM_ID']
+  elsif !Fog.mock?
+    begin
+      # Create a VM to work with
+      networks = Fog::Compute[:ninefold].list_networks
+      vm_job = Fog::Compute[:ninefold].deploy_virtual_machine(:serviceofferingid => Ninefold::Compute::TestSupport::SERVICE_OFFERING,
+                                                         :templateid => Ninefold::Compute::TestSupport::TEMPLATE_ID,
+                                                         :zoneid => Ninefold::Compute::TestSupport::ZONE_ID,
+                                                         :networkids => networks[0]['id'])
+      @vm = Ninefold::Compute::TestSupport.wait_for_job(vm_job)['jobresult']['virtualmachine']
+      @vmid = @vm['id']
+
+      # Allocate a public IP to work with
+      ip_job = Fog::Compute[:ninefold].associate_ip_address(:zoneid => Ninefold::Compute::TestSupport::ZONE_ID)
+      @ip = Ninefold::Compute::TestSupport.wait_for_job(ip_job)['jobresult']['ipaddress']
+      @ipid = @ip['id']
+    rescue => e
+      puts "*** CREATING VM OR IP FAILED - PLEASE TEST AND CORRECT THIS FIRST"
+      raise e
+    end
+  end
+
+  tests('success') do
+
+    tests("#enable_static_nat()").formats(Ninefold::Compute::Formats::Nat::ENABLE_NAT_RESPONSE) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].enable_static_nat(:ipaddressid => @ipid, :virtualmachineid => @vmid)
+    end
+
+    tests("#create_ip_forwarding_rule()").formats(Ninefold::Compute::Formats::Nat::FORWARDING_RULE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].create_ip_forwarding_rule(:ipaddressid => @ipid,
+                                                         :protocol => 'TCP',
+                                                         :startport => 22)
+      result = Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']['ipforwardingrule']
+      @fwd_rule_id = result['id']
+      result
+    end
+
+    tests("#list_ip_forwarding_rules()").formats(Ninefold::Compute::Formats::Nat::FORWARDING_RULES) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].list_ip_forwarding_rules
+    end
+
+    tests("#delete_ip_forwarding_rule()").formats(Ninefold::Compute::Formats::Nat::DELETE_RULE_RESPONSE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].delete_ip_forwarding_rule(:id => @fwd_rule_id)
+      Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']
+    end
+
+
+    tests("#disable_static_nat()").formats(Ninefold::Compute::Formats::Nat::DISABLE_NAT_RESPONSE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].disable_static_nat(:ipaddressid => @ipid)
+      Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#associate_ip_address()").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].associate_ip_address
+    end
+
+  end
+
+  unless ENV['VM_ID'] && ENV['IP_ID'] || Fog.mock?
+    begin
+      # Kill test VM
+      vm_job = Fog::Compute[:ninefold].destroy_virtual_machine(:id => @vmid)
+      Ninefold::Compute::TestSupport.wait_for_job(vm_job)
+
+      # Disassociate public IP
+      ip_job = Fog::Compute[:ninefold].disassociate_ip_address(:id => @ipid)
+      Ninefold::Compute::TestSupport.wait_for_job(ip_job)
+    rescue => e
+      puts "*** DESTROYING VM OR IP FAILED - PLEASE TEST AND CORRECT THIS FIRST"
+      raise e
+    end
+  end
+
+end

data/tests/compute/requests/ninefold/network_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Fog::Compute[:ninefold] | network requests', ['ninefold']) do
+
+  tests('success') do
+
+    tests("#list_networks()").formats(Ninefold::Compute::Formats::Networks::NETWORKS) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].list_networks()
+    end
+
+  end
+
+  tests('failure') do
+
+    #tests("#deploy_virtual_machine()").raises(Excon::Errors::HTTPStatusError) do
+    #  pending if Fog.mocking?
+    #  Fog::Compute[:ninefold].deploy_virtual_machine
+    #end
+
+  end
+
+end

data/tests/compute/requests/ninefold/template_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Fog::Compute[:ninefold] | template requests', ['ninefold']) do
+
+  tests('success') do
+
+    tests("#list_templates()").formats(Ninefold::Compute::Formats::Templates::TEMPLATES) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].list_templates(:templatefilter => 'executable')
+    end
+
+  end
+
+  tests('failure') do
+
+    #tests("#deploy_virtual_machine()").raises(Excon::Errors::HTTPStatusError) do
+    #  pending if Fog.mocking?
+    #  Fog::Compute[:ninefold].deploy_virtual_machine
+    #end
+
+  end
+
+end

data/tests/compute/requests/ninefold/virtual_machine_tests.rb

@@ -0,0 +1,69 @@
+Shindo.tests('Fog::Compute[:ninefold] | server requests', ['ninefold']) do
+
+  tests('success') do
+
+
+    tests("#deploy_virtual_machine()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINE) do
+      pending if Fog.mocking?
+      networks = Fog::Compute[:ninefold].list_networks
+
+      unless networks[0]
+        raise "No networks, ensure a network has been created by deploying a VM from the web UI and verify list_networks test"
+      end
+
+      newvm = Fog::Compute[:ninefold].deploy_virtual_machine(:serviceofferingid => Ninefold::Compute::TestSupport::SERVICE_OFFERING,
+                                                        :templateid => Ninefold::Compute::TestSupport::TEMPLATE_ID,
+                                                        :zoneid => Ninefold::Compute::TestSupport::ZONE_ID,
+                                                        :networkids => networks[0]['id'])
+      # wait for deployment, stash the job id.
+      @newvmid = newvm['id']
+      Ninefold::Compute::TestSupport.wait_for_job(newvm['jobid'])['jobresult']['virtualmachine']
+    end
+
+    tests("#list_virtual_machines()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINES) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].list_virtual_machines
+    end
+
+    tests("#reboot_virtual_machine()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].reboot_virtual_machine(:id => @newvmid)
+      Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']['virtualmachine']
+    end
+
+    tests("#stop_virtual_machine()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].stop_virtual_machine(:id => @newvmid)
+      Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']['virtualmachine']
+    end
+
+    tests("#change_service_for_virtual_machine()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINE) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].change_service_for_virtual_machine(:id => @newvmid,
+                                                                  :serviceofferingid => Ninefold::Compute::TestSupport::ALT_SERVICE_OFFERING)
+    end
+
+    tests("#start_virtual_machine()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].start_virtual_machine(:id => @newvmid)
+      Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']['virtualmachine']
+    end
+
+    tests("#destroy_virtual_machine()").formats(Ninefold::Compute::Formats::VirtualMachines::VIRTUAL_MACHINE) do
+      pending if Fog.mocking?
+      job = Fog::Compute[:ninefold].destroy_virtual_machine(:id => @newvmid)
+      Ninefold::Compute::TestSupport.wait_for_job(job)['jobresult']['virtualmachine']
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#deploy_virtual_machine()").raises(Excon::Errors::HTTPStatusError) do
+      pending if Fog.mocking?
+      Fog::Compute[:ninefold].deploy_virtual_machine
+    end
+
+  end
+
+end

data/tests/compute/requests/rackspace/address_tests.rb

@@ -1,19 +1,19 @@
-Shindo.tests('Rackspace::Compute | address requests', ['rackspace']) do
+Shindo.tests('Fog::Compute[:rackspace] | address requests', ['rackspace']) do
 
   tests('success') do
 
-    @server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
+    @server = Fog::Compute[:rackspace].servers.create(:flavor_id => 1, :image_id => 19)
 
     tests("#list_addresses(#{@server.id})").formats({'addresses' => {'private' => [String], 'public' => [String]}}) do
-      Rackspace[:compute].list_addresses(@server.id).body
+      Fog::Compute[:rackspace].list_addresses(@server.id).body
     end
 
     tests("#list_private_addresses(#{@server.id})").formats({'private' => [String]}) do
-      Rackspace[:compute].list_private_addresses(@server.id).body
+      Fog::Compute[:rackspace].list_private_addresses(@server.id).body
     end
 
     tests("#list_public_addresses(#{@server.id})").formats({'public' => [String]}) do
-      Rackspace[:compute].list_public_addresses(@server.id).body
+      Fog::Compute[:rackspace].list_public_addresses(@server.id).body
     end
 
     @server.wait_for { ready? }
@@ -23,16 +23,16 @@ Shindo.tests('Rackspace::Compute | address requests', ['rackspace']) do
 
   tests('failure') do
 
-    tests('#list_addresses(0)').raises(Fog::Rackspace::Compute::NotFound) do
-      Rackspace[:compute].list_addresses(0)
+    tests('#list_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      Fog::Compute[:rackspace].list_addresses(0)
     end
 
-    tests('#list_private_addresses(0)').raises(Fog::Rackspace::Compute::NotFound) do
-      Rackspace[:compute].list_private_addresses(0)
+    tests('#list_private_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      Fog::Compute[:rackspace].list_private_addresses(0)
     end
 
-    tests('#list_public_addresses(0)').raises(Fog::Rackspace::Compute::NotFound) do
-      Rackspace[:compute].list_public_addresses(0)
+    tests('#list_public_addresses(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      Fog::Compute[:rackspace].list_public_addresses(0)
     end
 
   end

data/tests/compute/requests/rackspace/flavor_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('Rackspace::Compute | flavor requests', ['rackspace']) do
+Shindo.tests('Fog::Compute[:rackspace] | flavor requests', ['rackspace']) do
 
   @flavor_format = {
     'disk'  => Integer,
@@ -11,26 +11,26 @@ Shindo.tests('Rackspace::Compute | flavor requests', ['rackspace']) do
 
     tests('#get_flavor_details(1)').formats(@flavor_format) do
       pending if Fog.mocking?
-      Rackspace[:compute].get_flavor_details(1).body['flavor']
+      Fog::Compute[:rackspace].get_flavor_details(1).body['flavor']
     end
 
     tests('#list_flavors').formats({'flavors' => [Rackspace::Compute::Formats::SUMMARY]}) do
       pending if Fog.mocking?
-      Rackspace[:compute].list_flavors.body
+      Fog::Compute[:rackspace].list_flavors.body
     end
 
     tests('#list_flavors_detail').formats({'flavors' => [@flavor_format]}) do
       pending if Fog.mocking?
-      Rackspace[:compute].list_flavors_detail.body
+      Fog::Compute[:rackspace].list_flavors_detail.body
     end
 
   end
 
   tests('failure') do
 
-    tests('#get_flavor_details(0)').raises(Fog::Rackspace::Compute::NotFound) do
+    tests('#get_flavor_details(0)').raises(Fog::Compute::Rackspace::NotFound) do
       pending if Fog.mocking?
-      Rackspace[:compute].get_flavor_details(0)
+      Fog::Compute[:rackspace].get_flavor_details(0)
     end
 
   end

data/tests/compute/requests/rackspace/image_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('Rackspace::Compute | image requests', ['rackspace']) do
+Shindo.tests('Fog::Compute[:rackspace] | image requests', ['rackspace']) do
 
   @image_format = {
     'created'   => Fog::Nullable::String,
@@ -12,40 +12,40 @@ Shindo.tests('Rackspace::Compute | image requests', ['rackspace']) do
 
   tests('success') do
 
-    @server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
+    @server = Fog::Compute[:rackspace].servers.create(:flavor_id => 1, :image_id => 19)
     @server.wait_for { ready? }
     @image_id = nil
 
     tests("#create_image(#{@server.id})").formats(@image_format) do
-      data = Rackspace[:compute].create_image(@server.id).body['image']
+      data = Fog::Compute[:rackspace].create_image(@server.id).body['image']
       @image_id = data['id']
       data
     end
 
     unless Fog.mocking?
-      Rackspace[:compute].images.get(@image_id).wait_for { ready? }
+      Fog::Compute[:rackspace].images.get(@image_id).wait_for { ready? }
     end
 
     tests("#get_image_details(#{@image_id})").formats(@image_format) do
       pending if Fog.mocking?
-      Rackspace[:compute].get_image_details(@image_id).body['image']
+      Fog::Compute[:rackspace].get_image_details(@image_id).body['image']
     end
 
     tests('#list_images').formats({'images' => [Rackspace::Compute::Formats::SUMMARY]}) do
-      Rackspace[:compute].list_images.body
+      Fog::Compute[:rackspace].list_images.body
     end
 
     tests('#list_images_detail').formats({'images' => [@image_format]}) do
-      Rackspace[:compute].list_images_detail.body
+      Fog::Compute[:rackspace].list_images_detail.body
     end
 
     unless Fog.mocking?
-      Rackspace[:compute].images.get(@image_id).wait_for { ready? }
+      Fog::Compute[:rackspace].images.get(@image_id).wait_for { ready? }
     end
 
     tests("#delete_image(#{@image_id})").succeeds do
       pending if Fog.mocking? # because it will fail without the wait just above here, which won't work
-      Rackspace[:compute].delete_image(@image_id)
+      Fog::Compute[:rackspace].delete_image(@image_id)
     end
 
     @server.destroy
@@ -55,12 +55,12 @@ Shindo.tests('Rackspace::Compute | image requests', ['rackspace']) do
   tests('failure') do
 
     tests('#delete_image(0)').raises(Excon::Errors::BadRequest) do
-      Rackspace[:compute].delete_image(0)
+      Fog::Compute[:rackspace].delete_image(0)
     end
 
-    tests('#get_image_details(0)').raises(Fog::Rackspace::Compute::NotFound) do
+    tests('#get_image_details(0)').raises(Fog::Compute::Rackspace::NotFound) do
       pending if Fog.mocking?
-      Rackspace[:compute].get_image_details(0)
+      Fog::Compute[:rackspace].get_image_details(0)
     end
 
   end

data/tests/compute/requests/rackspace/resize_tests.rb

@@ -1,27 +1,27 @@
-Shindo.tests('Rackspace::Compute | resize request', ['rackspace']) do
+Shindo.tests('Fog::Compute[:rackspace] | resize request', ['rackspace']) do
 
-    @confirm_server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
+    @confirm_server = Fog::Compute[:rackspace].servers.create(:flavor_id => 1, :image_id => 19)
 
-    @revert_server = Rackspace[:compute].servers.create(:flavor_id => 1, :image_id => 19)
+    @revert_server = Fog::Compute[:rackspace].servers.create(:flavor_id => 1, :image_id => 19)
 
     @confirm_server.wait_for { ready? }
     tests("#resize_server(#{@confirm_server.id}, 2) # to confirm").succeeds do
-      Rackspace[:compute].resize_server(@confirm_server.id, 2)
+      Fog::Compute[:rackspace].resize_server(@confirm_server.id, 2)
     end
 
     @revert_server.wait_for { ready? }
     tests("#resize_server(#{@revert_server.id}, 2) # to revert").succeeds do
-      Rackspace[:compute].resize_server(@revert_server.id, 2)
+      Fog::Compute[:rackspace].resize_server(@revert_server.id, 2)
     end
 
     @confirm_server.wait_for { state == 'VERIFY_RESIZE' }
     tests("#confirm_resized_server(#{@confirm_server.id})").succeeds do
-      Rackspace[:compute].confirm_resized_server(@confirm_server.id)
+      Fog::Compute[:rackspace].confirm_resized_server(@confirm_server.id)
     end
 
     @revert_server.wait_for { state == 'VERIFY_RESIZE' }
     tests("#revert_resized_server(#{@revert_server.id})").succeeds do
-      Rackspace[:compute].revert_resized_server(@revert_server.id)
+      Fog::Compute[:rackspace].revert_resized_server(@revert_server.id)
     end
 
     @confirm_server.wait_for { ready? }

data/tests/compute/requests/rackspace/server_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('Rackspace::Compute | server requests', ['rackspace']) do
+Shindo.tests('Fog::Compute[:rackspace] | server requests', ['rackspace']) do
 
   @server_format = {
     'addresses' => {
@@ -21,70 +21,70 @@ Shindo.tests('Rackspace::Compute | server requests', ['rackspace']) do
 
     tests('#create_server(1, 19)').formats(@server_format.merge('adminPass' => String)) do
       # 1 => 256MB, 19 => Gentoo
-      data = Rackspace[:compute].create_server(1, 19).body['server']
+      data = Fog::Compute[:rackspace].create_server(1, 19).body['server']
       @server_id = data['id']
       data
     end
 
-    Rackspace[:compute].servers.get(@server_id).wait_for { ready? }
+    Fog::Compute[:rackspace].servers.get(@server_id).wait_for { ready? }
 
     tests("#get_server_details(#{@server_id})").formats(@server_format) do
-      Rackspace[:compute].get_server_details(@server_id).body['server']
+      Fog::Compute[:rackspace].get_server_details(@server_id).body['server']
     end
 
     tests('#list_servers').formats({'servers' => [Rackspace::Compute::Formats::SUMMARY]}) do
-      Rackspace[:compute].list_servers.body
+      Fog::Compute[:rackspace].list_servers.body
     end
 
     tests('#list_servers_detail').formats({'servers' => [@server_format]}) do
-      Rackspace[:compute].list_servers_detail.body
+      Fog::Compute[:rackspace].list_servers_detail.body
     end
 
-    Rackspace[:compute].servers.get(@server_id).wait_for { ready? }
+    Fog::Compute[:rackspace].servers.get(@server_id).wait_for { ready? }
 
     tests("#update_server(#{@server_id}, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").succeeds do
-      Rackspace[:compute].update_server(@server_id, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
+      Fog::Compute[:rackspace].update_server(@server_id, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
     end
 
-    Rackspace[:compute].servers.get(@server_id).wait_for { ready? }
+    Fog::Compute[:rackspace].servers.get(@server_id).wait_for { ready? }
 
     tests("#reboot_server(#{@server_id}, 'HARD')").succeeds do
       pending if Fog.mocking?
-      Rackspace[:compute].reboot_server(@server_id, 'HARD')
+      Fog::Compute[:rackspace].reboot_server(@server_id, 'HARD')
     end
 
-    Rackspace[:compute].servers.get(@server_id).wait_for { ready? }
+    Fog::Compute[:rackspace].servers.get(@server_id).wait_for { ready? }
 
     tests("#reboot_server(#{@server_id}, 'SOFT')").succeeds do
       pending if Fog.mocking?
-      Rackspace[:compute].reboot_server(@server_id, 'SOFT')
+      Fog::Compute[:rackspace].reboot_server(@server_id, 'SOFT')
     end
 
-    Rackspace[:compute].servers.get(@server_id).wait_for { ready? }
+    Fog::Compute[:rackspace].servers.get(@server_id).wait_for { ready? }
 
     tests("#delete_server(#{@server_id})").succeeds do
-      Rackspace[:compute].delete_server(@server_id)
+      Fog::Compute[:rackspace].delete_server(@server_id)
     end
 
   end
 
   tests('failure') do
 
-    tests('#delete_server(0)').raises(Fog::Rackspace::Compute::NotFound) do
-      Rackspace[:compute].delete_server(0)
+    tests('#delete_server(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      Fog::Compute[:rackspace].delete_server(0)
     end
 
-    tests('#get_server_details(0)').raises(Fog::Rackspace::Compute::NotFound) do
-      Rackspace[:compute].get_server_details(0)
+    tests('#get_server_details(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      Fog::Compute[:rackspace].get_server_details(0)
     end
 
-    tests("#update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").raises(Fog::Rackspace::Compute::NotFound) do
-      Rackspace[:compute].update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
+    tests("#update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").raises(Fog::Compute::Rackspace::NotFound) do
+      Fog::Compute[:rackspace].update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
     end
 
-    tests('#reboot_server(0)').raises(Fog::Rackspace::Compute::NotFound) do
+    tests('#reboot_server(0)').raises(Fog::Compute::Rackspace::NotFound) do
       pending if Fog.mocking?
-      Rackspace[:compute].reboot_server(0)
+      Fog::Compute[:rackspace].reboot_server(0)
     end
 
   end