fog-vcloud-director 0.1.0

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

@@ -0,0 +1,101 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+Shindo.tests("Compute::VcloudDirector | vms", ['vclouddirector', 'all']) do
+  pending if Fog.mocking?
+  vapp = vapps.find {|v| v.vms.size >= 1}
+
+  # we can't run these tests if there is no vapps with a vm in them
+  pending unless vapp
+
+  vms = vapp.vms
+  vm = vms.first
+
+  tests("Compute::VcloudDirector | vm") do
+    tests("#model").returns(Fog::Compute::VcloudDirector::Vm){vm.class}
+    tests("#id").returns(String){ vm.id.class }
+    tests("#name").returns(String){ vm.name.class }
+    tests("#href").returns(String){ vm.href.class }
+    tests("#deployed").returns(String){ vm.deployed.class }
+    tests("#type").returns("application/vnd.vmware.vcloud.vm+xml"){ vm.type }
+    tests("#vapp_id").returns(String){ vm.vapp_id.class }
+    tests("#status").returns(String){ vm.status.class }
+    tests("#operating_system").returns(String){ vm.operating_system.class }
+    tests("#ip_address").returns(String){ vm.ip_address.class }
+    tests("#cpu").returns(Fixnum){ vm.cpu.class }
+    tests("#memory").returns(Fixnum){ vm.memory.class }
+    tests("#hard_disks").returns(Array){ vm.hard_disks.class }
+    tests("#network_adapters").returns(Array){ vm.network_adapters.class }
+  end
+
+  tests("Compute::VcloudDirector | vm", ['get']) do
+    tests("#get_by_name").returns(vm.name) { vms.get_by_name(vm.name).name }
+    tests("#get").returns(vm.id) { vms.get(vm.id).id }
+  end
+
+  tests("Compute::VcloudDirector | vm | disks") do
+    tests("#collection").returns(Fog::Compute::VcloudDirector::Disks){ vm.disks.class }
+    tests("#get_by_name").returns(Fog::Compute::VcloudDirector::Disk) { vm.disks.get_by_name("Hard disk 1").class }
+
+    hard_disk = vm.disks.get_by_name("Hard disk 1")
+    tests("#id").returns(2000){ hard_disk.id }
+    tests("#name").returns("Hard disk 1"){ hard_disk.name }
+    tests("#description").returns("Hard disk"){ hard_disk.description }
+    tests("#resource_type").returns(17){ hard_disk.resource_type }
+    tests("#address_on_parent").returns(0){ hard_disk.address_on_parent }
+    tests("#parent").returns(2){ hard_disk.parent }
+    tests("#capacity").returns(Fixnum){ hard_disk.capacity.class }
+    tests("#bus_sub_type").returns(String){ hard_disk.bus_sub_type.class }
+    tests("#bus_type").returns(6){ hard_disk.bus_type }
+  end
+
+  tests("Compute::VcloudDirector | vm | customization") do
+    customization = vm.customization
+    tests("#model").returns(Fog::Compute::VcloudDirector::VmCustomization){customization.class}
+    tests("#id").returns(String){ customization.id.class }
+    tests("#href").returns(String){ customization.href.class }
+    tests("#type").returns("application/vnd.vmware.vcloud.guestCustomizationSection+xml"){ customization.type }
+    tests("#virtual_machine_id").returns(String){ customization.virtual_machine_id.class }
+    tests("#computer_name").returns(String){ customization.computer_name.class }
+    tests("#enabled").returns(true){ boolean? customization.enabled }
+    tests("#change_sid").returns(true){ boolean? customization.change_sid }
+    tests("#join_domain_enabled").returns(true){ boolean? customization.join_domain_enabled }
+    tests("#use_org_settings").returns(true){ boolean? customization.use_org_settings }
+    tests("#admin_password_enabled").returns(true){ boolean? customization.admin_password_enabled }
+    tests("#reset_password_required").returns(true){ boolean? customization.reset_password_required }
+  end
+
+  tests("Compute::VcloudDirector | vm | network") do
+    network = vm.network
+    tests("#model").returns(Fog::Compute::VcloudDirector::VmNetwork){network.class}
+    tests("#id").returns(String){ network.id.class }
+    tests("#href").returns(String){ network.href.class }
+    tests("#type").returns("application/vnd.vmware.vcloud.networkConnectionSection+xml"){ network.type }
+    tests("#info").returns(String){ network.info.class }
+    tests("#primary_network_connection_index").returns(Fixnum){ network.primary_network_connection_index.class }
+    tests("#network").returns(String){ network.network.class }
+    tests("#network_connection_index").returns(Fixnum){ network.network_connection_index.class }
+    tests("#mac_address").returns(String){ network.mac_address.class }
+    tests("#ip_address_allocation_mode").returns(String){ network.ip_address_allocation_mode.class }
+    tests("#needs_customization").returns(true){ boolean? network.needs_customization }
+    tests("#is_connected").returns(true){ boolean? network.is_connected }
+  end
+
+  tests("Compute::VcloudDirector | vm | tags") do
+    tags = vm.tags
+    tests("#collection").returns(Fog::Compute::VcloudDirector::Tags){ tags.class }
+  end
+
+  # We should also be able to find this VM via Query API
+  #  :name is not unique for VMs though, so let us query by href
+  tests("Compute::VcloudDirector | vm", ['find_by_query']) do
+    tests('we can retrieve :name without lazy loading').returns(vm.name) do
+      query_vm = vms.find_by_query(:filter => "href==#{vm.href}").first
+      query_vm.attributes[:name]
+    end
+    tests('we can retrieve name via model object returned by query').returns(vm.name) do
+      query_vm = vms.find_by_query(:filter => "href==#{vm.href}").first
+      query_vm.name
+    end
+  end
+
+end

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

@@ -0,0 +1,16 @@
+Shindo.tests('Compute::VcloudDirector | admin requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#get_vcloud').data_matches_schema(VcloudDirector::Compute::Schema::VCLOUD_TYPE) do
+     @service.get_vcloud.body
+  end
+
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+
+  tests('#get_org_settings').returns(Hash) do
+    pending if Fog.mocking?
+    @service.get_org_settings(@org[:href].split('/').last).body.class
+  end
+
+end

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

@@ -0,0 +1,42 @@
+Shindo.tests('Compute::VcloudDirector | catalog requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+
+  tests('#get_catalog').data_matches_schema(VcloudDirector::Compute::Schema::CATALOG_TYPE) do
+    link = @org[:Link].find do |l|
+      l[:rel] == 'down' && l[:type] == 'application/vnd.vmware.vcloud.catalog+xml'
+    end
+    @catalog_id = link[:href].split('/').last
+    pending if Fog.mocking?
+    @catalog = @service.get_catalog(@catalog_id).body
+  end
+
+  tests('#get_catalog_metadata').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
+    pending if Fog.mocking?
+    @service.get_catalog_metadata(@catalog_id).body
+  end
+
+  tests('#get_control_access_params_catalog').data_matches_schema(VcloudDirector::Compute::Schema::CONTROL_ACCESS_PARAMS_TYPE) do
+    pending if Fog.mocking?
+    @service.get_control_access_params_catalog(@org[:href].split('/').last, @catalog_id).body
+  end
+
+  tests('#get_catalogs_from_query') do
+    pending if Fog.mocking?
+    %w[idrecords records references].each do |format|
+      tests(":format => #{format}") do
+        tests('#body').data_matches_schema(VcloudDirector::Compute::Schema::CONTAINER_TYPE) do
+          @body = @service.get_catalogs_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'CatalogReference' : 'CatalogRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+  tests('Retrieve non-existent Catalog').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.get_catalog('00000000-0000-0000-0000-000000000000')
+  end
+
+end

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

@@ -0,0 +1,178 @@
+Shindo.tests('Compute::VcloudDirector | disk requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+  @disk_name = VcloudDirector::Compute::Helper.test_name
+
+  tests('error conditions') do
+    tests('#post_upload_disk') do
+      tests('Invalid size').raises(Fog::Compute::VcloudDirector::BadRequest) do
+        @service.post_upload_disk('00000000-0000-0000-0000-000000000000', @disk_name, -1)
+      end
+    end
+    tests('Upload to non-existent vDC').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.post_upload_disk('00000000-0000-0000-0000-000000000000', @disk_name, 0)
+    end
+    tests('Retrieve non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Retrieve owner of non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk_owner('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Retrieve VM list for non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_vms_disk_attached_to('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Delete non-existent Disk').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.delete_disk('00000000-0000-0000-0000-000000000000')
+    end
+  end
+
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+  @size = 1024
+
+  tests('Upload and manipulate a disk') do
+    tests('#post_upload_disk').data_matches_schema(VcloudDirector::Compute::Schema::DISK_TYPE) do
+      @vdc_id = VcloudDirector::Compute::Helper.first_vdc_id(@org)
+      @disk = @service.post_upload_disk(@vdc_id, @disk_name, @size).body
+    end
+    @service.process_task(@disk[:Tasks][:Task])
+    @disk_id = @disk[:href].split('/').last
+
+    tests("#get_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::DISK_TYPE) do
+      @disk = @service.get_disk(@disk_id).body
+    end
+    tests("disk[:name]").returns(@disk_name) { @disk[:name] }
+    tests("disk[:size]").returns(@size) { @disk[:size].to_i }
+
+    tests("#get_disk_owner(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::OWNER_TYPE) do
+      @owner = @service.get_disk_owner(@disk_id).body
+    end
+    tests("owner[:User][:name]").returns(@service.user_name) { @owner[:User][:name] }
+
+    #tests("#put_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+    #  @disk_name += '-renamed'
+    #  @task = @service.put_disk(@disk_id, @disk_name).body
+    #end
+    #@service.process_task(@task)
+    #tests("#get_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::DISK_TYPE) do
+    #  @disk = @service.get_disk(@disk_id).body
+    #end
+    #tests("disk[:name]").returns(@disk_name) { @disk[:name] }
+    #tests("disk[:size]").returns(@size) { @disk[:size].to_i } # shouldn't change
+
+    tests('disk metadata') do
+      pending if Fog.mocking?
+
+      tests("#put_disk_metadata_item_metadata(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+        @task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-key', 'fog-test-value').body
+      end
+      @service.process_task(@task)
+
+      tests("#put_disk_metadata_item_metadata(#{@disk_id})") do
+        tests("#put_disk_metadata_item_metadata(Boolean)").returns(true) do
+          task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-boolean', true).body
+          @service.process_task(task)
+        end
+        tests("#put_disk_metadata_item_metadata(DateTime)").returns(true) do
+          task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-datetime', DateTime.now).body
+          @service.process_task(task)
+        end
+        tests("#put_disk_metadata_item_metadata(Number)").returns(true) do
+          task = @service.put_disk_metadata_item_metadata(@disk_id, 'fog-test-number', 111).body
+          @service.process_task(task)
+        end
+      end
+
+      tests("#post_update_disk_metadata(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+        metadata = {
+          'fog-test-key-update' => 'fog-test-value-update',
+          'fog-test-boolean-update' => false,
+          'fog-test-datetime-update' => DateTime.now,
+          'fog-test-number-update' => 222
+        }
+        @task = @service.post_update_disk_metadata(@disk_id, metadata).body
+      end
+      @service.process_task(@task)
+
+      tests("#get_disk_metadata(#{@disk_id})") do
+        tests('response format').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
+          @metadata = @service.get_disk_metadata(@disk_id).body
+        end
+        tests('TypedValue') do
+          pending if @service.api_version.to_f < 5.1
+          tests('key').returns('MetadataStringValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-key'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('boolean').returns('MetadataBooleanValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-boolean'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('datetime').returns('MetadataDateTimeValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-datetime'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('number').returns('MetadataNumberValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-number'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('key-update').returns('MetadataStringValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-key-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('boolean-update').returns('MetadataBooleanValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-boolean-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('datetime-update').returns('MetadataDateTimeValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-datetime-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+          tests('number-update').returns('MetadataNumberValue') do
+            entry = @metadata[:MetadataEntry].find {|e| e[:Key] == 'fog-test-number-update'}
+            entry[:TypedValue][:xsi_type]
+          end
+        end
+      end
+    end
+
+    tests("#get_vms_disk_attached_to(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::VMS_TYPE) do
+      pending if Fog.mocking?
+      @service.get_vms_disk_attached_to(@disk_id).body
+    end
+
+    tests("#delete_disk(#{@disk_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+      @task = @service.delete_disk(@disk_id).body
+    end
+    @service.process_task(@task)
+  end
+
+  tests('Disk no longer exists') do
+    tests("#get_disk(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk(@disk_id)
+    end
+    tests("#get_disk_owner(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_disk_owner(@disk_id)
+    end
+    tests("#get_disk_metadata(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      pending if Fog.mocking?
+      @service.get_disk_metadata(@disk_id)
+    end
+    tests("#delete_disk(#{@disk_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.delete_disk(@disk_id)
+    end
+  end
+
+  tests('#get_disks_from_query') do
+    pending if Fog.mocking?
+    %w[idrecords records references].each do |format|
+      tests(":format => #{format}") do
+        tests('#body').data_matches_schema(VcloudDirector::Compute::Schema::CONTAINER_TYPE) do
+          @body = @service.get_disks_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'DiskReference' : 'DiskRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,217 @@
+Shindo.tests('Compute::VcloudDirector | edge gateway requests', ['vclouddirector']) do
+
+  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"
+          }]
+        }]
+      }
+  }
+
+  @routing_service_configuration = {
+    :StaticRoutingService => {
+      :IsEnabled => "true",
+      :StaticRoute => [
+        {
+          :Name => "Test static route #1",
+          :Network => "192.168.192.0/24",
+          :NextHopIp => "192.168.0.1",
+          :GatewayInterface => {}
+        }
+      ]
+    }
+  }
+
+  @new_edge_gateway_configuration = {
+    :FirewallService =>
+      {
+        :IsEnabled => "true",
+        :DefaultAction => "allow",
+        :LogDefaultAction => "false",
+        :FirewallRule => [
+          {
+            :IsEnabled => "false",
+            :MatchOnTranslate => "false",
+            :Id => FIREWALL_RULE_ID,
+            :Policy => "drop",
+            :Description => "generated from edge_gateway_tests",
+            :Protocols => {
+              :Tcp => "true"
+            },
+            :Port => "3412",
+            :DestinationPortRange => "3412",
+            :DestinationIp => "internal",
+            :SourcePort => "3412",
+            :SourceIp => "internal",
+            :SourcePortRange => "3412",
+            :EnableLogging => "false"
+          }
+        ]
+      }
+  }.merge!(@vpn_configuration).merge!(@dhcp_configuration)
+
+  @service = Fog::Compute::VcloudDirector.new
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+
+  tests('Get first vDC with an EdgeGatewayRecord') do
+    @org[:Link].each do |l|
+      if l[:type] == 'application/vnd.vmware.vcloud.vdc+xml'
+        id = l[:href].split('/').last
+        edge_gateways = @service.get_org_vdc_gateways(id).body
+        if edge_gateways && edge_gateways[:EdgeGatewayRecord].size >= 1
+          @vdc_id = id
+          break
+        end
+      end
+    end
+  end
+
+  tests('#get_org_vdc_gateways').data_matches_schema(VcloudDirector::Compute::Schema::QUERY_RESULT_RECORDS_TYPE) do
+    begin
+      @edge_gateways = @service.get_org_vdc_gateways(@vdc_id).body
+    rescue Fog::Compute::VcloudDirector::Unauthorized # bug, may be localised
+      retry
+    end
+    @edge_gateways
+  end
+
+  @edge_gateways[:EdgeGatewayRecord].each do |result|
+    tests("each EdgeGatewayRecord").
+      data_matches_schema(VcloudDirector::Compute::Schema::QUERY_RESULT_EDGE_GATEWAY_RECORD_TYPE) do
+        result
+      end
+  end
+
+  tests('#get_edge_gateway').data_matches_schema(VcloudDirector::Compute::Schema::GATEWAY_TYPE) do
+    @edge_gateway_id = @edge_gateways[:EdgeGatewayRecord].first[:href].split('/').last
+    @original_gateway_conf = @service.get_edge_gateway(@edge_gateway_id).body
+  end
+
+  tests('#configure_edge_gateway_services') do
+
+    rule = @original_gateway_conf[:Configuration][:EdgeGatewayServiceConfiguration][:FirewallService][:FirewallRule].find { |rule| rule[:Id] == FIREWALL_RULE_ID }
+    raise('fail fast if our test firewall rule already exists - its likely left over from a broken test run') if rule
+
+    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]
+    end
+
+    tests('#remove the firewall rule added by test').returns(nil) do
+      response = @service.post_configure_edge_gateway_services(@edge_gateway_id,
+                                                               @original_gateway_conf[:Configuration][:EdgeGatewayServiceConfiguration])
+      @service.process_task(response.body)
+      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 Static Routing service configuration').returns(true) do
+      edge_gateway = @service.get_edge_gateway(@edge_gateway_id).body
+      gateway_interface = edge_gateway[:Configuration][:GatewayInterfaces][:GatewayInterface].first
+      @routing_service_configuration[:StaticRoutingService][:StaticRoute].first[:GatewayInterface] = {
+        :type => gateway_interface[:type],
+        :name => gateway_interface[:name],
+        :href => gateway_interface[:href]
+      }
+
+      response = @service.post_configure_edge_gateway_services(@edge_gateway_id,
+                                                               @routing_service_configuration)
+      @service.process_task(response.body)
+      edge_gateway = @service.get_edge_gateway(@edge_gateway_id).body
+      edge_gateway[:Configuration][:EdgeGatewayServiceConfiguration][:StaticRoutingService][:IsEnabled] == "true"
+    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
+    begin
+      @service.get_edge_gateway('00000000-0000-0000-0000-000000000000')
+    rescue Fog::Compute::VcloudDirector::Unauthorized # bug, may be localised
+      retry
+    end
+  end
+
+  tests('Configure non-existent edge gateway').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    begin
+      @service.post_configure_edge_gateway_services('00000000-0000-0000-0000-000000000000', {})
+    rescue Fog::Compute::VcloudDirector::Unauthorized # bug, may be localised
+      retry
+    end
+  end
+
+end