fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/lib/fog/vsphere/requests/compute/get_network.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_network(name, datacenter_name)
+          network = get_raw_network(name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless network
+          network_attributes(network, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_network(name, datacenter_name)
+          dc = find_raw_datacenter(datacenter_name)
+          dc.networkFolder.find(name)
+        end
+      end
+
+      class Mock
+        def get_network(id)
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/get_resource_pool.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_resource_pool(name, cluster_name, datacenter_name)
+          resource_pool = get_raw_resource_pool(name, cluster_name, datacenter_name)
+          raise(Fog::Compute::Vsphere::NotFound) unless resource_pool
+          resource_pool_attributes(resource_pool, cluster_name, datacenter_name)
+        end
+
+        protected
+
+        def get_raw_resource_pool(name, cluster_name, datacenter_name)
+          dc      = get_raw_datacenter(datacenter_name)
+          cluster = dc.find_compute_resource(cluster_name)
+          cluster.resourcePool.find name
+        end
+      end
+
+      class Mock
+        def get_resource_pool(name, cluster_name, datacenter_name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/get_virtual_machine.rb

@@ -0,0 +1,62 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def get_virtual_machine(id, datacenter_name = nil)
+          convert_vm_mob_ref_to_attr_hash(get_vm_ref(id, datacenter_name))
+        end
+
+        protected
+
+        def get_vm_ref(id, dc = nil)
+          vm = case id
+                 # UUID based
+                 when /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+                   @service.searchIndex.FindByUuid :uuid => id, :vmSearch => true, :instanceUuid => true, :datacenter => dc
+                 else
+                   # try to find based on VM name
+                   if dc
+                     get_raw_datacenter(dc).find_vm(id)
+                   else
+                     raw_datacenters.map { |d| d.find_vm(id) }.compact.first
+                   end
+               end
+          vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
+        end
+      end
+
+      class Mock
+        def get_virtual_machine(id, datacenter_name = nil)
+          case id
+          when "5032c8a5-9c5e-ba7a-3804-832a03e16381", 'vm-715'
+            { :resource_pool    => "Resources",
+              :memory_mb        => 2196,
+              :power_state      => "poweredOn",
+              :mac_addresses    => { "Network adapter 1" => "00:50:56:b2:00:af" },
+              :hostname         => "centos56gm.localdomain",
+              :cpus             => 1,
+              :connection_state => "connected",
+              :mo_ref           => "vm-715",
+              :overall_status   => "green",
+              :datacenter       => "Solutions",
+              :instance_uuid    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
+              :hypervisor       => "gunab.puppetlabs.lan",
+              :guest_id         => "rhel6_64Guest",
+              :cluster          => "virtlabcluster",
+              :tools_state      => "toolsOk",
+              :name             => "jefftest",
+              :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
+              :path             => "/",
+              :tools_version    => "guestToolsUnmanaged",
+              :ipaddress        => "192.168.100.187",
+              :id               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
+              :uuid             => "42329da7-e8ab-29ec-1892-d6a4a964912a"
+            }
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_clusters.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_clusters(filters = { })
+          datacenter_name = filters[:datacenter]
+
+          raw_clusters(datacenter_name).map do |cluster|
+            cluster_attributes(cluster, datacenter_name)
+          end
+        end
+
+        def raw_clusters(datacenter)
+          find_raw_datacenter(datacenter).hostFolder.childEntity.grep(RbVmomi::VIM::ClusterComputeResource)
+        end
+
+        protected
+
+        def cluster_attributes cluster, datacenter_name
+          {
+            :id             => managed_obj_id(cluster),
+            :name           => cluster.name,
+            :num_host       => cluster.summary.numHosts,
+            :num_cpu_cores  => cluster.summary.numCpuCores,
+            :overall_status => cluster.summary.overallStatus,
+            :datacenter     => datacenter_name || parent_attribute(cluster.path, :datacenter)[1],
+          }
+        end
+
+      end
+      class Mock
+        def list_clusters(filters = { })
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_datacenters.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+
+        def list_datacenters filters = {}
+          raw_datacenters.map do |dc|
+            {
+              :id => managed_obj_id(dc),
+              :name => dc.name,
+              :status => dc.overallStatus
+            }
+          end
+        end
+
+        protected
+
+        def raw_datacenters
+          @raw_datacenters ||= @connection.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter)
+        end
+
+        def find_datacenters name=nil
+          name ? [get_raw_datacenter(name)] : raw_datacenters
+        end
+      end
+
+      class Mock
+        def list_datacenters filters = {}
+          [ {:name => "Solutions", :status => "grey"}, {:name => "Solutions2", :status => "green" }]
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_datastores.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_datastores(filters = { })
+          datacenter_name = filters[:datacenter]
+          # default to show all datastores
+          only_active = filters[:accessible] || false
+          raw_datastores(datacenter_name).map do |datastore|
+            next if only_active and !datastore.summary.accessible
+            datastore_attributes(datastore, datacenter_name)
+          end.compact
+        end
+
+        def raw_datastores(datacenter_name)
+          find_raw_datacenter(datacenter_name).datastore
+        end
+        protected
+
+        def datastore_attributes datastore, datacenter
+          {
+            :id         => managed_obj_id(datastore),
+            :name       => datastore.name,
+            :accessible => datastore.summary.accessible,
+            :type       => datastore.summary.type,
+            :freespace  => datastore.summary.freeSpace,
+            :capacity   => datastore.summary.capacity,
+            :datacenter => datacenter,
+          }
+        end
+
+      end
+      class Mock
+        def list_datastores(datacenter_name)
+          []
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_folders.rb

@@ -0,0 +1,45 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        # Grabs all sub folders within a given path folder.
+        #
+        # ==== Parameters
+        # * filters<~Hash>:
+        #   * :datacenter<~String> - *REQUIRED* Your datacenter where you're
+        #     looking for folders. Example: 'my-datacenter-name' (passed if you
+        #     are using the models/collections)
+        #       eg: vspconn.datacenters.first.vm_folders('mypath')
+        #   * :path<~String> - Your path where you're looking for
+        #     more folders, if return = none you will get an error. If you don't
+        #     define it will look in the main datacenter folder for any folders
+        #     in that datacenter.
+        #
+        # Example Usage Testing Only:
+        #  vspconn = Fog::Compute[:vsphere]
+        #  mydc = vspconn.datacenters.first
+        #  folders = mydc.vm_folders
+        #
+        def list_folders(filters = { })
+          path            = filters[:path] || filters['path'] || ''
+          datacenter_name = filters[:datacenter]
+          get_raw_vmfolders(path, datacenter_name).map do |folder|
+            folder_attributes(folder, datacenter_name)
+          end
+        end
+
+        protected
+
+        def get_raw_vmfolders(path, datacenter_name)
+          folder = get_raw_vmfolder(path, datacenter_name)
+          child_folders(folder).flatten.compact
+        end
+
+        def child_folders folder
+          [folder, folder.childEntity.grep(RbVmomi::VIM::Folder).map(&method(:child_folders)).flatten]
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_networks.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_networks(filters = { })
+          datacenter_name = filters[:datacenter]
+          # default to show all networks
+          only_active = filters[:accessible] || false
+          raw_networks(datacenter_name).map do |network|
+            next if only_active and !network.summary.accessible
+            network_attributes(network, datacenter_name)
+          end.compact
+        end
+
+        def raw_networks(datacenter_name)
+          find_raw_datacenter(datacenter_name).network
+        end
+
+        protected
+
+        def network_attributes network, datacenter
+          {
+            :id         => managed_obj_id(network),
+            :name       => network.name,
+            :accessible => network.summary.accessible,
+            :datacenter => datacenter,
+          }
+        end
+
+      end
+      class Mock
+        def list_networks(datacenter_name)
+          []
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_resource_pools.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def list_resource_pools(filters = { })
+          datacenter_name = filters[:datacenter]
+          cluster_name    = filters[:cluster]
+          cluster         = get_raw_cluster(cluster_name, datacenter_name)
+          list_raw_resource_pools(cluster).map do |resource_pool|
+            resource_pool_attributes(resource_pool, cluster_name, datacenter_name)
+          end
+        end
+
+        protected
+
+        # root ResourcePool + Children if they exists
+        def list_raw_resource_pools(cluster)
+          [cluster.resourcePool, cluster.resourcePool.resourcePool].flatten
+        end
+
+        def resource_pool_attributes resource_pool, cluster, datacenter
+          {
+            :id                   => managed_obj_id(resource_pool),
+            :name                 => resource_pool.name,
+            :configured_memory_mb => resource_pool.summary.configuredMemoryMB,
+            :overall_status       => resource_pool.overallStatus,
+            :cluster              => cluster,
+            :datacenter           => datacenter
+          }
+        end
+
+      end
+      class Mock
+        def list_resource_pools(filters = { })
+        end
+      end
+    end
+  end
+end

data/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -2,97 +2,43 @@ module Fog
   module Compute
     class Vsphere
       class Real
-        def list_virtual_machines(options = {})
+        def list_virtual_machines(options = { })
           # Listing all VM's can be quite slow and expensive.  Try and optimize
           # based on the available options we have.  These conditions are in
-          # ascending order of  time to complete for large deployments.
+          # ascending order of time to complete for large deployments.
+
+          options[:folder] ||= options['folder']
           if options['instance_uuid'] then
-            list_all_virtual_machines_by_instance_uuid(options)
-          elsif options['folder'] then
-            list_all_virtual_machines_in_folder(options)
+            [service.get_virtual_machine(options['instance_uuid'])]
+          elsif options[:folder] && options[:datacenter] then
+            list_all_virtual_machines_in_folder(options[:folder], options[:datacenter])
           else
-            list_all_virtual_machines
+            list_all_virtual_machines(options)
           end
         end
 
         private
 
-        def list_all_virtual_machines_in_folder(options = {})
-          # Tap gets rid of the leading empty string and "Datacenters" element
-          # and returns the array.
-          path_elements = options['folder'].split('/').tap { |ary| ary.shift 2 }
-          # The DC name itself.
-          dc_name = path_elements.shift
-          # If the first path element contains "vm" this denotes the vmFolder
-          # and needs to be shifted out since each DC contains only one
-          # vmFolder
-          path_elements.shift if path_elements[0] == 'vm'
-          # Make sure @datacenters is populated (the keys are DataCenter instances)
-          self.datacenters.include? dc_name or raise ArgumentError, "Could not find a Datacenter named #{dc_name}"
-          # Get the datacenter managed object
-          dc = @datacenters[dc_name]
-
-          # Get the VM Folder (Group) efficiently
-          vm_folder = dc.vmFolder
+        def list_all_virtual_machines_in_folder(path, datacenter_name)
+          folder = get_raw_vmfolder(path, datacenter_name)
 
-          # Walk the tree resetting the folder pointer as we go
-          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
-            # JJM VIM::Folder#find appears to be quite efficient as it uses the
-            # searchIndex It certainly appears to be faster than
-            # VIM::Folder#inventory since that returns _all_ managed objects of
-            # a certain type _and_ their properties.
-            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
-            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
-            sub_folder
-          end
-
-          # This should be efficient since we're not obtaining properties
-          virtual_machines = folder.children.inject([]) do |ary, child|
-            if child.is_a? RbVmomi::VIM::VirtualMachine then
-              ary << convert_vm_mob_ref_to_attr_hash(child)
-            end
-            ary
-          end
-
-          # Return the managed objects themselves as an array.  These may be converted
-          # to an attribute has using convert_vm_mob_ref_to_attr_hash
-          { 'virtual_machines' => virtual_machines }
+          folder.children.grep(RbVmomi::VIM::VirtualMachine).map(&method(:convert_vm_mob_ref_to_attr_hash))
         end
 
-        def list_all_virtual_machines_by_instance_uuid(options = {})
-          uuid = options['instance_uuid']
-          search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
-          vm_mob_ref = @connection.searchIndex.FindAllByUuid(search_filter).first
-          if vm_attribute_hash = convert_vm_mob_ref_to_attr_hash(vm_mob_ref) then
-            virtual_machines = [ vm_attribute_hash ]
-          else
-            virtual_machines = [ ]
-          end
-          { 'virtual_machines' => virtual_machines }
-        end
+        def list_all_virtual_machines(options = { })
+          datacenters = find_datacenters(options[:datacenter])
+          # TODO: go though nested folders
+          vms         = datacenters.map { |dc| dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine) }.flatten
+          # remove all template based virtual machines
+          vms.delete_if { |v| v.config.template }
 
-        def list_all_virtual_machines
-          virtual_machines = list_all_virtual_machine_mobs.collect do |vm_mob|
+          vms.map do |vm_mob|
             convert_vm_mob_ref_to_attr_hash(vm_mob)
           end
-          { 'virtual_machines' => virtual_machines }
-        end
-
-
-        # NOTE: This is a private instance method required by the vm_clone
-        # request.  It's very hard to get the Managed Object Reference
-        # of a Template because we can't search for it by instance_uuid
-        # As a result, we need a list of all virtual machines, and we
-        # need them in "native" format, not filter attribute format.
-        def list_all_virtual_machine_mobs
-          # Find each datacenter
-          datacenters = @connection.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter)
-          # Next, search the "vmFolder" inventory of each data center:
-          datacenters.map {|dc| dc.vmFolder.childEntity.grep(RbVmomi::VIM::VirtualMachine) }.flatten
         end
 
         def get_folder_path(folder, root = nil)
-          if ( not folder.methods.include?('parent') ) or ( folder == root )
+          if (not folder.methods.include?('parent')) or (folder == root)
             return
           end
           "#{get_folder_path(folder.parent)}/#{folder.name}"
@@ -105,100 +51,120 @@ module Fog
           nil
         end
 
-        def list_virtual_machines(options = {})
+        def list_virtual_machines(options = { })
           case options['instance_uuid']
-          when nil
-            rval = YAML.load <<-'ENDvmLISTING'
----
-virtual_machines:
-- name: centos56gm
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress:
-  mo_ref: vm-698
-  power_state: poweredOff
-  uuid: 42322347-d791-cd34-80b9-e25fe28ad37c
-  is_a_template: true
-  id: 50323f93-6835-1178-8b8f-9e2109890e1a
-  tools_state: toolsNotRunning
-  connection_state: connected
-  instance_uuid: 50323f93-6835-1178-8b8f-9e2109890e1a
-  hostname:
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:a1
-  operatingsystem:
-- name: centos56gm2
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress:
-  mo_ref: vm-640
-  power_state: poweredOff
-  uuid: 564ddcbe-853a-d29a-b329-a0a3693a004d
-  is_a_template: true
-  id: 5257dee8-050c-cbcd-ae25-db0e582ab530
-  tools_state: toolsNotRunning
-  connection_state: connected
-  instance_uuid: 5257dee8-050c-cbcd-ae25-db0e582ab530
-  hostname:
-  mac_addresses:
-    Network adapter 1: 00:0c:29:3a:00:4d
-  operatingsystem:
-- name: dashboard_gm
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress: 192.168.100.184
-  mo_ref: vm-669
-  power_state: poweredOn
-  uuid: 564d3f91-3452-a509-a678-1246f7897979
-  is_a_template: false
-  id: 5032739c-c871-c0d2-034f-9700a0b5383e
-  tools_state: toolsOk
-  connection_state: connected
-  instance_uuid: 5032739c-c871-c0d2-034f-9700a0b5383e
-  hostname: compliance.puppetlabs.vm
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:96
-  operatingsystem: Red Hat Enterprise Linux 6 (64-bit)
-- name: jefftest
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress: 192.168.100.187
-  mo_ref: vm-715
-  power_state: poweredOn
-  uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
-  is_a_template: false
-  id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  tools_state: toolsOk
-  connection_state: connected
-  instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  hostname: centos56gm.localdomain
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:af
-  operatingsystem: CentOS 4/5 (32-bit)
-ENDvmLISTING
-          when '5032c8a5-9c5e-ba7a-3804-832a03e16381'
-            YAML.load <<-'5032c8a5-9c5e-ba7a-3804-832a03e16381'
----
-virtual_machines:
-- name: jefftest
-  hypervisor: gunab.puppetlabs.lan
-  tools_version: guestToolsCurrent
-  ipaddress: 192.168.100.187
-  mo_ref: vm-715
-  power_state: poweredOn
-  uuid: 42329da7-e8ab-29ec-1892-d6a4a964912a
-  is_a_template: false
-  id: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  tools_state: toolsOk
-  connection_state: connected
-  instance_uuid: 5032c8a5-9c5e-ba7a-3804-832a03e16381
-  hostname: centos56gm.localdomain
-  mac_addresses:
-    Network adapter 1: 00:50:56:b2:00:af
-  operatingsystem: CentOS 4/5 (32-bit)
-            5032c8a5-9c5e-ba7a-3804-832a03e16381
-          when 'does-not-exist-and-is-not-a-uuid', '50323f93-6835-1178-8b8f-9e2109890e1a'
-            { 'virtual_machines' => [] }
+            when nil
+
+              [
+                { :resource_pool    => "Resources",
+                  :memory_mb        => 2196,
+                  :mac_addresses    => { "Network adapter 1" => "00:50:56:a9:00:28" },
+                  :power_state      => "poweredOn",
+                  :cpus             => 1,
+                  :hostname         => "dhcp75-197.virt.bos.redhat.com",
+                  :mo_ref           => "vm-562",
+                  :connection_state => "connected",
+                  :overall_status   => "green",
+                  :datacenter       => "Solutions",
+                  :volumes          =>
+                    [{
+                       :id        => "6000C29c-a47d-4cd9-5249-c371de775f06",
+                       :datastore => "Storage1",
+                       :mode      => "persistent",
+                       :size      => 8388608,
+                       :thin      => true,
+                       :name      => "Hard disk 1",
+                       :filename  => "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
+                       :size_gb   => 8
+                     }],
+                  :interfaces       =>
+                    [{ :mac     => "00:50:56:a9:00:28",
+                       :network => "VM Network",
+                       :name    => "Network adapter 1",
+                       :status  => "ok",
+                       :summary => "VM Network",
+                     }],
+                  :hypervisor       => "gunab.puppetlabs.lan",
+                  :guest_id         => "rhel6_64Guest",
+                  :tools_state      => "toolsOk",
+                  :cluster          => "Solutionscluster",
+                  :name             => "rhel64",
+                  :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
+                  :uuid             => "4229f0e9-bfdc-d9a7-7bac-12070772e6dc",
+                  :path             => "/Datacenters/Solutions/vm",
+                  :id               => "5029c440-85ee-c2a1-e9dd-b63e39364603",
+                  :tools_version    => "guestToolsUnmanaged",
+                  :ipaddress        => "192.168.100.184",
+                },
+                { :resource_pool    => "Resources",
+                  :memory_mb        => 512,
+                  :power_state      => "poweredOn",
+                  :mac_addresses    => { "Network adapter 1" => "00:50:56:a9:00:00" },
+                  :hostname         => nil,
+                  :cpus             => 1,
+                  :connection_state => "connected",
+                  :mo_ref           => "vm-621",
+                  :overall_status   => "green",
+                  :datacenter       => "Solutions",
+                  :volumes          =>
+                    [{ :thin      => false,
+                       :size_gb   => 10,
+                       :datastore => "datastore1",
+                       :filename  => "[datastore1] i-1342439683/i-1342439683.vmdk",
+                       :size      => 10485762,
+                       :name      => "Hard disk 1",
+                       :mode      => "persistent",
+                       :id        => "6000C29b-f364-d073-8316-8e98ac0a0eae" }],
+                  :interfaces       =>
+                    [{  :summary => "VM Network",
+                       :mac     => "00:50:56:a9:00:00",
+                       :status  => "ok",
+                       :network => "VM Network",
+                       :name    => "Network adapter 1" }],
+                  :instance_uuid    => "502916a3-b42e-17c7-43ce-b3206e9524dc",
+                  :hypervisor       => "gunab.puppetlabs.lan",
+                  :guest_id         => nil,
+                  :cluster          => "Solutionscluster",
+                  :tools_state      => "toolsNotInstalled",
+                  :uuid             => "4229e0de-30cb-ceb2-21f9-4d8d8beabb52",
+                  :name             => "i-1342439683",
+                  :operatingsystem  => nil,
+                  :path             => "/",
+                  :tools_version    => "guestToolsNotInstalled",
+                  :id               => "502916a3-b42e-17c7-43ce-b3206e9524dc",
+                  :ipaddress        => nil }
+
+
+              ]
+            when '5032c8a5-9c5e-ba7a-3804-832a03e16381'
+              [{ :resource_pool    => "Resources",
+                 :memory_mb        => 2196,
+                 :power_state      => "poweredOn",
+                 :mac_addresses    => { "Network adapter 1" => "00:50:56:b2:00:af" },
+                 :hostname         => "centos56gm.localdomain",
+                 :cpus             => 1,
+                 :connection_state => "connected",
+                 :mo_ref           => "vm-715",
+                 :overall_status   => "green",
+                 :datacenter       => "Solutions",
+                 :instance_uuid    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
+                 :hypervisor       => "gunab.puppetlabs.lan",
+                 :guest_id         => "rhel6_64Guest",
+                 :cluster          => "Solutionscluster",
+                 :tools_state      => "toolsOk",
+                 :name             => "jefftest",
+                 :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
+                 :path             => "/",
+                 :tools_version    => "guestToolsUnmanaged",
+                 :ipaddress        => "192.168.100.187",
+                 :id               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
+                 :uuid             => "42329da7-e8ab-29ec-1892-d6a4a964912a"
+
+               }
+
+              ]
+            when 'does-not-exist-and-is-not-a-uuid', '50323f93-6835-1178-8b8f-9e2109890e1a'
+              []
           end
         end
       end