fog 1.20.0 → 1.21.0

data/tests/joyent/models/analytics/transformation_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests("Fog::Joyent[:analytics] | transformation", %w{joyent}) do
+  @analytics = Fog::Joyent[:analytics]
+  @transformation = @analytics.transformations.first
+
+  tests('read only') do
+    returns(false, 'should not save') { @transformation.respond_to?(:save)}
+    returns(false, 'should not allow creating a new one') { @transformation.respond_to?(:create)}
+    returns(false, 'should not allow destroying') { @transformation.respond_to?(:destroy)}
+  end
+end

data/tests/joyent/models/analytics/transformations_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests("Fog::Joyent[:analytics] | transformations", %w{joyent}) do
+  @analytics = Fog::Joyent[:analytics]
+  @transformations = @analytics.transformations
+
+  tests('#all').succeeds do
+    @transformations.all
+  end
+
+  tests('#new').succeeds do
+    @transformations.new(['geolocate', { 'label' => 'geolocate IP addresses', "fields" => ["raddr"] }])
+  end
+
+end

data/tests/joyent/models/analytics/type_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests("Fog::Joyent[:analytics] | type", %w{joyent}) do
+  @analytics = Fog::Joyent[:analytics]
+  @type = @analytics.types.first
+
+  tests('read only') do
+    returns(false, 'should not save') { @type.respond_to?(:save)}
+    returns(false, 'should not allow creating a new one') { @type.respond_to?(:create)}
+    returns(false, 'should not allow destroying') { @type.respond_to?(:destroy)}
+  end
+end

data/tests/joyent/models/analytics/types_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests("Fog::Joyent[:analytics] | types", %w{joyent}) do
+  @analytics = Fog::Joyent[:analytics]
+  @types = @analytics.types
+
+  tests('#all').succeeds do
+    @types.all
+  end
+
+  tests('#new').succeeds do
+    @types.new(['string', {'arity' => 'discrete', 'unit' => ''}])
+  end
+
+end

data/tests/joyent/requests/analytics/instrumentation_tests.rb

@@ -0,0 +1,44 @@
+Shindo.tests("Fog::Joyent[:analytics] | instrumentation requests", %w{joyent}) do
+
+  @analytics = Fog::Joyent[:analytics]
+
+  @instrumentation_schema = {
+      'id' => String,
+      'module' => String,
+      'stat' => String,
+      'predicate' => Hash,
+      'decomposition' => [String],
+      'value-dimension' => Integer,
+      'value-arity' => String,
+      'retention-time' => Integer,
+      'granularity' => Integer,
+      'idle-max' => Integer,
+      'transformations' => [String],
+      'persist-data' => Fog::Boolean,
+      'crtime' => Integer,
+      'value-scope' => String,
+      'uris' => [
+          {
+              'uri' => String,
+              'name' => String
+          }
+      ]
+  }
+
+  tests('#create_instrumentation').data_matches_schema(@instrumentation_schema) do
+    @analytics.create_instrumentation.body
+  end
+
+  tests('#list_instrumentations') do
+    data_matches_schema(@instrumentation_schema) do
+      @analytics.list_instrumentations.body.first
+    end
+
+    returns(Array) { @analytics.list_instrumentations.body.class }
+  end
+
+  tests('#delete_instrumentation') do
+    returns(204) { @analytics.delete_instrumentation(Fog::Joyent::Analytics::Mock.data[:instrumentation]['id']).status }
+  end
+
+end

data/tests/libvirt/models/compute/volume_tests.rb

@@ -27,4 +27,12 @@ Shindo.tests('Fog::Compute[:libvirt] | volume model', ['libvirt']) do
     test('be a kind of Fog::Compute::Libvirt::Volume') { volume.kind_of? Fog::Compute::Libvirt::Volume }
   end
 
+  tests('Cloning volumes should') do
+    test('respond to clone_volume') { volume.respond_to? :clone_volume }
+    new_vol = volume.clone_volume('new_vol')
+    # We'd like to test that the :name attr has changed, but it seems that's
+    # not possible, so we can at least check the new_vol xml exists properly
+    test('succeed') { volume.xml == new_vol.xml }
+  end
+
 end

data/tests/openstack/models/compute/server_tests.rb

@@ -2,6 +2,27 @@ Shindo.tests("Fog::Compute[:openstack] | server", ['openstack']) do
 
   tests('success') do
 
+    tests('#floating_ips').succeeds do
+      fog = Fog::Compute[:openstack]
+      net = Fog::Network[:openstack]
+      flavor = fog.flavors.first.id
+      image  = fog.images.first.id
+
+      server = fog.servers.new(:name       => 'test server',
+                               :flavor_ref => flavor,
+                               :image_ref  => image)
+      server.save
+
+      ip1 = net.floating_ips.create(:floating_network_id => 'f0000000-0000-0000-0000\
+-000000000000',
+                                                         :fixed_ip_address => '192.168.11.3')
+
+      server.associate_address(ip1.fixed_ip_address)
+      server.reload
+
+      returns( ["192.168.11.3"] ) { server.floating_ip_addresses }
+    end
+
     tests('#security_groups').succeeds do
       fog = Fog::Compute[:openstack]
 
@@ -41,6 +62,30 @@ Shindo.tests("Fog::Compute[:openstack] | server", ['openstack']) do
       end
     end
 
+    tests('#failed') do
+      
+      fog = Fog::Compute[:openstack]
+
+      flavor = fog.flavors.first.id
+      image  = fog.images.first.id     
+
+      tests('successful server').returns(false) do
+        server = fog.servers.new( :name       => 'test server',
+                                  :flavor_ref => flavor,
+                                  :image_ref  => image,
+                                  :state      => 'success' )
+        server.failed?
+      end
+
+      tests('failed server').returns(true) do
+        server = fog.servers.new( :name       => 'test server',
+                                  :flavor_ref => flavor,
+                                  :image_ref  => image,
+                                  :state      => 'ERROR' )
+        server.failed?
+      end
+
+    end
 
     tests('#metadata').succeeds do
       fog = Fog::Compute[:openstack]

data/tests/openstack/models/identity/users_tests.rb

@@ -14,6 +14,11 @@ Shindo.tests("Fog::Identity[:openstack] | users", ['openstack']) do
       user.id == @instance.id
     end
 
+    tests('#find_by_name').succeeds do
+      user = Fog::Identity[:openstack].users.find_by_name(@instance.name)
+      user.name == @instance.name
+    end
+
     tests('#destroy').succeeds do
       Fog::Identity[:openstack].users.destroy(@instance.id)
     end
@@ -26,6 +31,10 @@ Shindo.tests("Fog::Identity[:openstack] | users", ['openstack']) do
       Fog::Identity[:openstack].users.find_by_id('fake')
     end
 
+    tests('#find_by_name').raises(Fog::Identity::OpenStack::NotFound) do
+      Fog::Identity[:openstack].users.find_by_name('fake')
+    end
+
     tests('#destroy').raises(Fog::Identity::OpenStack::NotFound) do
       Fog::Identity[:openstack].users.destroy('fake')
     end

data/tests/ovirt/compute_tests.rb

@@ -17,7 +17,8 @@ Shindo.tests('Fog::Compute[:ovirt]', ['ovirt']) do
   tests("Compute requests") 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  }.each do |collection|
+        list_virtual_machines list_vm_interfaces storage_domains update_interface update_vm vm_action
+        api_version}.each do |collection|
       test("it should respond to #{collection}") { compute.respond_to? collection }
     end
   end

data/tests/rackspace/helper.rb

@@ -5,17 +5,11 @@ LINKS_FORMAT = [{
 
 module Shindo
   class Tests
-
-    unless Fog.mocking?
-      Fog.timeout = 2000
-      Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
-    end
-
     def given_a_load_balancer_service(&block)
       @service = Fog::Rackspace::LoadBalancers.new
       instance_eval(&block)
     end
-    
+
     def given_a_load_balancer(&block)
         @lb = @service.load_balancers.create({
             :name => ('fog' + Time.now.to_i.to_s),
@@ -32,7 +26,7 @@ module Shindo
         @lb.destroy
       end
     end
-  
+
    def wait_for_request(description = "waiting", &block)
      return if Fog.mocking?
      tests(description) do
@@ -96,4 +90,4 @@ module Shindo
       return true
     end
   end
-end
+end

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

@@ -0,0 +1,33 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interface', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.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/compute_v2/virtual_interfaces_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interfaces', ['rackspace']) do
+  service = Fog::Compute::RackspaceV2.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/requests/compute_v2/virtual_interface_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | virtual_interface_tests', ['rackspace']) do
+  @service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  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

data/tests/sakuracloud/helper.rb

@@ -0,0 +1,7 @@
+def volume_service
+  Fog::Volume[:sakuracloud]
+end
+
+def compute_service
+  Fog::Compute[:sakuracloud]
+end

data/tests/sakuracloud/requests/compute/plans_tests.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+Shindo.tests('Fog::Compute[:sakuracloud] | list_plans request', ['sakuracloud', 'compute']) do
+
+  @plan_format = {
+    'Index'        => Integer,
+    'ID'           => Integer,
+    'Name'         => String,
+    'CPU'          => Integer,
+    'MemoryMB'     => Integer,
+    'Availability' => String
+  }
+
+  tests('success') do
+
+    tests('#list_plans') do
+      serverplans = compute_service.list_plans
+      test 'returns a Hash' do
+        serverplans.body.is_a? Hash
+      end
+      if Fog.mock?
+        tests('ServerPlans').formats(@plan_format, false) do
+          serverplans.body['ServerPlans'].first
+        end
+      else
+        returns(200) { serverplans.status }
+        returns(false) { serverplans.body.empty? }
+      end
+    end
+
+  end
+
+end

data/tests/sakuracloud/requests/compute/servers_tests.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+Shindo.tests('Fog::Compute[:sakuracloud] | list_servers request', ['sakuracloud', 'compute']) do
+
+  @servers_format = {
+    'Index'        => Integer,
+    'ID'           => Integer,
+    'Name'         => String,
+    'ServerPlan'   => Hash,
+    'Instance'     => Hash,
+    'Disks'        => Array
+  }
+
+  tests('success') do
+
+    tests('#list_servers') do
+      servers = compute_service.list_servers
+      test 'returns a Hash' do
+        servers.body.is_a? Hash
+      end
+      if Fog.mock?
+        tests('Servers').formats(@servers_format, false) do
+          servers.body['Servers'].first
+        end
+      else
+        returns(200) { servers.status }
+        returns(true) { servers.body.is_a? Hash }
+      end
+    end
+  end
+end
+
+Shindo.tests('Fog::Compute[:sakuracloud] | create_servers request', ['sakuracloud', 'compute']) do
+  tests('success') do
+    tests('#create_servers') do
+      servers = compute_service.create_server('foobar', 2001)
+      test 'returns a Hash' do
+        servers.body.is_a? Hash
+      end
+
+      unless Fog.mock?
+        returns(201) { servers.status }
+        returns(true) { servers.body.is_a? Hash }
+      end
+    end
+  end
+end

data/tests/sakuracloud/requests/compute/ssh_keys_tests.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+Shindo.tests('Fog::Compute[:sakuracloud] | list_ssh_keys request', ['sakuracloud', 'compute']) do
+
+  @sshkey_format = {
+    'Index'        => Integer,
+    'ID'           => String,
+    'Name'           => String,
+    'PublicKey'    => String
+  }
+
+  tests('success') do
+
+    tests('#list_ssh_keys') do
+      sshkeys = compute_service.list_ssh_keys
+      test 'returns a Hash' do
+        sshkeys.body.is_a? Hash
+      end
+      if Fog.mock?
+        tests('SSHKeys').formats(@sshkey_format, false) do
+          sshkeys.body['SSHKeys'].first
+        end
+      else
+        returns(200) { sshkeys.status }
+        returns(false) { sshkeys.body.empty? }
+      end
+    end
+
+  end
+
+end