fog 0.7.1 → 2.3.0

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

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

@@ -0,0 +1,18 @@
+Shindo.tests('Compute::VcloudDirector | groups requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#get_groups_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_groups_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'GroupReference' : 'GroupRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,32 @@
+class VcloudDirector
+  module Compute
+    module Helper
+      def self.test_name
+        @test_name ||= 'fog-test-%x' % Time.now.to_i
+      end
+
+      def self.fixture(filename)
+        File.join(File.expand_path('../../../fixtures', __FILE__), filename)
+      end
+
+      def self.current_org(service)
+        service.get_organization(current_org_id(service)).body
+      end
+
+      def self.current_org_id(service)
+        session = service.get_current_session.body
+        link = session[:Link].find do |l|
+          l[:type] == 'application/vnd.vmware.vcloud.org+xml'
+        end
+        link[:href].split('/').last
+      end
+
+      def self.first_vdc_id(org)
+        link = org[:Link].find do |l|
+          l[:type] == 'application/vnd.vmware.vcloud.vdc+xml'
+        end
+        link[:href].split('/').last
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+Shindo.tests('Compute::VcloudDirector | media requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('error conditions') do
+    tests('#post_upload_media') do
+      tests('Invalid image_type').raises(Fog::Compute::VcloudDirector::BadRequest) do
+        @service.post_upload_media('00000000-0000-0000-0000-000000000000', 'test.iso', 'isox', 0)
+      end
+      tests('Invalid size').raises(Fog::Compute::VcloudDirector::BadRequest) do
+        @service.post_upload_media('00000000-0000-0000-0000-000000000000', 'test.iso', 'iso', -1)
+      end
+    end
+    tests('Upload to non-existent vDC').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.post_upload_media('00000000-0000-0000-0000-000000000000', 'test.iso', 'iso', 0)
+    end
+    tests('Retrieve non-existent Media').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_media('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Retrieve owner of non-existent Media').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_media_owner('00000000-0000-0000-0000-000000000000')
+    end
+    tests('Delete non-existent Media').raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.delete_media('00000000-0000-0000-0000-000000000000')
+    end
+  end
+
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+  @media_name = VcloudDirector::Compute::Helper.test_name
+
+  tests('Upload and manipulate a media object') do
+    File.open(VcloudDirector::Compute::Helper.fixture('test.iso'), 'rb') do |iso|
+      tests('#post_upload_media').data_matches_schema(VcloudDirector::Compute::Schema::MEDIA_TYPE) do
+        @vdc_id = VcloudDirector::Compute::Helper.first_vdc_id(@org)
+        @size = File.size(iso.path)
+        @media = @service.post_upload_media(@vdc_id, @media_name, 'iso', @size).body
+      end
+
+      tests('media object has exactly one file').returns(true) do
+        @media[:Files][:File].size == 1
+      end
+
+      tests('media object file has an upload link').returns(true) do
+        @link = @media[:Files][:File].first[:Link]
+        @link[:rel] == 'upload:default'
+      end
+
+      unless Fog.mocking?
+        headers = {
+          'Content-Length' => @size,
+          'Content-Type' => 'application/octet-stream',
+          'x-vcloud-authorization' => @service.vcloud_token
+        }
+        Excon.put(
+          @link[:href], :body => iso.read, :expects => 200, :headers => headers
+        )
+      end
+
+      @service.process_task(@media[:Tasks][:Task])
+      @media_id = @media[:href].split('/').last
+
+      tests("#get_media(#{@media_id})").data_matches_schema(VcloudDirector::Compute::Schema::MEDIA_TYPE) do
+        @media = @service.get_media(@media_id).body
+      end
+      tests("media[:name]").returns(@media_name) { @media[:name] }
+      tests("media[:imageType]").returns('iso') { @media[:imageType] }
+      tests("media[:size]").returns(@size) { @media[:size].to_i }
+
+      tests("#get_media_owner(#{@media_id})").data_matches_schema(VcloudDirector::Compute::Schema::OWNER_TYPE) do
+        @owner = @service.get_media_owner(@media_id).body
+      end
+      tests("owner[:User][:name]").returns(@service.user_name) { @owner[:User][:name] }
+
+      tests('media metadata') do
+        pending if Fog.mocking?
+
+        tests("#put_media_metadata_item_metadata(#{@media_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+          @task = @service.put_media_metadata_item_metadata(@media_id, 'fog-test-key', 'fog-test-value').body
+        end
+        @service.process_task(@task)
+
+        tests("#put_media_metadata_item_metadata(#{@media_id})") do
+          tests("#put_media_metadata_item_metadata(Boolean)").returns(true) do
+            task = @service.put_media_metadata_item_metadata(@media_id, 'fog-test-boolean', true).body
+            @service.process_task(task)
+          end
+          tests("#put_media_metadata_item_metadata(DateTime)").returns(true) do
+            task = @service.put_media_metadata_item_metadata(@media_id, 'fog-test-datetime', DateTime.now).body
+            @service.process_task(task)
+          end
+          tests("#put_media_metadata_item_metadata(Number)").returns(true) do
+            task = @service.put_media_metadata_item_metadata(@media_id, 'fog-test-number', 111).body
+            @service.process_task(task)
+          end
+        end
+
+        tests("#post_update_media_metadata(#{@media_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_media_metadata(@media_id, metadata).body
+        end
+        @service.process_task(@task)
+
+        tests("#get_media_metadata(#{@media_id})") do
+          tests('response format').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
+            @metadata = @service.get_media_metadata(@media_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("#post_clone_media(#{@media_id})").data_matches_schema(VcloudDirector::Compute::Schema::MEDIA_TYPE) do
+        @media = @service.post_clone_media(@vdc_id, @media_id, :IsSourceDelete => true).body
+      end
+      @service.process_task(@media[:Tasks][:Task])
+      @media_id = @media[:href].split('/').last
+      tests("media[:name] starts '#{@media_name}-copy-'").returns(true) do
+        !!(@media[:name] =~ /^#{@media_name}-copy-/)
+      end
+
+      tests("#delete_media(#{@media_id})").data_matches_schema(VcloudDirector::Compute::Schema::TASK_TYPE) do
+        @task = @service.delete_media(@media_id).body
+      end
+      @service.process_task(@task)
+    end
+  end
+
+  tests('Media item no longer exists') do
+    tests("#get_media(#{@media_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_media(@media_id)
+    end
+    tests("#get_media_owner(#{@media_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.get_media_owner(@media_id)
+    end
+    tests("#get_media_metadata(#{@media_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      pending if Fog.mocking?
+      @service.get_media_metadata(@media_id)
+    end
+    tests("#delete_media(#{@media_id})").raises(Fog::Compute::VcloudDirector::Forbidden) do
+      @service.delete_media(@media_id)
+    end
+  end
+
+  tests('#get_medias_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_medias_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'MediaReference' : 'MediaRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,186 @@
+
+require 'pp'
+
+Shindo.tests('Compute::VcloudDirector | network requests', ['vclouddirector']) do
+
+  GET_NETWORK_FORMAT = {
+    :type => String,
+    :name => String,
+    :href => String,
+    :id => String,
+    :description => Fog::Nullable::String,
+    :is_inherited => Fog::Boolean,
+    :gateway => Fog::Nullable::String,
+    :netmask => String,
+    :dns1 => Fog::Nullable::String,
+    :dns2 => Fog::Nullable::String,
+    :dns_suffix => Fog::Nullable::String,
+    :ip_ranges => [{
+      :start_address => String,
+      :end_address => String
+    }]
+  }
+
+  @service = Fog::Compute::VcloudDirector.new
+  @org = VcloudDirector::Compute::Helper.current_org(@service)
+  @created_net_id = nil
+
+  tests('Create network in non-existent vDC').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.post_create_org_vdc_network('00000000-0000-0000-0000-000000000000', 'bob')
+  end
+
+  tests('Delete non-existent OrgNetwork').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.delete_network('00000000-0000-0000-0000-000000000000')
+  end
+
+  tests('Retrieve non-existent OrgNetwork (get_network)').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.get_network('00000000-0000-0000-0000-000000000000')
+  end
+
+  tests('Retrieve non-existent OrgNetwork (get_network_complete)').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.get_network_complete('00000000-0000-0000-0000-000000000000')
+  end
+
+  tests('#get_network').data_matches_schema(GET_NETWORK_FORMAT) 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(@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
+    @service.get_network_metadata(@network_id).body
+  end
+
+  tests('#post_create_org_vdc_network') do
+    #pending unless Fog.mocking?
+    link = @org[:Link].find do |l|
+      l[:rel] == 'down' && l[:type] == 'application/vnd.vmware.vcloud.vdc+xml'
+    end
+
+    vdc_id = link[:href].split('/').last
+    name = VcloudDirector::Compute::Helper.test_name
+
+    options = {
+      :Description => "Testing post_create_org_vdc_network #{name}",
+      :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',
+      }
+    }
+
+    body = @service.post_create_org_vdc_network(vdc_id, name, options).body
+    @created_net_id = body[:href].split('/').last if body[:href]
+    @service.process_task(body[:Tasks][:Task]) if body && body.key?(:Tasks)
+
+    tests('fetched name matches created name').returns(name) do
+      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
+    @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
+      @service.get_network(@created_net_id)
+    end
+  end
+
+end

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

@@ -0,0 +1,37 @@
+Shindo.tests('Compute::VcloudDirector | organization requests', ['vclouddirector']) do
+
+  @service = Fog::Compute::VcloudDirector.new
+
+  tests('#get_organizations').data_matches_schema(VcloudDirector::Compute::Schema::ORG_LIST_TYPE) do
+    @org_list = @service.get_organizations.body
+  end
+
+  tests('#get_organization').data_matches_schema(VcloudDirector::Compute::Schema::ORG_TYPE) do
+    org = @org_list[:Org].find {|o| o[:name] == @service.org_name}
+    @org_uuid = org[:href].split('/').last
+    @service.get_organization(@org_uuid).body
+  end
+
+  tests('#get_organization_metadata').data_matches_schema(VcloudDirector::Compute::Schema::METADATA_TYPE) do
+    pending if Fog.mocking?
+    @service.get_organization_metadata(@org_uuid).body
+  end
+
+  tests('#get_organizations_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_organizations_from_query(:format => format).body
+        end
+        key = (format == 'references') ? 'OrganizationReference' : 'OrganizationRecord'
+        tests("#body.key?(:#{key})").returns(true) { @body.key?(key.to_sym) }
+      end
+    end
+  end
+
+  tests('retrieve non-existent Org').raises(Fog::Compute::VcloudDirector::Forbidden) do
+    @service.get_organization('00000000-0000-0000-0000-000000000000')
+  end
+
+end