vcloud-walker 3.1.1

data/lib/vcloud/walker/resource/vm.rb

@@ -0,0 +1,85 @@
+module Vcloud
+  module Walker
+    module Resource
+      class Vms < Collection
+        def initialize fog_vms
+          fog_vms = [fog_vms] unless fog_vms.is_a? Array
+          fog_vms.each do |vm|
+            self << Resource::Vm.new(vm)
+          end
+        end
+      end
+
+
+      class Vm < Entity
+
+        attr_reader :id, :status, :cpu, :memory, :operating_system, :disks,
+                    :primary_network_connection_index, :vmware_tools,
+                    :virtual_system_type, :network_connections, :storage_profile,
+                    :network_cards, :metadata
+
+        HARDWARE_RESOURCE_TYPES = {
+            :cpu => '3',
+            :memory => '4',
+            :hard_disk => '17',
+            :network_adapter => '10'
+        }
+
+        def initialize fog_vm
+          @id = extract_id(fog_vm[:href])
+          @status = fog_vm[:status]
+          @operating_system = fog_vm[:'ovf:OperatingSystemSection'][:'ovf:Description']
+          @network_connections = fog_vm[:NetworkConnectionSection][:NetworkConnection] if fog_vm[:NetworkConnectionSection]
+          @primary_network_connection_index = fog_vm[:NetworkConnectionSection][:PrimaryNetworkConnectionIndex]
+          extract_compute_capacity fog_vm[:'ovf:VirtualHardwareSection'][:'ovf:Item']
+          @vmware_tools = fog_vm[:RuntimeInfoSection][:VMWareTools]
+          @virtual_system_type = extract_virtual_system_type(fog_vm[:'ovf:VirtualHardwareSection'])
+          @storage_profile = {
+            :id   => fog_vm[:StorageProfile][:href].split('/').last,
+            :name => fog_vm[:StorageProfile][:name],
+          }
+          @metadata = Vcloud::Core::Vm.get_metadata(id)
+        end
+
+
+        private
+        def extract_compute_capacity ovf_resources
+          %w(cpu memory disks network_cards).each { |resource| send("extract_#{resource}", ovf_resources) } unless ovf_resources.empty?
+        end
+
+        def extract_cpu(resources)
+          @cpu = resources.detect { |element| element[:'rasd:ResourceType']== HARDWARE_RESOURCE_TYPES[:cpu] }[:'rasd:ElementName']
+        end
+
+        def extract_memory(resources)
+          @memory = resources.detect { |element| element[:'rasd:ResourceType']== HARDWARE_RESOURCE_TYPES[:memory] }[:'rasd:ElementName']
+        end
+
+        def extract_disks(resources)
+          disk_resources = resources.select { |element| element[:'rasd:ResourceType']== HARDWARE_RESOURCE_TYPES[:hard_disk] }
+          @disks = disk_resources.collect do |d|
+            {:name => d[:'rasd:ElementName'], :size => d[:'rasd:HostResource'][:'ns12_capacity'].to_i}
+          end
+        end
+
+        def extract_network_cards(resources)
+          resources = resources.select {
+            |element| element[:'rasd:ResourceType'] == HARDWARE_RESOURCE_TYPES[:network_adapter]
+          }
+          @network_cards = resources.collect do |r|
+            {:name => r[:'rasd:ElementName'],
+             :type => r[:'rasd:ResourceSubType'],
+             :mac_address => r[:'rasd:Address'],
+            }
+          end
+        end
+
+        def extract_virtual_system_type virtual_hardware_section
+          virtual_system = virtual_hardware_section[:"ovf:System"]
+          virtual_system[:"vssd:VirtualSystemType"] if virtual_system
+        end
+
+      end
+    end
+  end
+end

data/lib/vcloud/walker/resource.rb

@@ -0,0 +1,11 @@
+require 'vcloud/walker/resource/entity'
+require 'vcloud/walker/resource/organization'
+require 'vcloud/walker/resource/collection'
+require 'vcloud/walker/resource/catalog_item'
+require 'vcloud/walker/resource/catalog'
+require 'vcloud/walker/resource/network'
+require 'vcloud/walker/resource/vapp'
+require 'vcloud/walker/resource/vdc'
+require 'vcloud/walker/resource/vm'
+require 'vcloud/walker/resource/gateway_ipsec_vpn_service'
+

data/lib/vcloud/walker/vcloud_session.rb

@@ -0,0 +1,13 @@
+module Vcloud
+  module Walker
+    class VcloudSession
+
+      def self.instance
+        ::Fog::Compute::VcloudDirector.new
+      end
+
+    end
+
+  end
+end
+

data/lib/vcloud/walker/version.rb

@@ -0,0 +1,5 @@
+module Vcloud
+  module Walker
+    VERSION = '3.1.1'
+  end
+end

data/lib/vcloud/walker.rb

@@ -0,0 +1,23 @@
+require 'fog'
+
+require 'vcloud/core'
+require 'vcloud/walker/vcloud_session'
+require 'vcloud/walker/fog_interface'
+require 'vcloud/walker/resource'
+require 'vcloud/walker/version'
+
+module Vcloud
+  module Walker
+
+    def self.walk(resource_to_walk)
+      valid_options = ['catalogs', 'vdcs', 'networks',
+                        'edgegateways', 'organization']
+      if valid_options.include? resource_to_walk
+        Vcloud::Walker::Resource::Organization.send(resource_to_walk)
+      else
+         puts "Possible options are '#{valid_options.join("','")}'."
+      end
+    end
+
+  end
+end

data/scripts/configure_walker_ci_vse.rb

@@ -0,0 +1,31 @@
+require 'fog'
+
+edge_gateway_id = ARGV[0]
+raise "please provide edgegateway id. usage: bx ruby ./configure_walker_ci_vse.rb <edgegateway-id>" unless edge_gateway_id
+
+lb_config = {
+    :IsEnabled => "true",
+    :Pool => [],
+    :VirtualServer => []
+}
+
+configuration = {
+    :FirewallService =>
+        {
+            :IsEnabled => true,
+            :DefaultAction => 'allow',
+            :LogDefaultAction => false,
+            :FirewallRule => []
+        },
+    :LoadBalancerService => lb_config,
+    :NatService => {
+        :IsEnabled => true,
+        :nat_type => 'portForwarding',
+        :Policy => 'allowTraffic',
+        :NatRule => []
+    }
+}
+
+vcloud = Fog::Compute::VcloudDirector.new
+task = vcloud.post_configure_edge_gateway_services edge_gateway_id, configuration
+vcloud.process_task(task.body)

data/scripts/data/walker_ci/carrenza.yaml

@@ -0,0 +1,17 @@
+---
+ vapps:
+ - name: vcloud-walker-contract-testing-vapp
+   vdc_name: 0e7t-vcloud_tools_ci-OVDC-001
+   catalog: walker-ci
+   catalog_item: walker-ci-template
+   vm:
+     hardware_config:
+       memory: '1024'
+       cpu: '1'
+     extra_disks:
+     - size: '8192'
+     network_connections:
+     - name: walker-ci-network
+       ip_address: 192.168.254.100
+     metadata:
+      is_webserver: true

data/scripts/data/walker_ci/skyscape.yaml

@@ -0,0 +1,17 @@
+---
+ vapps:
+ - name: vcloud-walker-contract-testing-vapp
+   vdc_name: 'vCloud CI (IL2-DEVTEST-BASIC)'
+   catalog: walker-ci
+   catalog_item: ubuntu-precise-201310041515
+   vm:
+     hardware_config:
+       memory: '1024'
+       cpu: '1'
+     extra_disks:
+     - size: '8192'
+     network_connections:
+     - name: Default
+       ip_address: 192.168.254.100
+     metadata:
+      is_webserver: true

data/scripts/generate_fog_conf_file.sh

@@ -0,0 +1,6 @@
+cat <<EOF >fog_integration_test.config
+default:
+    vcloud_director_username: '$API_USERNAME'
+    vcloud_director_password: '$API_PASSWORD'
+    vcloud_director_host: '$API_HOST'
+EOF

data/spec/fog_interface_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'rspec/mocks'
+
+describe Vcloud::Walker::FogInterface do
+  context "GET entities" do
+    let(:org) { double(:fog_org, :id => 'org-123') }
+    let(:organizations) { double(:orgs) }
+    let(:session) { double(:fog_session, :org_name => 'org-123', :organizations => organizations) }
+
+    before(:each) do
+      Vcloud::Walker::VcloudSession.should_receive(:instance).with(any_args()).at_least(:once).and_return(session)
+      organizations.should_receive(:get_by_name).and_return(org)
+    end
+
+    it "should get catalogs for given org id" do
+      mock_catalogs = [double(:catalog1), double(:catalog2)]
+      org.should_receive(:catalogs).and_return(double(:catalogs, :all => mock_catalogs))
+
+      catalogs = Vcloud::Walker::FogInterface.get_catalogs
+
+      catalogs.count.should == 2
+      catalogs.should == mock_catalogs
+
+    end
+
+    it "should get networks for given org id" do
+      mock_networks = [double(:network1), double(:network2)]
+      org.should_receive(:networks).and_return(double(:networks, :all => mock_networks))
+
+      networks = Vcloud::Walker::FogInterface.get_networks
+      networks.count.should == 2
+      networks.should == mock_networks
+    end
+
+    it "should get vdcs for given org id" do
+      mock_vdcs = [double(:vdc1), double(:vdc2), double(:vdc3)]
+      org.should_receive(:vdcs).and_return(double(:vdcs, :all => mock_vdcs))
+
+      vdcs = Vcloud::Walker::FogInterface.get_vdcs
+      vdcs.count.should == 3
+      vdcs.should == mock_vdcs
+    end
+
+    it "should get edge gateways for given org" do
+      mock_vdc1 = double(:vdc, :id => 1)
+      get_edge_gateway_result = double('Excon::Response', :body => {:EdgeGatewayRecord => {:href => '/sausage'}})
+
+      org.should_receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1 ]))
+      session.should_receive(:get_org_vdc_gateways).with(1).and_return(get_edge_gateway_result)
+      session.should_receive(:get_edge_gateway).with('sausage').and_return(double(:eg, :body => :eg1))
+
+      edge_gateways = Vcloud::Walker::FogInterface.get_edge_gateways
+
+      edge_gateways.count.should == 1
+      edge_gateways.should == [:eg1]
+    end
+
+    it "should get edge gateways for given org with complex set up of 2 vdcs and 3 edge gateways" do
+      mock_vdc1 = double(:vdc, :id => 1)
+      get_edge_gateway_vdc_1_result = double('Excon::Response', :body => {:EdgeGatewayRecord => {:href => '/sausage'}})
+      mock_vdc2 = double(:vdc, :id => 2)
+      get_edge_gateway_vdc_2_result = double('Excon::Response', :body => {:EdgeGatewayRecord => [{:href => '/beans'}, {:href => '/hashbrown'}]})
+
+      org.should_receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1, mock_vdc2 ]))
+
+      session.should_receive(:get_org_vdc_gateways).with(1).and_return(get_edge_gateway_vdc_1_result)
+      session.should_receive(:get_org_vdc_gateways).with(2).and_return(get_edge_gateway_vdc_2_result)
+      session.should_receive(:get_edge_gateway).with('sausage').and_return(double(:eg, :body => :eg1))
+      session.should_receive(:get_edge_gateway).with('beans').and_return(double(:eg, :body => :eg2))
+      session.should_receive(:get_edge_gateway).with('hashbrown').and_return(double(:eg, :body => :eg3))
+
+      edge_gateways = Vcloud::Walker::FogInterface.get_edge_gateways
+
+      edge_gateways.count.should == 3
+      edge_gateways.should == [:eg1, :eg2, :eg3]
+    end
+
+    it "get_edge_gateways should be happy if there are no edge gateways" do
+      mock_vdc1 = double(:vdc, :id => 1)
+
+      # no edge gateways means no entries to find in the results, just some other noise
+      vdc_1_search_result = double('Excon::Response', :body => {:Link => {:href => 's'}})
+
+      org.should_receive(:vdcs).and_return(double(:vdcs, :all => [ mock_vdc1 ]))
+      session.should_receive(:get_org_vdc_gateways).with(1).and_return(vdc_1_search_result)
+
+      edge_gateways = Vcloud::Walker::FogInterface.get_edge_gateways
+
+      edge_gateways.count.should == 0
+    end
+
+  end
+end

data/spec/integration/vcloud_walker_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'fog'
+require 'stringio'
+require 'vcloud/walker'
+
+#######################################################################################
+#  The intention of these tests are to ensure we have confdence that our tooling will
+#   function when used, and as integration tests to cover the areas that get mocked
+#   and so to uncover assumptions on how we use the fog libraries.
+#
+#  They are not there to test fog - that is the job of the fog tests, though
+#   this can be reconsidered if we get a of undetected bugs.
+#
+#  Most if not all edge cases should be caught by the unit tests or the Fog tests.
+#
+#  NB: These tests require that all EdgeGateways in the organization have the
+#  following services configured with at least one rule:
+#    NatService
+#    LoadBalancerService
+#
+#  NB: Integration test also requires that at least one vApp is configured in
+#  the organization, otherwise tests fail with insufficient coverage.
+#
+
+
+describe Vcloud::Walker do
+  context 'walk an organization' do
+
+    it 'should integrate with fog to get vdcs' do
+
+      vdc_summaries = Vcloud::Walker.walk('vdcs').to_json
+
+      # assert that there are atleast one item and that includes the essencial sections
+      vdc_summaries.should have_json_path('0/id')
+      vdc_summaries.should have_json_path('0/name')
+      vdc_summaries.should have_json_path('0/vapps')
+      vdc_summaries.should have_json_path('0/quotas')
+      vdc_summaries.should have_json_path('0/compute_capacity')
+    end
+
+    it "should integrate with fog to get networks" do
+
+      network_summary = Vcloud::Walker.walk('networks').to_json
+
+      # assert that there are atleast one item and that includes the essencial sections
+      network_summary.should have_json_path('0/id')
+      network_summary.should have_json_path('0/name')
+      network_summary.should have_json_path('0/ip_ranges')
+      network_summary.should have_json_path('0/gateway')
+    end
+
+    it "should integrate with fog to get catalogs" do
+
+      catalogs_summary = Vcloud::Walker.walk('catalogs')
+      catalog_summary = catalogs_summary.detect{|c| !c[:items].empty? }.to_json
+
+      # assert that there are atleast one item and that includes the essencial sections
+      catalog_summary.should have_json_path('id')
+      catalog_summary.should have_json_path('name')
+      catalog_summary.should have_json_path('items')
+      catalog_summary.should have_json_path('items/0/vapp_template_id')
+    end
+
+    it "should integrate with fog to get edge gateway data" do
+
+      result = Vcloud::Walker.walk('edgegateways').to_json
+      # assert that there are atleast one item and that includes the essencial sections
+      result.should have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/FirewallService')
+      result.should have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/NatService')
+      result.should have_json_path('0/Configuration/EdgeGatewayServiceConfiguration/LoadBalancerService')
+      result.should have_json_path('0/Configuration/GatewayInterfaces/GatewayInterface')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+
+  SimpleCov.profiles.define 'gem' do
+    add_filter '/spec/'
+    add_filter '/features/'
+    add_filter '/vendor/'
+
+    add_group 'Libraries', '/lib/'
+  end
+
+  SimpleCov.start 'gem'
+end
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'rspec'
+require 'rspec/mocks'
+require 'json_spec'
+require 'vcloud/walker'
+require_relative 'stubs/stubs'
+require_relative 'stubs/service_layer_stub'
+
+
+def set_login_credential username = 'some-username', password = 'some-password'
+  ENV['API_USERNAME'] = username
+  ENV['API_PASSWORD'] = password
+end
+
+RSpec.configure do |config|
+  config.include JsonSpec::Helpers
+end
+
+if ENV['COVERAGE']
+  ACCEPTED_COVERAGE = 97
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    # do not change the coverage percentage, instead add more unit tests to fix coverage failures.
+    if SimpleCov.result.covered_percent < ACCEPTED_COVERAGE
+      print "ERROR::BAD_CODE_COVERAGE\n"
+      print "Coverage is less than acceptable limit(#{ACCEPTED_COVERAGE}%). Please add more tests to improve the coverage"
+      exit(1)
+    end
+  end
+end

data/spec/stubs/service_layer_stub.rb

@@ -0,0 +1,109 @@
+module Fog
+  module ServiceLayerStub
+    def self.vapp_body
+      {:name => "vapp-atomic-centre",
+       :id => "urn:vcloud:vm:aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+       :href => 'https://myvdc.carrenza.net/api/vApp/vapp-aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
+       :status => "on",
+       :description => "hosts the atomic centre app",
+       :deployed => true,
+       :NetworkConfigSection => {:NetworkConfig => [{:networkName => "Default", :IsDeployed => true, :Description => "default network",
+                                                     :Configuration => {:IpScopes => 'abc'}, :ParentNetwork => nil}]},
+       :"ovf:NetworkSection" => {:'ovf:Network' => 'network'},
+       :Children =>
+           {
+               :Vm =>
+                   {
+                       :needsCustomization => "true",
+                       :deployed => "true",
+                       :status => "4", :name => "ubuntu-precise-201309091031",
+                       :id => "urn:vcloud:vm:d19d84a5-c950-4497-a638-23eccc4226a5",
+                       :type => "application/vnd.vmware.vcloud.vm+xml",
+                       :href => "https://api.vcd.portal.examplecloud.com/api/vApp/vm-d19d84a5-c950-4497-a638-23eccc4226a5",
+                       :Description => "ubuntu-precise | Version: 1.0 | Built using BoxGrinder",
+                       :"ovf:OperatingSystemSection" =>
+                           {
+                               :"ovf:Description" => "Ubuntu Linux (64-bit)"
+                           },
+                       :NetworkConnectionSection =>
+                           {
+                               :ovf_required => "false",
+                               :"ovf:Info" => "Specifies the available VM network connections",
+                               :PrimaryNetworkConnectionIndex => "0",
+                               :NetworkConnection =>
+                                   {
+                                       :network => "Default",
+                                       :needsCustomization => "true",
+                                       :NetworkConnectionIndex => "0",
+                                       :IpAddress => "192.168.2.2",
+                                       :IsConnected => "true",
+                                       :MACAddress => "00:50:56:01:0b:1a",
+                                       :IpAddressAllocationMode => "MANUAL"
+                                   },
+                           },
+                       :'ovf:VirtualHardwareSection' =>
+                           {
+                               :'ovf:Item' => [],
+                               :"ovf:System" =>
+                                   {:"vssd:ElementName" => "Virtual Hardware Family", :"vssd:VirtualSystemType" => "vmx-08"}
+                           },
+                       :RuntimeInfoSection =>
+                           {
+                               :VMWareTools => {:version => "2147483647"}
+                           },
+                       :StorageProfile =>
+                           {
+                               :type => "application/vnd.vmware.vcloud.vdcStorageProfile+xml",
+                               :name => "TEST-STORAGE-PROFILE",
+                               :href => "https://api.vcd.portal.examplecloud.com/api/vdcStorageProfile/00000000-aaaa-bbbb-aaaa-000000000000"
+                           }
+                   }
+           }
+      }
+    end
+
+    def self.mock_vapp
+      RSpec::Mocks::Mock.new(:fog_vapp, :body => vapp_body)
+    end
+
+    def self.hardware_resources
+      [
+          {
+              :'rasd:ResourceType' =>:: Vcloud::Walker::Resource::Vm::HARDWARE_RESOURCE_TYPES[:hard_disk],
+              :"rasd:AddressOnParent" => "0",
+              :"rasd:Description" => "Hard disk",
+              :"rasd:ElementName" => "Hard disk 1",
+              :"rasd:HostResource" => {:ns12_capacity => "11265", :ns12_busSubType => "lsilogic", :ns12_busType => "6"},
+          },
+
+          {
+              :'rasd:ResourceType' => ::Vcloud::Walker::Resource::Vm::HARDWARE_RESOURCE_TYPES[:hard_disk],
+              :"rasd:AddressOnParent" => "1",
+              :"rasd:Description" => "Hard disk",
+              :"rasd:ElementName" => "Hard disk 2",
+              :"rasd:HostResource" => {:ns12_capacity => "307200", :ns12_busSubType => "lsilogic", :ns12_busType => "6"}
+          },
+          {
+              :'rasd:ResourceType' => ::Vcloud::Walker::Resource::Vm::HARDWARE_RESOURCE_TYPES[:cpu],
+              :"rasd:Description" => "Number of Virtual CPUs",
+              :"rasd:ElementName" => "2 virtual CPU(s)"
+          },
+          {
+              :'rasd:ResourceType' => ::Vcloud::Walker::Resource::Vm::HARDWARE_RESOURCE_TYPES[:memory],
+              :"rasd:Description" => "Memory Size",
+              :"rasd:ElementName" => "4096 MB of memory"
+          },
+          {
+              :'rasd:ResourceType' => ::Vcloud::Walker::Resource::Vm::HARDWARE_RESOURCE_TYPES[:network_adapter],
+              :'rasd:Address'     => '00:50:56:00:00:01',
+              :'rasd:AddressOnParent' => '0',
+              :'rasd:AutomaticAllocation' => true,
+              :'rasd:Description' => 'E1000 ethernet adapter on "Default"',
+              :'rasd:ElementName' => 'Network adapter 0',
+              :'rasd:InstanceID'  => '0',
+              :'rasd:ResourceSubType' => 'E1000',
+          },
+      ]
+    end
+  end
+end

data/spec/stubs/stubs.rb

@@ -0,0 +1,46 @@
+class StubVdc
+  @edge_gateways
+
+  def initialize
+    @edge_gateways = []
+    @vapps = []
+    @description = 'vdc-1-description'
+  end
+
+  def edge_gateways(edge_gateways)
+    @edge_gateways = edge_gateways
+    self
+  end
+
+  def vapps(vapps)
+    @vapps = vapps
+    self
+  end
+
+  def desc(desc)
+    @description = desc
+    self
+  end
+
+  def build
+    vdc = RSpec::Mocks::Mock.new(:vdc,
+                                 :id => 'vdc-1',
+                                 :description => @description,
+                                 :name => 'atomic reactor data centre',
+                                 :network_quota => 20,
+                                 :nic_quota => 0,
+                                 :vm_quota => 150,
+                                 :compute_capacity => {:storage => '200'}
+    )
+    vdc.stub(:edgeGateways).and_return( @edge_gateways )
+    vdc.stub(:vapps).and_return( @vapps)
+    vdc
+  end
+end
+
+
+class StubCollectionBuilders
+  def self.vdcs(vdc)
+   [vdc]
+  end
+end

data/spec/vcloud/walker_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Vcloud
+  module Walker
+
+    describe "walk" do
+
+      context "pass correct resource calls" do
+
+        it "should correctly pass catalogs" do
+          test_array = [ "name" => "catalogs" ]
+          Vcloud::Walker::Resource::Organization.stub(:catalogs).and_return(test_array)
+          result_array = Vcloud::Walker.walk("catalogs")
+          result_array.should include("name" => "catalogs")
+        end
+
+        it "should correctly pass vdcs" do
+          test_array = [ "name" => "vdcs" ]
+          Vcloud::Walker::Resource::Organization.stub(:vdcs).and_return(test_array)
+          result_array = Vcloud::Walker.walk("vdcs")
+          result_array.should include("name" => "vdcs")
+        end
+
+        it "should correctly pass networks" do
+          test_array = [ "name" => "networks" ]
+          Vcloud::Walker::Resource::Organization.stub(:networks).and_return(test_array)
+          result_array = Vcloud::Walker.walk("networks")
+          result_array.should include("name" => "networks")
+        end
+
+        it "should correctly pass edgegateways" do
+          test_array = [ "name" => "edgegateways" ]
+          Vcloud::Walker::Resource::Organization.stub(:edgegateways).and_return(test_array)
+          result_array = Vcloud::Walker.walk("edgegateways")
+          result_array.should include("name" => "edgegateways")
+        end
+
+        it "should correctly pass organization" do
+          test_array = [ "name" => "organization" ]
+          Vcloud::Walker::Resource::Organization.stub(:organization).and_return(test_array)
+          result_array = Vcloud::Walker.walk("organization")
+          result_array.should include("name" => "organization")
+        end
+
+      end
+
+      context "invalid resources" do
+
+        it "should reject input that is not a valid resouce" do
+          result_array = Vcloud::Walker.walk("invalid")
+          result_array.should be_nil
+        end
+
+      end
+
+    end
+
+  end
+end