fog 0.7.1 → 2.3.0

data/spec/ecloud/requests/get_nodes_spec.rb

@@ -1,58 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_nodes) }
-
-    describe "#get_nodes" do
-      context "with a valid nodes_uri" do
-        before { @nodes = @vcloud.get_nodes(@mock_node_collection.href) }
-        subject { @nodes }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.tmrk.ecloud.nodeService+xml") }
-
-        describe "#body" do
-          subject { @nodes.body }
-
-          it { should have(3).items }
-
-          describe "[:NodeService]" do
-            subject { @nodes.body[:NodeService] }
-
-            it { should have(@mock_node_collection.items.length).nodes }
-
-            [0,1].each do |idx|
-
-              context "[#{idx}]" do
-                subject { @nodes.body[:NodeService][idx] }
-                let(:mock_node) { @mock_node_collection.items[idx] }
-                let(:keys) { subject.keys.sort_by(&:to_s) }
-                specify { keys.should == [:Description, :Enabled, :Href, :Id, :IpAddress, :Name, :Port] }
-                its(:Href) { should == mock_node.href }
-                its(:Id) { should == mock_node.object_id.to_s }
-                its(:Name) { should == mock_node.name }
-                its(:Enabled) { should == mock_node.enabled.to_s }
-                its(:Port) { should == mock_node.port.to_s }
-                its(:IpAddress) { should == mock_node.ip_address }
-                its(:Description) { should == mock_node.description }
-              end
-
-            end
-
-          end
-
-        end
-      end
-
-      context "with a public_ips_uri that doesn't exist" do
-        subject { lambda { @vcloud.get_nodes(URI.parse('https://www.fakey.c/piv8vc99')) } }
-
-        it_should_behave_like "a request for a resource that doesn't exist"
-      end
-    end
-  end
-else
-end

data/spec/ecloud/requests/get_organization_spec.rb

@@ -1,52 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_organization) }
-
-    describe "#get_organization" do
-      context "with a valid organization uri" do
-        before { @organization = @vcloud.get_organization(@vcloud.default_organization_uri) }
-        subject { @organization }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.org+xml") }
-
-        describe "#body" do
-          subject { @organization.body }
-
-
-          let(:links) { subject[:Link] }
-
-          it { should have(6).keys }
-
-          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-          it { should have_key_with_value(:href, @mock_organization.href)}
-          it { should have_key_with_value(:name, @mock_organization.name) }
-          it { should have_key_with_array(:Link, @mock_organization.vdcs.map { |vdc|
-                                                 [{ :type => "application/vnd.vmware.vcloud.vdc+xml",
-                                                    :href => vdc.href,
-                                                    :name => vdc.name,
-                                                    :rel => "down" },
-                                                  { :type => "application/vnd.vmware.vcloud.catalog+xml",
-                                                    :href => vdc.catalog.href,
-                                                    :name => vdc.catalog.name,
-                                                    :rel => "down" },
-                                                  { :type => "application/vnd.vmware.vcloud.tasksList+xml",
-                                                    :href => vdc.task_list.href,
-                                                    :name => vdc.task_list.name,
-                                                    :rel => "down" }]
-                                                  }.flatten) }
-
-        end
-      end
-      context "with an organization uri that doesn't exist" do
-        subject { lambda { @vcloud.get_organization(URI.parse('https://www.fakey.com/api/v0.8/org/999')) } }
-        it_should_behave_like("a request for a resource that doesn't exist")
-      end
-    end
-  end
-end
-

data/spec/ecloud/requests/get_public_ip_spec.rb

@@ -1,38 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_public_ip) }
-
-    describe "#get_public_ip" do
-      context "with a valid public_ip_uri" do
-        before do
-          @public_ip = @vcloud.get_public_ip(@mock_public_ip.href)
-        end
-
-        subject { @public_ip }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.tmrk.ecloud.publicIp+xml") }
-
-        describe "#body" do
-          subject { @public_ip.body }
-
-          its(:Name) { should == @mock_public_ip.name }
-          its(:Href) { should == @mock_public_ip.href }
-          its(:Id)   { should == @mock_public_ip.object_id.to_s }
-
-        end
-      end
-
-      context "with a public_ips_uri that doesn't exist" do
-        subject { lambda { @vcloud.get_public_ip(URI.parse('https://www.fakey.c/piv89')) } }
-
-        it_should_behave_like "a request for a resource that doesn't exist"
-      end
-    end
-  end
-else
-end

data/spec/ecloud/requests/get_public_ips_spec.rb

@@ -1,52 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_public_ips) }
-
-    describe "#get_public_ips" do
-      context "with a valid public_ips_uri" do
-        before { @public_ips = @vcloud.get_public_ips(@mock_public_ip_collection.href) }
-        subject { @public_ips }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.tmrk.ecloud.publicIpsList+xml") }
-
-        describe "#body" do
-          subject { @public_ips.body }
-
-          it { should have(1).item }
-
-          describe "[:PublicIPAddress]" do
-            subject { @public_ips.body[:PublicIPAddress] }
-
-            it { should have(@mock_public_ip_collection.items.length).addresses }
-
-            [0,1,2].each do |idx|
-
-              context "[#{idx}]" do
-                subject { @public_ips.body[:PublicIPAddress][idx] }
-                let(:public_ip) { @mock_public_ip_collection.items[idx] }
-                its(:Href) { should == public_ip.href }
-                its(:Id) { should == public_ip.object_id.to_s }
-                its(:Name) { should == public_ip.name }
-              end
-
-            end
-
-          end
-
-        end
-      end
-
-      context "with a public_ips_uri that doesn't exist" do
-        subject { lambda { @vcloud.get_public_ips(URI.parse('https://www.fakey.c/piv8vc99')) } }
-
-        it_should_behave_like "a request for a resource that doesn't exist"
-      end
-    end
-  end
-else
-end

data/spec/ecloud/requests/get_vapp_spec.rb

@@ -1,125 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_vapp) }
-
-    describe "#get_vapp" do
-      context "with a valid vapp_uri" do
-        before { @vapp = @vcloud.get_vapp(@mock_vm.href) }
-        subject { @vapp }
-        let(:vapp_id) { @vapp.body[:href].split("/").last }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.vApp+xml") }
-
-        describe "#body" do
-          subject { @vapp.body }
-
-          specify { subject.keys.sort_by(&:to_s).should == [:Link,                         :NetworkConnectionSection,
-                                                            :OperatingSystemSection,       :VirtualHardwareSection,
-                                                            :href,                         :name,
-                                                            :size,                         :status,
-                                                            :type,                         :xmlns,
-                                                            :xmlns_xsd,                    :xmlns_xsi] }
-
-          it_should_behave_like("it has the standard vcloud v0.8 xmlns attributes")   # 3 keys
-
-          its(:href)   { should == @mock_vm.href }
-          its(:name)   { should == @mock_vm.name }
-          its(:status) { should == @mock_vm.status.to_s }
-          its(:size)   { should == (@mock_vm.disks.inject(0) {|s, d| s += d[:size].to_i } * 1024).to_s }
-
-          describe "Link" do
-            subject { @vapp.body[:Link] }
-
-            its(:rel)  { should == "up" }
-            its(:type) { should == "application/vnd.vmware.vcloud.vdc+xml" }
-            its(:href) { should == @mock_vdc.href }
-          end
-
-          describe "NetworkConnectionSection" do
-            subject { @vapp.body[:NetworkConnectionSection] }
-
-            it { should include(:NetworkConnection) }
-
-            describe "NetworkConnection" do
-              subject { @vapp.body[:NetworkConnectionSection][:NetworkConnection] }
-
-              its(:IpAddress) { should == @mock_vm.ip }
-            end
-          end
-
-          describe "OperatingSystemSection" do
-            subject { @vapp.body[:OperatingSystemSection] }
-
-            its(:Info) { should == "The kind of installed guest operating system" }
-            its(:Description) { should == "Red Hat Enterprise Linux 5 (64-bit)" }
-          end
-
-          describe "VirtualHardwareSection" do
-            subject { @vapp.body[:VirtualHardwareSection] }
-
-            specify { subject.keys.sort_by(&:to_s).should == [:Info, :Item, :System, :xmlns] }
-
-            describe "Item" do
-              subject { @vapp.body[:VirtualHardwareSection][:Item] }
-
-              it { should have(5).items }
-
-              specify { subject.map {|i| i[:ResourceType] }.uniq.sort.should == %w(3 4 6 17).sort }
-
-              describe "CPU" do
-                subject { @vapp.body[:VirtualHardwareSection][:Item].detect {|i| i[:ResourceType] == "3" } }
-
-                its(:VirtualQuantity) { should == @mock_vm.cpus.to_s }
-              end
-
-              describe "memory" do
-                subject { @vapp.body[:VirtualHardwareSection][:Item].detect {|i| i[:ResourceType] == "4" } }
-
-                its(:VirtualQuantity) { should == @mock_vm.memory.to_s }
-              end
-
-              describe "SCSI controller" do
-                subject { @vapp.body[:VirtualHardwareSection][:Item].detect {|i| i[:ResourceType] == "6" } }
-
-                its(:Address) { should == "0" }
-              end
-
-              describe "Hard Disks" do
-                subject { @vapp.body[:VirtualHardwareSection][:Item].find_all {|i| i[:ResourceType] == "17" } }
-
-                it { should have(2).disks }
-
-                describe "#1" do
-                  subject { @vapp.body[:VirtualHardwareSection][:Item].find_all {|i| i[:ResourceType] == "17" }[0] }
-
-                  its(:AddressOnParent) { should == "0" }
-                  its(:VirtualQuantity) { should == (1024 * @mock_vm.disks[0][:size].to_i).to_s }
-                  its(:HostResource)    { should == (1024 * @mock_vm.disks[0][:size].to_i).to_s }
-                end
-
-                describe "#2" do
-                  subject { @vapp.body[:VirtualHardwareSection][:Item].find_all {|i| i[:ResourceType] == "17" }[1] }
-
-                  its(:AddressOnParent) { should == "1" }
-                  its(:VirtualQuantity) { should == (1024 * @mock_vm.disks[1][:size].to_i).to_s }
-                  its(:HostResource)    { should == (1024 * @mock_vm.disks[1][:size].to_i).to_s }
-                end
-              end
-            end
-          end
-        end
-      end
-
-      context "with a vapp uri that doesn't exist" do
-        subject { lambda { @vcloud.get_vapp(URI.parse('https://www.fakey.com/api/v0.8/vApp/99999')) } }
-
-        it_should_behave_like("a request for a resource that doesn't exist")
-      end
-    end
-  end
-end

data/spec/ecloud/requests/get_vdc_spec.rb

@@ -1,112 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_vdc) }
-
-    describe "#get_vdc" do
-      context "with a valid vdc uri" do
-        before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc.href)) }
-        subject { @vdc }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.vdc+xml") }
-
-        describe "#body" do
-          subject { @vdc.body }
-
-          it { should have(11).items }
-
-          it_should_behave_like("it has the standard vcloud v0.8 xmlns attributes")   # 3 keys
-
-          its(:href) { should == @mock_vdc.href }
-          its(:name) { should == @mock_vdc.name }
-
-          its(:Description) { should == "" }
-          its(:StorageCapacity) { should == {:Units => "bytes * 10^9", :Allocated => @mock_vdc.storage_allocated.to_s, :Used => @mock_vdc.storage_used.to_s } }
-          its(:ComputeCapacity) { should == {:InstantiatedVmsQuota => { :Limit => "-1", :Used => "-1" },
-                                             :Memory => { :Units => "bytes * 2^20", :Allocated => @mock_vdc.memory_allocated.to_s },
-                                             :Cpu => { :Units => "hz * 10^6", :Allocated => @mock_vdc.cpu_allocated.to_s },
-                                             :DeployedVmsQuota => { :Limit => "-1", :Used => "-1" } } }
-
-          its(:Link) { should have(4).links }
-
-          describe "link 0" do
-            subject { @vdc.body[:Link][0] }
-            it { should have(4).attributes }
-            its(:type) { should == "application/vnd.vmware.vcloud.catalog+xml" }
-            its(:rel)  { should == "down" }
-            its(:href) { should == @mock_vdc.catalog.href }
-            its(:name) { should == @mock_vdc.catalog.name }
-          end
-          describe "link 1" do
-            subject { @vdc.body[:Link][1] }
-            it { should have(4).attributes }
-            its(:type) { should == "application/vnd.tmrk.ecloud.publicIpsList+xml" }
-            its(:rel)  { should == "down" }
-            its(:href) { should == @mock_vdc.public_ip_collection.href }
-            its(:name) { should == @mock_vdc.public_ip_collection.name }
-          end
-          describe "link 2" do
-            subject { @vdc.body[:Link][2] }
-            it { should have(4).attributes }
-            its(:type) { should == "application/vnd.tmrk.ecloud.internetServicesList+xml" }
-            its(:rel)  { should == "down" }
-            its(:href) { should == @mock_vdc.internet_service_collection.href }
-            its(:name) { should == @mock_vdc.internet_service_collection.name }
-          end
-          describe "link 3" do
-            subject { @vdc.body[:Link][3] }
-            it { should have(4).attributes }
-            its(:type) { should == "application/vnd.tmrk.ecloud.firewallAclsList+xml" }
-            its(:rel)  { should == "down" }
-            its(:href) { should == @mock_vdc.firewall_acls.href }
-            its(:name) { should == @mock_vdc.firewall_acls.name }
-          end
-
-          let(:resource_entities) { subject[:ResourceEntities][:ResourceEntity] }
-          specify { resource_entities.should have(@mock_vdc.virtual_machines.length).vapps  }
-
-          describe "[:ResourceEntities][:ResourceEntity]" do
-            context "[0]" do
-              subject { @vdc.body[:ResourceEntities][:ResourceEntity][0] }
-              it { should be_a_vapp_link_to(@mock_vdc.virtual_machines[0]) }
-            end
-            context "[1]" do
-              subject { @vdc.body[:ResourceEntities][:ResourceEntity][1] }
-              it { should be_a_vapp_link_to(@mock_vdc.virtual_machines[1]) }
-            end
-            context "[2]" do
-              subject { @vdc.body[:ResourceEntities][:ResourceEntity][2] }
-              it { should be_a_vapp_link_to(@mock_vdc.virtual_machines[2]) }
-            end
-          end
-
-          its(:name)            { should == @mock_vdc[:name] }
-
-          let(:available_networks) { subject[:AvailableNetworks][:Network] }
-          specify { available_networks.should have(2).networks }
-
-          describe "[:AvailableNetworks][:Network]" do
-            context "[0]" do
-              subject { @vdc.body[:AvailableNetworks][:Network][0] }
-              it { should be_a_network_link_to(@mock_vdc.networks[0]) }
-            end
-            context "[1]" do
-              subject { @vdc.body[:AvailableNetworks][:Network][1] }
-              it { should be_a_network_link_to(@mock_vdc.networks[1]) }
-            end
-          end
-        end
-      end
-
-      context "with a vdc uri that doesn't exist" do
-        subject { lambda { @vcloud.get_vdc(URI.parse('https://www.fakey.com/api/v0.8/vdc/999')) } }
-
-        it_should_behave_like("a request for a resource that doesn't exist")
-      end
-    end
-  end
-end

data/spec/ecloud/requests/get_versions_spec.rb

@@ -1,57 +0,0 @@
-require 'ecloud/spec_helper'
-
-shared_examples_for "real or mock get_versions requests" do
-  if Fog.mocking?
-
-    subject { @vcloud }
-
-    it { should respond_to(:get_versions) }
-
-    describe "#get_versions" do
-      subject { @vcloud.get_versions( @vcloud.versions_uri ) }
-
-      it_should_behave_like "all responses"
-
-      describe "body" do
-        subject { @vcloud.get_versions( @vcloud.versions_uri ).body }
-
-        it { should have(4).keys }
-        it_should_behave_like "it has the standard xmlns attributes"   # 2 keys
-
-        its(:xmlns) { should == "http://www.vmware.com/vcloud/versions" }
-
-        its(:VersionInfo) { should be_either_a_hash_or_array }
-
-        describe ":VersionInfo" do
-          subject { arrayify(@vcloud.get_versions( @vcloud.versions_uri ).body[:VersionInfo]) }
-
-          specify {
-            subject.each do |version_info|
-              version_info.should include(:LoginUrl)
-              version_info[:LoginUrl].should be_a_url
-              version_info.should include(:Version)
-              version_info[:Version].should be_an_instance_of(String)
-            end
-          }
-        end
-      end
-    end
-
-  end
-end
-
-if Fog.mocking?
-  describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
-
-    it_should_behave_like "real or mock get_versions requests"
-
-    describe "body" do
-      subject { @vcloud.get_versions( @vcloud.versions_uri ).body }
-      its(:VersionInfo) { should == { :LoginUrl => @mock_version.login_url , :Version => @mock_version.version } }
-    end
-  end
-else
-  describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
-    it_should_behave_like "real or mock get_versions requests"
-  end
-end

data/spec/ecloud/requests/instantiate_vapp_template_spec.rb

@@ -1,95 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Ecloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:instantiate_vapp_template) }
-
-    describe "#instantiate_vapp_template" do
-      let(:vdc) { @vcloud.vdcs.first }
-      let(:mock_vdc) { @mock_vdc }
-
-      let(:catalog_item) { vdc.catalog.first }
-      let(:mock_catalog_item) { @vcloud.mock_data.catalog_item_from_href(catalog_item.href) }
-
-      let(:new_vapp_data) do
-        {
-          :name => "foobar",
-          :network_uri => @mock_network.href,
-          :row => "test row",
-          :group => "test group",
-          :memory => 1024,
-          :cpus => 2,
-          :vdc_uri => @mock_vdc.href
-        }
-      end
-
-      let(:added_mock_data) { mock_vdc.virtual_machines.last }
-
-      context "with a valid data" do
-        let(:template_instantiation) { @vcloud.instantiate_vapp_template(catalog_item.href, new_vapp_data) }
-        subject { template_instantiation }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/xml") }
-
-        it "updates the mock data properly" do
-          expect { subject }.to change { mock_vdc.virtual_machines.size }.by(1)
-        end
-
-        describe "added mock data" do
-          before  { template_instantiation }
-          subject { added_mock_data }
-
-          it { should be_an_instance_of(Fog::Ecloud::MockDataClasses::MockVirtualMachine) }
-
-          its(:name) { should == new_vapp_data[:name] }
-          its(:memory) { should == new_vapp_data[:memory] }
-          its(:cpus) { should == new_vapp_data[:cpus] }
-          # WHAT
-          specify { subject._parent.should == mock_vdc }
-          specify { subject.status.should == 2 }
-          specify { subject.disks.should == mock_catalog_item.disks }
-          # its(:_parent) { should == mock_vdc }
-          #its(:status) { should == 2 }
-          #its(:disks) { should == mock_catalog_item.disks }
-        end
-
-        describe "server based on added mock data" do
-          before  { template_instantiation }
-          subject { vdc.servers.reload.detect {|s| s.href == added_mock_data.href }.reload }
-
-          its(:name) { should == new_vapp_data[:name] }
-        end
-
-        describe "#body" do
-          subject { template_instantiation.body }
-
-          it { should have(9).items }
-
-          it_should_behave_like("it has the standard vcloud v0.8 xmlns attributes")   # 3 keys
-
-          its(:href) { should == added_mock_data.href }
-          its(:type) { should == "application/vnd.vmware.vcloud.vApp+xml" }
-          its(:name) { should == new_vapp_data[:name] }
-          its(:status) { should == "0" }
-          its(:size) { should == "4" }
-
-          it { should include(:Link) }
-
-          describe "Link" do
-            subject { template_instantiation.body[:Link] }
-
-            it { should have(3).keys }
-
-            its(:rel)  { should == "up" }
-            its(:type) { should == "application/vnd.vmware.vcloud.vdc+xml" }
-            # WHAT
-            its(:href) { blah = vdc.href; should == blah }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/ecloud/requests/login_spec.rb

@@ -1,10 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it_should_behave_like "all login requests"
-  end
-else
-end

data/spec/ecloud/requests/power_off_spec.rb

@@ -1,34 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:power_off) }
-
-    describe :power_off, :type => :vcloud_request do
-      context "with a valid vapp uri" do
-        before { @mock_vm.power_on!; @power_off = @vcloud.power_off(@mock_vm.href(:power_off)) }
-        subject { @power_off }
-
-        it_should_behave_like "all responses"
-        #it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
-
-        specify { @mock_vm.status.should == 2 }
-
-        describe :body do
-          subject { @power_off.body }
-
-          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-        end
-      end
-
-      context "with a vapp uri that doesn't exist" do
-        subject { lambda { @vcloud.power_off(URI.parse('https://www.fakey.com/api/v0.8/vapp/9999')) } }
-        it_should_behave_like "a request for a resource that doesn't exist"
-      end
-    end
-  end
-else
-end
-

data/spec/ecloud/requests/power_on_spec.rb

@@ -1,34 +0,0 @@
-require 'ecloud/spec_helper'
-
-if Fog.mocking?
-  describe Fog::Ecloud, :type => :mock_tmrk_ecloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:power_on) }
-
-    describe :power_on, :type => :vcloud_request do
-      context "with a valid vapp uri" do
-        before { @mock_vm.power_off!; @power_on = @vcloud.power_on(@mock_vm.href(:power_on)) }
-        subject { @power_on }
-
-        it_should_behave_like "all responses"
-        #it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
-
-        specify { @mock_vm.status.should == 4 }
-
-        describe :body do
-          subject { @power_on.body }
-
-          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-        end
-      end
-
-      context "with a vapp uri that doesn't exist" do
-        subject { lambda { @vcloud.power_on(URI.parse('https://www.fakey.com/api/v0.8/vapp/9999')) } }
-        it_should_behave_like "a request for a resource that doesn't exist"
-      end
-    end
-  end
-else
-end
-