fog 1.22.1 → 1.23.0

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

@@ -1,6 +1,9 @@
+require 'securerandom'
+
 Shindo.tests('Fog::Storage[:google] | object requests', ["google"]) do
 
-  @directory = Fog::Storage[:google].directories.create(:key => 'fogobjecttests')
+  random_string = SecureRandom.hex
+  @directory = Fog::Storage[:google].directories.create(:key => "fog-test-object-#{random_string}")
 
   tests('success') do
 

data/tests/helpers/collection_helper.rb

@@ -71,7 +71,7 @@ def collection_tests(collection, params = {}, mocks_implemented = true)
     end
 
     if block_given?
-      yield
+      yield(@instance)
     end
 
     if !Fog.mocking? || mocks_implemented

data/tests/helpers/mock_helper.rb

@@ -65,6 +65,9 @@ if Fog.mock?
     :ninefold_storage_token           => 'ninefold_storage_token',
 #    :public_key_path                  => '~/.ssh/id_rsa.pub',
 #    :private_key_path                 => '~/.ssh/id_rsa',
+    :opennebula_endpoint              => 'http://opennebula:2633/RPC2',
+    :opennebula_username              => 'oneadmin',
+    :opennebula_password              => 'oneadmin',
     :openstack_api_key                => 'openstack_api_key',
     :openstack_username               => 'openstack_username',
     :openstack_tenant                 => 'openstack_tenant',

data/tests/helpers/model_helper.rb

@@ -9,7 +9,7 @@ def model_tests(collection, params = {}, mocks_implemented = true)
     end
 
     if block_given?
-      yield
+      yield(@instance)
     end
 
     tests("#destroy").succeeds do

data/tests/opennebula/compute_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('Fog::Compute[:opennebula]', ['opennebula']) do
+
+  compute = Fog::Compute[:opennebula]
+
+  tests("Compute collections") do
+    %w{networks groups}.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+
+  tests("Compute requests") do
+    %w{list_networks}.each do |request|
+      test("it should respond to #{request}") { compute.respond_to? request }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Compute[:opennebula] | group model', ['opennebula']) do
+
+  groups = Fog::Compute[:opennebula].groups
+  group = groups.last
+
+  tests('The group model should') do
+    tests('have the action') do
+      test('reload') { group.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = group.attributes
+      attributes = 
+      tests("The group model should respond to") do
+        [:name, :id, :to_label].each do |attribute|
+          test("#{attribute}") { group.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        [:name, :id].each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::OpenNebula::Group') { group.kind_of? Fog::Compute::OpenNebula::Group }
+  end
+
+end

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

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

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

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Compute[:opennebula] | network model', ['opennebula']) do
+
+  networks = Fog::Compute[:opennebula].networks
+  network = networks.last
+
+  tests('The network model should') do
+    tests('have the action') do
+      test('reload') { network.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = network.attributes
+      attributes = 
+      tests("The network model should respond to") do
+        [:name, :id, :vlan, :uid, :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|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::OpenNebula::Network') { network.kind_of? Fog::Compute::OpenNebula::Network }
+  end
+
+end

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

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Compute[:opennebula] | networks collection', ['opennebula']) do
+
+  networks = Fog::Compute[:opennebula].networks
+
+  tests('The networks collection') do
+    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('by instance id').succeeds { networks.get networks.first.id }
+    end
+  end
+
+end

data/tests/opennebula/requests/compute/vm_allocate_tests.rb

@@ -0,0 +1,59 @@
+Shindo.tests("Fog::Compute[:opennebula] | vm_create and destroy request", 'opennebula') do
+
+  compute = Fog::Compute[:opennebula]
+  name_base = Time.now.to_i
+  f = compute.flavors.get_by_name("fogtest")
+
+  tests("Get 'fogtest' flavor/template") do
+    test("could not get template with name 'fogtest'! This is required for live tests!") {f.kind_of? Array}
+    raise ArgumentError, "Could not get a template with the name 'fogtest'" unless f
+  end
+
+  f = f.first
+  response = {}
+
+  tests("Allocate VM") do
+    response = compute.vm_allocate({:name => 'fog-'+name_base.to_s, :flavor => f})
+    test("response should be a kind of Hash") { response.kind_of?  Hash}
+    test("id should be a one-id (Fixnum)") { response['id'].is_a?  Fixnum}
+  end
+  tests("Destroy VM") do
+    compute.vm_destroy(response['id'])
+    vms = compute.list_vms({:id => response['id'], :mock_return => false})
+    test("get vm should be empty") { compute.list_vms({:id => response['id']}).empty?}
+  end
+
+  #tests("Create VM from template (clone)") do
+  #  response = compute.create_vm(:name => 'fog-'+(name_base+ 1).to_s, :template_name => 'hwp_small', :cluster_name => 'Default')
+  #  test("should be a kind of OVIRT::VM") { response.kind_of?  OVIRT::VM}
+  #end
+
+  tests("Fail Creating VM - no flavor") do
+    begin
+      response = compute.vm_allocate({:name => 'fog-'+name_base.to_s, :flavor => nil})
+      test("should be a kind of Hash") { response.kind_of?  Hash} #mock never raise exceptions
+    rescue => e
+      #should raise vm name already exist exception.
+      test("error should be a kind of ArgumentError") { e.kind_of?  ArgumentError}
+    end
+  end
+  tests("Fail Creating VM - nil name") do
+    begin
+      response = compute.vm_allocate({:name => nil, :flavor => f})
+      test("should be a kind of Hash") { response.kind_of?  Hash} #mock never raise exceptions
+    rescue => e
+      #should raise vm name already exist exception.
+      test("error should be a kind of ArgumentError") { e.kind_of?  ArgumentError}
+    end
+  end
+  tests("Fail Creating VM - empty name") do
+    begin
+      response = compute.vm_allocate({:name => "", :flavor => f})
+      test("should be a kind of Hash") { response.kind_of?  Hash} #mock never raise exceptions
+    rescue => e
+      #should raise vm name already exist exception.
+      test("error should be a kind of ArgumentError") { e.kind_of?  ArgumentError}
+    end
+  end
+
+end

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

@@ -164,6 +164,18 @@ Shindo.tests('Fog::Compute[:openstack] | server requests', ['openstack']) do
 
     Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? } if not Fog.mocking?
 
+    #STOP
+    tests("#stop_server(#{@server_id})").succeeds do
+      Fog::Compute[:openstack].stop_server(@server_id)
+    end
+
+    #START
+    tests("#start_server(#{@server_id})").succeeds do
+      Fog::Compute[:openstack].start_server(@server_id)
+    end
+
+    Fog::Compute[:openstack].servers.get(@server_id).wait_for { ready? } if not Fog.mocking?
+
     #DELETE
     tests("#delete_server(#{@server_id})").succeeds do
       Fog::Compute[:openstack].delete_server(@server_id)
@@ -195,6 +207,15 @@ Shindo.tests('Fog::Compute[:openstack] | server requests', ['openstack']) do
       Fog::Compute[:openstack].reboot_server(0)
     end
 
+    tests('#start_server(0)').raises(Fog::Compute::OpenStack::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:openstack].start_server(0)
+    end
+
+    tests('#stop_server(0)').raises(Fog::Compute::OpenStack::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:openstack].stop_server(0)
+    end
   end
 
 end

data/tests/vcloud/data/api_+_vdc_+_1

@@ -7,6 +7,7 @@
             <vmext:VimObjectType>RESOURCE_POOL</vmext:VimObjectType>
         </vmext:VimObjectRef>
     </VCloudExtension>
+    <Link rel="add" type="application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml" href="https://vcloud.example.com/api/vdc/1/action/uploadVAppTemplate" />
     <Link rel="up" type="application/vnd.vmware.vcloud.org+xml" href="https://vcloud.example.com/api/org/1"/>
     <Link rel="add" type="application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml" href="https://vcloud.example.com/api/vdc/1/action/uploadVAppTemplate"/>
     <Link rel="add" type="application/vnd.vmware.vcloud.media+xml" href="https://vcloud.example.com/api/vdc/1/media"/>

data/tests/vcloud_director/models/compute/vapp_tests.rb

@@ -38,4 +38,12 @@ Shindo.tests("Compute::VcloudDirector | vapps", ['vclouddirector', 'all']) do
     tests("#get_by_name").returns(vapp.name) { vapps.get_by_name(vapp.name).name }
     tests("#get").returns(vapp.id) { vapps.get(vapp.id).id }
   end
+
+  tests("Compute::VcloudDirector | vapp", ['custom_fields']) do
+    tests("#set_custom_field").returns('2'){ vapp.custom_fields[:custom_field] = '2' }
+
+    tests("#get_custom_field_by_name").returns('2') { vapp.custom_fields[:custom_field].value }
+    tests("#delete_custom_field").returns([]){ vapp.custom_fields.delete(:custom_field); vapp.custom_fields }
+  end
+
 end

data/tests/vcloud_director/requests/compute/edge_gateway_tests.rb

@@ -2,6 +2,49 @@ Shindo.tests('Compute::VcloudDirector | edge gateway requests', ['vclouddirector
 
   FIREWALL_RULE_ID = '9999'
 
+  @dhcp_configuration = {
+    :GatewayDhcpService => {
+      :IsEnabled => "true",
+      :pools => [{
+        :IsEnabled => "true",
+        :Network => "testNet",
+        :DefaultLeaseTime => "65",
+        :MaxLeaseTime => "650",
+        :LowIpAddress => "192.168.9.2",
+        :HighIpAddress => "192.168.9.20"
+      }]
+    }
+  }
+
+  @vpn_configuration = {
+    :GatewayIpsecVpnService => 
+      {
+        :IsEnabled => "true",
+        :Tunnel => {
+          :Name => "test vpn",
+          :PeerIpAddress => "110.110.110.110",
+          :PeerId => "1223-123UDH-12321",
+          :LocalIpAddress => "192.168.90.90",
+          :LocalId => "202UB-9602-UB629",
+          :PeerSubnet => {
+            :Name => "192.168.0.0/18",
+            :Gateway => "192.168.0.0",
+            :Netmask => "255.255.192.0",
+          },
+          :SharedSecret => "dont tell anyone",
+          :SharedSecretEncrypted => "false",
+          :EncryptionProtocol => "AES",
+          :Mtu => "1500",
+          :IsEnabled => "true",
+          :LocalSubnet => [{
+            :Name => "VDC Network",
+            :Gateway => "192.168.90.254",
+            :Netmask => "255.255.255.0"
+          }]
+        }
+      }
+  }
+
   @new_edge_gateway_configuration = {
     :FirewallService =>
       {
@@ -28,7 +71,7 @@ Shindo.tests('Compute::VcloudDirector | edge gateway requests', ['vclouddirector
           }
         ]
       }
-  }
+  }.merge!(@vpn_configuration).merge!(@dhcp_configuration)
 
   @service = Fog::Compute::VcloudDirector.new
   @org = VcloudDirector::Compute::Helper.current_org(@service)
@@ -75,6 +118,16 @@ Shindo.tests('Compute::VcloudDirector | edge gateway requests', ['vclouddirector
     response = @service.post_configure_edge_gateway_services(@edge_gateway_id, @new_edge_gateway_configuration)
     @service.process_task(response.body)
 
+    tests('#check for DHCP configuration').returns(@new_edge_gateway_configuration[:GatewayDhcpService][:IsEnabled]) do
+      edge_gateway = @service.get_edge_gateway(@edge_gateway_id).body
+      edge_gateway[:Configuration][:EdgeGatewayServiceConfiguration][:GatewayDhcpService][:IsEnabled]
+    end
+
+    tests('#check for VPN').returns(@new_edge_gateway_configuration[:GatewayIpsecVpnService][:IsEnabled]) do
+      edge_gateway = @service.get_edge_gateway(@edge_gateway_id).body
+      edge_gateway[:Configuration][:EdgeGatewayServiceConfiguration][:GatewayIpsecVpnService][:IsEnabled]
+    end
+
     tests('#check for new firewall rule').returns(@new_edge_gateway_configuration[:FirewallService][:FirewallRule]) do
       edge_gateway = @service.get_edge_gateway(@edge_gateway_id).body
       edge_gateway[:Configuration][:EdgeGatewayServiceConfiguration][:FirewallService][:FirewallRule]
@@ -87,6 +140,32 @@ Shindo.tests('Compute::VcloudDirector | edge gateway requests', ['vclouddirector
       edge_gateway = @service.get_edge_gateway(@edge_gateway_id).body
       edge_gateway[:Configuration][:EdgeGatewayServiceConfiguration][:FirewallService][:FirewallRule].find { |rule| rule[:Id] == FIREWALL_RULE_ID }
     end
+
+    tests('#check VPN xml from generator').returns(true) do
+      xml = Nokogiri.XML Fog::Generators::Compute::VcloudDirector::EdgeGatewayServiceConfiguration.new(@vpn_configuration).generate_xml
+      #Not comprehensive, only checks that the generator actually knows how to handle it and that the output looks vagely sane
+      paths = {
+        'GatewayIpsecVpnService>IsEnabled' => 'true',
+        'Tunnel>Name' => 'test vpn',
+        'Tunnel>PeerIpAddress' => '110.110.110.110',
+        'Tunnel>LocalSubnet>Gateway' => '192.168.90.254',
+        'Tunnel>PeerSubnet>Netmask' => '255.255.192.0' }
+      paths.none? { |path| (xml.css path[0]).inner_text != path[1] }
+    end
+
+    tests('#check DHCP xml from generator').returns(true) do
+      xml = Nokogiri.XML Fog::Generators::Compute::VcloudDirector::EdgeGatewayServiceConfiguration.new(@dhcp_configuration).generate_xml
+      paths = {
+          'GatewayDhcpService>IsEnabled' => "true",
+          'GatewayDhcpService>Pool>IsEnabled' => "true",
+          'GatewayDhcpService>Pool>Network' => "testNet",
+          'GatewayDhcpService>Pool>DefaultLeaseTime' => "65",
+          'GatewayDhcpService>Pool>MaxLeaseTime' => "650",
+          'GatewayDhcpService>Pool>LowIpAddress' => "192.168.9.2",
+          'GatewayDhcpService>Pool>HighIpAddress' => "192.168.9.20" }
+      paths.none? { |path| (xml.css path[0]).inner_text != path[1] }
+    end
+
 end
 
   tests('Retrieve non-existent edge gateway').raises(Fog::Compute::VcloudDirector::Forbidden) do

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

@@ -50,16 +50,6 @@ Shindo.tests('Compute::VcloudDirector | network requests', ['vclouddirector']) d
     @service.get_network(@network_id).body
   end
 
-  tests('#get_network_complete').data_matches_schema(VcloudDirector::Compute::Schema::NETWORK_TYPE) do
-    pending if Fog.mocking?
-    link = @org[:Link].find do |l|
-      l[:rel] == 'down' && l[:type] == 'application/vnd.vmware.vcloud.orgNetwork+xml'
-    end
-    pending unless link # nothing to test here cannot continue
-    @network_id = link[:href].split('/').last
-    @service.get_network_complete(@network_id).body
-  end
-
   tests('#get_network_metadata').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
     pending if Fog.mocking?
     pending unless @network_id  # nothing to test here cannot continue
@@ -67,7 +57,7 @@ Shindo.tests('Compute::VcloudDirector | network requests', ['vclouddirector']) d
   end
 
   tests('#post_create_org_vdc_network') do
-    pending unless Fog.mocking?
+    #pending unless Fog.mocking?
     link = @org[:Link].find do |l|
       l[:rel] == 'down' && l[:type] == 'application/vnd.vmware.vcloud.vdc+xml'
     end
@@ -101,13 +91,91 @@ Shindo.tests('Compute::VcloudDirector | network requests', ['vclouddirector']) d
     @service.process_task(body[:Tasks][:Task]) if body && body.key?(:Tasks)
 
     tests('fetched name matches created name').returns(name) do
-      net = @service.get_network(@created_net_id).body
+      net = @service.get_network_complete(@created_net_id).body
       net[:name]
     end
+
+  end
+
+  tests('#get_network_complete schema').data_matches_schema(VcloudDirector::Compute::Schema::NETWORK_TYPE) do
+    link = @org[:Link].find do |l|
+      l[:rel] == 'down' && l[:type] == 'application/vnd.vmware.vcloud.orgNetwork+xml'
+    end
+    pending unless link # nothing to test here cannot continue
+    @network_id = link[:href].split('/').last
+    @service.get_network_complete(@network_id).body
+  end
+
+  tests('#get_network_complete') do
+    new_network = @service.get_network_complete(@created_net_id).body
+    tests('network has a :name') do
+      new_network.fetch(:name)
+    end
+    tests('network has a :Description') do
+      new_network.fetch(:Description)
+    end
+    tests('network has a :Gateway') do
+      new_network[:Configuration][:IpScopes][:IpScope][:Gateway]
+    end
+    tests('network has a several :IpRanges') do
+      new_network[:Configuration][:IpScopes][:IpScope][:IpRanges].size >= 1
+    end
+  end
+
+  tests('#put_network') do
+
+    new_options = {
+      :Description => "Testing put_network",
+      :Configuration => {
+        :IpScopes => {
+          :IpScope => {
+            :IsInherited => 'false',
+            :Gateway => '198.51.100.1',
+            :Netmask => '255.255.255.0',
+            :Dns1    => '198.51.100.2',
+            :Dns2    => '198.51.100.3',
+            :DnsSuffix => 'example.com',
+            :IpRanges => [
+              { :IpRange => { :StartAddress => '198.51.100.10', :EndAddress => '198.51.100.20' } },
+              { :IpRange => { :StartAddress => '198.51.100.30', :EndAddress => '198.51.100.40' } },
+            ]
+          },
+        },
+        :FenceMode => 'isolated',
+      }
+    }
+
+    original_network = @service.get_network_complete(@created_net_id).body
+    name = original_network[:name]
+
+    task = @service.put_network(@created_net_id, name, new_options).body
+    @service.process_task(task)
+
+    tests('fetched :Gateway matches updated :Gateway').returns(
+      new_options[:Configuration][:IpScopes][:IpScope][:Gateway]
+    ) do
+      net = @service.get_network_complete(@created_net_id).body
+      net[:Configuration][:IpScopes][:IpScope][:Gateway]
+    end
+
+    tests('fetched :IpRanges count is matches updated data').returns(
+      new_options[:Configuration][:IpScopes][:IpScope][:IpRanges].size
+    ) do
+      net = @service.get_network_complete(@created_net_id).body
+      # dammit, the API returns with IpRange as a list, not IpRanges
+      net[:Configuration][:IpScopes][:IpScope][:IpRanges][:IpRange].size
+    end
+
+    tests('fetched :Network matches updated :Description').returns(
+      new_options[:Description]
+    ) do
+      net = @service.get_network_complete(@created_net_id).body
+      net[:Description]
+    end
+
   end
 
   tests('#delete_network') do
-    pending unless Fog.mocking?
     @delete_task = @service.delete_network(@created_net_id).body
     @service.process_task(@delete_task)
     tests('created network has been deleted').raises(Fog::Compute::VcloudDirector::Forbidden) do