fog 1.3.1 → 1.4.0

data/tests/openstack/requests/identity/user_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Fog::Identity[:openstack] | user requests', ['openstack']) do
+
+  @user_format = {
+    'id'   => String,
+    'name' => String,
+    'enabled'  => Fog::Boolean,
+    'email'    => String,
+    'tenantId' => Fog::Nullable::String
+  }
+
+  tests('success') do
+    tests('#create_user("Onamae", "spoof", "user@email.com", "t3n4nt1d", true)').formats(@user_format, false) do
+      @user = Fog::Identity[:openstack].create_user("Onamae", "spoof", "morph@example.com", "m0rPh1d").body['user']
+    end
+
+    tests('#list_users').formats({'users' => [@user_format]}) do
+      Fog::Identity[:openstack].list_users.body
+    end
+
+    tests("#update_user(#{@user['id']}, :name => 'fogupdateduser')").succeeds do
+      Fog::Identity[:openstack].update_user(@user['id'], :name => 'fogupdateduser', :email => 'fog@test.com')
+    end
+
+    tests("#delete_user(#{@user['id']})").succeeds do
+      Fog::Identity[:openstack].delete_user(@user['id'])
+    end
+
+  end
+end

data/tests/openstack/requests/image/image_tests.rb

@@ -0,0 +1,98 @@
+Shindo.tests('Fog::Image[:openstack] | image requests', ['openstack']) do
+
+  @image_format = {
+    'id' => String,
+    'name' => String,
+    'size' => Fog::Nullable::Integer,
+    'disk_format' => Fog::Nullable::String,
+    'container_format' => Fog::Nullable::String,
+    'checksum' => Fog::Nullable::String,
+    'min_disk'  => Fog::Nullable::Integer,
+    'created_at' => Fog::Nullable::String,
+    'deleted_at' => Fog::Nullable::String,
+    'updated_at' => Fog::Nullable::String,
+    'deleted' => Fog::Nullable::Boolean,
+    'protected' => Fog::Nullable::Boolean,
+    'is_public' => Fog::Nullable::Boolean,
+    'status' => Fog::Nullable::String,
+    'min_ram' => Fog::Nullable::Integer,
+    'owner' => Fog::Nullable::String,
+    'properties' => Fog::Nullable::Hash
+  }
+
+  @image_meta_format ={
+                     "X-Image-Meta-Is_public"=>String,
+                     "X-Image-Meta-Min_disk"=>Fog::Nullable::String,
+                     "X-Image-Meta-Property-Ramdisk_id"=>Fog::Nullable::String,
+                     "X-Image-Meta-Disk_format"=>Fog::Nullable::String,
+                     "X-Image-Meta-Created_at"=>String,
+                     "X-Image-Meta-Container_format"=>Fog::Nullable::String,
+                     "Etag"=>String,
+                     "Location"=>String,
+                     "X-Image-Meta-Protected"=>String,
+                     "Date"=>String,
+                     "X-Image-Meta-Name"=>String,
+                     "X-Image-Meta-Min_ram"=>String,
+                     "Content-Type"=>String,
+                     "X-Image-Meta-Updated_at"=>String,
+                     "X-Image-Meta-Property-Kernel_id"=>Fog::Nullable::String,
+                     "X-Image-Meta-Size"=>String,
+                     "X-Image-Meta-Checksum"=>Fog::Nullable::String,
+                     "X-Image-Meta-Deleted"=>String,
+                     "Content-Length"=>String,
+                     "X-Image-Meta-Owner"=>String,
+                     "X-Image-Meta-Status"=>String,
+                     "X-Image-Meta-Id"=>String}
+
+  @image_members_format =[
+                          {"can_share"=>Fog::Nullable::Boolean,
+                           "member_id"=>String
+                          }
+                         ]
+
+  tests('success') do
+    tests('#list_public_images').formats({'images' => [@image_format]}) do
+      Fog::Image[:openstack].list_public_images.body
+    end
+
+    tests('#list_public_images_detailed').formats({'images' => [@image_format]}) do
+      Fog::Image[:openstack].list_public_images.body
+    end
+
+    tests('#create_image').formats({'image' => @image_format}) do
+      @instance = Fog::Image[:openstack].create_image({:name => "test image"}).body
+    end
+
+    tests('#get_image').formats(@image_meta_format) do
+       Fog::Image[:openstack].get_image(@instance['image']['id']).headers
+    end
+
+    tests('#update_image').formats(@image_format) do
+       Fog::Image[:openstack].update_image({:id => @instance['image']['id'],
+                                            :name => "edit image"}).body['image']
+    end
+
+    tests('#add_member_to_image').succeeds do
+       Fog::Image[:openstack].add_member_to_image(
+           @instance['image']['id'], @instance['image']['owner'])
+    end
+
+    tests('#get_image_members').succeeds do
+       Fog::Image[:openstack].get_image_members(@instance['image']['id'])
+    end
+
+    tests('#get_shared_images').succeeds do
+       Fog::Image[:openstack].get_shared_images(@instance['image']['owner'])
+    end
+
+    tests('#remove_member_from_image').succeeds do
+       Fog::Image[:openstack].remove_member_from_image(
+           @instance['image']['id'], @instance['image']['owner'])
+    end
+
+    tests('#delete_image').succeeds do
+      Fog::Image[:openstack].delete_image(@instance['image']['id'])
+    end
+
+  end
+end

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

@@ -7,7 +7,7 @@ Shindo.tests('Fog::Compute[:ovirt] | storage_domains request', ['ovirt']) do
     response = compute.storage_domains
     tests("The response data format ...") do
       test("it should be a kind of Array") { response.kind_of? Array }
-      test("be a kind of Hash") { response.first.kind_of? Hash }
+      test("be a kind of OVIRT::StorageDomain") { response.first.kind_of? OVIRT::StorageDomain }
     end
   end
 end

data/tests/rackspace/helper.rb

@@ -10,7 +10,7 @@ module Shindo
             :protocol => 'HTTP',
             :port => 80,
             :virtual_ips => [{ :type => 'PUBLIC'}],
-            :nodes => [{ :address => '10.0.0.1', :port => 80, :condition => 'ENABLED'}]
+            :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]
           })
         @lb.wait_for { ready? }
       begin

data/tests/rackspace/models/load_balancers/access_list_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | access_list', ['rackspace']) do
 
   given_a_load_balancer_service do
     given_a_load_balancer do
-      model_tests(@lb.access_rules, { :address => '10.0.0.2', :type => 'ALLOW'}, false) do
+      model_tests(@lb.access_rules, { :address => '1.1.1.2', :type => 'ALLOW'}, false) do
         @lb.wait_for { ready? }
       end
     end

data/tests/rackspace/models/load_balancers/access_lists_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | access_lists', ['rackspace']) do
 
   given_a_load_balancer_service do
     given_a_load_balancer do
-      collection_tests(@lb.access_rules, { :address => '10.0.0.2', :type => 'ALLOW'}, false) do
+      collection_tests(@lb.access_rules, { :address => '1.1.1.2', :type => 'ALLOW'}, false) do
         @lb.wait_for { ready? }
       end
     end

data/tests/rackspace/models/load_balancers/load_balancer_tests.rb

@@ -7,7 +7,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do
       :protocol => 'HTTP',
       :port => 80,
       :virtual_ips => [{ :type => 'PUBLIC'}],
-      :nodes => [{ :address => '10.0.0.1', :port => 80, :condition => 'ENABLED'}]
+      :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]
     }
 
   given_a_load_balancer_service do
@@ -127,6 +127,18 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer', ['rackspace']) do
       @instance.wait_for { ready? }
     end
 
+    tests('create(...with algorithm...)') do
+      attributes = LOAD_BALANCER_ATTRIBUTES.clone
+      attributes[:algorithm] = 'LEAST_CONNECTIONS'
+      @lb = @service.load_balancers.create attributes
+      returns('LEAST_CONNECTIONS') { @lb.algorithm }
+
+      @lb.wait_for { ready? }
+
+      @lb.destroy
+    end
+
+
     tests('failure') do
       @lb = @service.load_balancers.new LOAD_BALANCER_ATTRIBUTES
       tests('#usage => Requires ID').raises(ArgumentError) do

data/tests/rackspace/models/load_balancers/load_balancers_tests.rb

@@ -10,7 +10,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancers', ['rackspace']) do
         :protocol => 'HTTP',
         :port => 80,
         :virtual_ips => [{ :type => 'PUBLIC'}],
-        :nodes => [{ :address => '10.0.0.1', :port => 80, :condition => 'ENABLED'}]
+        :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]
       },
       false) do
       @instance.wait_for { ready? }

data/tests/rackspace/models/load_balancers/node_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | node', ['rackspace']) do
 
   given_a_load_balancer_service do
     given_a_load_balancer do
-      model_tests(@lb.nodes, { :address => '10.0.0.2', :port => 80, :condition => 'ENABLED'}, false) do
+      model_tests(@lb.nodes, { :address => '1.1.1.2', :port => 80, :condition => 'ENABLED'}, false) do
         @lb.wait_for { ready? }
 
         tests("#save() => existing node with port = 88").succeeds do

data/tests/rackspace/models/load_balancers/nodes_tests.rb

@@ -4,7 +4,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | nodes', ['rackspace']) do
 
   given_a_load_balancer_service do
     given_a_load_balancer do
-      collection_tests(@lb.nodes, { :address => '10.0.0.2', :port => 80, :condition => 'ENABLED'}, false) do
+      collection_tests(@lb.nodes, { :address => '1.1.1.2', :port => 80, :condition => 'ENABLED'}, false) do
         @lb.wait_for { ready? }
       end
     end

data/tests/rackspace/requests/load_balancers/helper.rb

@@ -1,4 +1,4 @@
-SINGLE_NODE_FORMAT = {'address' => String, 'id' => Integer, 'status' => String, 'weight' => Fog::Nullable::Integer, 'port' => Integer, 'condition' => String}
+SINGLE_NODE_FORMAT = {'address' => String, 'id' => Integer, 'status' => String, 'weight' => Fog::Nullable::Integer, 'port' => Integer, 'condition' => String, 'type' => String}
 NODE_FORMAT = {'node' => SINGLE_NODE_FORMAT}
 NODES_FORMAT = {'nodes' => [SINGLE_NODE_FORMAT]}
 VIRTUAL_IP_FORMAT = {'type' => String, 'id' => Integer, 'type' => String, 'ipVersion' => String, 'address' => String}
@@ -9,6 +9,13 @@ SOURCE_ADDRESSES = {
   'ipv6Public'      => String,
 }
 LOAD_BALANCER_USAGE_FORMAT = {
+  'links' => [
+    {
+      'otherAttributes' => [],
+      'href' => Fog::Nullable::String,
+      'rel' => Fog::Nullable::String
+    }
+  ],
   'loadBalancerUsageRecords' => [
     {
       'id' => Fog::Nullable::Integer,
@@ -95,7 +102,8 @@ LOAD_BALANCERS_FORMAT = {
       'status' => String,
       'virtualIps' => [VIRTUAL_IP_FORMAT],
       'created' => { 'time' => String },
-      'updated' => { 'time' => String }
+      'updated' => { 'time' => String },
+      'nodeCount' => Integer
     }]
 }
 

data/tests/rackspace/requests/load_balancers/load_balancer_tests.rb

@@ -9,11 +9,20 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_tests', ['rackspace'
       @lb_name = 'fog' + Time.now.to_i.to_s
 
       tests("#create_load_balancer(#{@lb_name}, 'HTTP', 80,...)").formats(LOAD_BALANCER_FORMAT) do
-        data = @service.create_load_balancer(@lb_name, 'HTTP', 80, [{ :type => 'PUBLIC'}], [{ :address => '10.0.0.1', :port => 80, :condition => 'ENABLED'}]).body
+        data = @service.create_load_balancer(@lb_name, 'HTTP', 80, [{ :type => 'PUBLIC'}], [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]).body
         @lb_id = data['loadBalancer']['id']
         data
       end
 
+      tests("#create_load_balancer(#{@lb_name}, 'HTTP', 80,...with algorithm)").formats(LOAD_BALANCER_FORMAT) do
+        data = @service.create_load_balancer(@lb_name, 'HTTP', 80, [{ :type => 'PUBLIC'}], 
+                                             [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}],
+                                             { :algorithm => 'LEAST_CONNECTIONS' }).body
+        @lb_id = data['loadBalancer']['id']
+        returns('LEAST_CONNECTIONS') { data['loadBalancer']['algorithm'] }
+        data
+      end
+
       tests("#update_load_balancer(#{@lb_id}) while immutable").raises(Fog::Rackspace::LoadBalancers::ServiceError) do
         @service.update_load_balancer(@lb_id, { :port => 80 }).body
       end
@@ -30,8 +39,8 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_tests', ['rackspace'
         sleep 10
       end
 
-      tests("#list_load_balancers({:node_address => '10.0.0.1'})").formats(LOAD_BALANCERS_FORMAT) do
-        @service.list_load_balancers({:node_address => '10.0.0.1'}).body
+      tests("#list_load_balancers({:node_address => '1.1.1.1'})").formats(LOAD_BALANCERS_FORMAT) do
+        @service.list_load_balancers({:node_address => '1.1.1.1'}).body
       end
 
       tests("#update_load_balancer(#{@lb_id}, { :port => 80 })").succeeds do
@@ -49,7 +58,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | load_balancer_tests', ['rackspace'
 
     tests('failure') do
       tests('#create_load_balancer(invalid name)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do
-        @service.create_load_balancer('', 'HTTP', 80, [{ :type => 'PUBLIC'}], [{ :address => '10.0.0.1', :port => 80, :condition => 'ENABLED'}])
+        @service.create_load_balancer('', 'HTTP', 80, [{ :type => 'PUBLIC'}], [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}])
       end
 
       tests('#get_load_balancer(0)').raises(Fog::Rackspace::LoadBalancers::NotFound) do

data/tests/rackspace/requests/load_balancers/node_tests.rb

@@ -9,15 +9,15 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | node_tests', ['rackspace']) do
       tests('success') do
 
         @lb.wait_for { ready? }
-        tests("#create_node(#{@lb.id}, '10.10.10.10', 80, 'ENABLED')").formats(NODES_FORMAT) do
-          data = @service.create_node(@lb.id, '10.10.10.10', 80, 'ENABLED').body
+        tests("#create_node(#{@lb.id}, '1.1.1.2', 80, 'ENABLED')").formats(NODES_FORMAT) do
+          data = @service.create_node(@lb.id, '1.1.1.2', 80, 'ENABLED').body
           @nodes_created << data['nodes'][0]['id']
           data
         end
 
         @lb.wait_for { ready? }
         tests('#create_node with weight').formats(NODES_FORMAT) do
-          data = @service.create_node(@lb.id, '10.10.10.11', 80, 'ENABLED', { :weight => 10 }).body
+          data = @service.create_node(@lb.id, '1.1.1.3', 80, 'ENABLED', { :weight => 10 }).body
           @nodes_created << data['nodes'][0]['id']
           data
         end
@@ -53,7 +53,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | node_tests', ['rackspace']) do
           @service.create_node(@lb.id, '', 80, 'ENABLED')
         end
         tests('#create_node(invalid condition)').raises(Fog::Rackspace::LoadBalancers::BadRequest) do
-          @service.create_node(@lb.id, '10.10.10.10', 80, 'EABLED')
+          @service.create_node(@lb.id, '1.1.1.2', 80, 'EABLED')
         end
         tests("#get_node(#{@lb.id}, 0)").raises(Fog::Rackspace::LoadBalancers::NotFound) do
           @service.get_node(@lb.id, 0)
@@ -76,7 +76,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | node_tests', ['rackspace']) do
         end
         @lb.wait_for { ready? }
         tests("#delete_node()").succeeds do
-          node_id = @service.create_node(@lb.id, '10.10.10.12', 80, 'ENABLED').body['nodes'][0]['id']
+          node_id = @service.create_node(@lb.id, '1.1.1.3', 80, 'ENABLED').body['nodes'][0]['id']
           @lb.wait_for { ready? }
           @service.delete_node(@lb.id, node_id)
         end

data/tests/storage/helper.rb

@@ -6,6 +6,9 @@ def storage_providers
     :google     => {
       :mocked => true
     },
+    :hp         => {
+      :mocked => true
+    },
     :local      => {
       :mocked => false
     },

data/tests/vsphere/requests/compute/vm_config_vnc_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_config_vnc request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
+  vnc_spec = {:port => '5900', :password => 'ssaaa', :enabled => 'true'}
+
+  tests('The response should') do
+    response = compute.vm_config_vnc('instance_uuid' => reconfig_target).merge(vnc_spec)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+  end
+
+  tests('VNC attrs response should') do
+    response = compute.vm_get_vnc(reconfig_target)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a port key') { response.has_key? :port }
+  end
+end

data/tests/xenserver/README

@@ -0,0 +1,21 @@
+# Running the XenServer tests.
+
+Tweak the helper.rb file in tests/xenserver/helper.rb to fit your needs.
+
+Fog credentials in $HOME/.fog file are used to run the tests. In particular:
+
+    :default:
+      :xenserver_url: xenserver-test
+      :xenserver_username: root
+      :xenserver_password: secret
+
+We need a working template named squeeze-test available in the XenServer
+to perform the tests. Change the template name to fit your needs
+or create a working template named squeeze-test.
+
+The tests creates a few VMs during the flight. Make sure you have enough RAM and
+Storage available in the hypervisor.
+
+Run the XenServer provider tests issuing:
+
+    shindo tests/xenserver

data/tests/xenserver/compute_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests('Fog::Compute[:xenserver]', ['xenserver']) do
+
+  compute = Fog::Compute[:xenserver]
+
+  tests("Compute attributes") do
+    %w{ default_template }.each do |attr|
+      test("it should respond to #{attr}") { compute.respond_to? attr }
+    end
+  end
+
+  tests("Compute collections") do
+    %w{ pifs vifs hosts storage_repositories servers networks vbds vdis pools }.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+      test("it should respond to #{collection}.all") { eval("compute.#{collection}").respond_to? 'all' }
+      test("it should respond to #{collection}.get") { eval("compute.#{collection}").respond_to? 'get' }
+    end
+    # This will fail if there are no PIFs 
+    # (not sure if that's gonna be a real scenario though)
+    tests("PIFs collection") do
+      test("should have at least one PIF") { compute.pifs.size >= 1 }
+    end
+    
+    # This will fail if there are no VIFs
+    # (not sure if that's gonna be a real scenario though)
+    tests("VIFs collection") do
+      test("should have at least one VIF") { compute.vifs.size >= 1 }
+    end
+    
+    # This will fail if there are no VIFs
+    # (not sure if that's gonna be a real scenario though)
+    tests("Networks collection") do
+      test("should have at least one Network") { compute.networks.size >= 1 }
+      tests("each network should be a Fog::Compute::XenServer::Network") do
+        ok = true
+        compute.networks.each { |n| ok = false if n.kind_of? Fog::Compute::XenServer::Network } 
+      end
+    end
+  end
+
+  tests "Default template" do
+    test("it should NOT have a default template") { compute.default_template.nil? }
+    # This template exists in our XenServer
+    compute.default_template = 'squeeze-test'
+    test("it should have a default template if template exists") { compute.default_template.name == 'squeeze-test' }
+    test("it should be a Fog::Compute::XenServer::Server") { compute.default_template.is_a? Fog::Compute::XenServer::Server }
+    test("it should return nil when not found") do
+      compute.default_template = 'asdfasdfasfdwe'
+      compute.default_template.nil?
+    end
+  end
+end
+

data/tests/xenserver/helper.rb

@@ -0,0 +1,36 @@
+def test_template_name
+  ENV['FOG_XENSERVER_TEMPLATE'] || 'squeeze-test'
+end
+
+def test_ephemeral_vm_name
+  'fog-test-server-shindo'
+end
+
+def valid_ref?(ref)
+  (ref =~ /OpaqueRef:/) and \
+    (ref != "OpaqueRef:NULL" )
+end
+
+def create_ephemeral_vm
+  Fog::Compute[:xenserver].servers.create(:name => test_ephemeral_vm_name, 
+                                          :template_name => test_template_name)
+end
+
+def create_ephemeral_server
+  create_ephemeral_vm
+end
+
+def destroy_ephemeral_servers
+  servers = Fog::Compute[:xenserver].servers
+  # Teardown cleanup
+  (servers.all :name_matches => test_ephemeral_vm_name).each do |s|
+    s.destroy
+  end
+  (servers.templates.find_all { |t| t.name == test_ephemeral_vm_name}).each do |s|
+    s.destroy
+  end
+end
+
+def destroy_ephemeral_vms
+  destroy_ephemeral_servers
+end