phpfog-fog 0.4.1

data/spec/vcloud/terremark/ecloud/requests/get_network_ips_spec.rb

@@ -0,0 +1,59 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :get_network_ips }
+
+    describe "#get_network_ips" do
+      context "with a valid VDC network ips_uri" do
+        before { @ips = @vcloud.get_network_ips(@mock_network_ip_collection.href) }
+        subject { @ips }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.tmrk.ecloud.ipAddressesList+xml" }
+
+        describe "#body" do
+          subject { @ips.body }
+
+          it { should have(1).item }
+
+          context "[:IpAddress]" do
+            subject { @ips.body[:IpAddress] }
+
+            # Note the real TMRK API returns only "assigned" ips currently
+            # This is a bug they've slated to fix in the next release.
+            it { should have(252).addresses }
+
+          end
+
+          context "one we know is assigned" do
+            let(:address) { @ips.body[:IpAddress][0] }
+            specify { address.should have(6).keys }
+            specify { address[:Status].should == "Assigned" }
+            specify { address[:Server].should == "Broom 1" }
+            specify { address[:Name].should == "1.2.3.3" }
+            specify { address[:RnatAddress].should == "99.1.2.3" }
+          end
+
+          context "one we know is not assigned" do
+            let(:address) { @ips.body[:IpAddress][100] }
+            specify { address.should have(5).keys }
+            specify { address[:Status].should == "Available" }
+            specify { address.has_key?(:Server).should be_false }
+            specify { address[:Name].should == "1.2.3.103" }
+            specify { address[:RnatAddress].should == "99.1.2.3" }
+          end
+        end
+      end
+
+      context "with a network ips uri that doesn't exist" do
+        subject { lambda { @vcloud.get_network_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/vcloud/terremark/ecloud/requests/get_network_spec.rb

@@ -0,0 +1,49 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :get_network }
+
+    describe "#get_network" do
+      context "with a valid network uri" do
+        before { @network = @vcloud.get_network(@mock_network.href) }
+        subject { @network }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
+
+        describe "#body" do
+          subject { @network.body }
+
+          it { should have(9).keys }
+
+          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
+
+          its(:type) { should == "application/vnd.vmware.vcloud.network+xml" }
+          its(:Features) { should == @mock_network.features.map {|f| { f[:type] => f[:value] } }.first }
+          its(:href) { should == @mock_network.href }
+          its(:name) { should == @mock_network.name }
+          its(:Configuration) { should == { :Gateway => @mock_network.gateway, :Netmask => @mock_network.netmask } }
+          its(:Link) { should ==
+                         [{:type => "application/xml",
+                            :rel => "down",
+                            :href => @mock_network_ip_collection.href,
+                            :name => "IP Addresses"},
+                           {:type => "application/xml",
+                            :rel => "down",
+                            :href => @mock_network_extensions.href,
+                            :name => @mock_network_extensions.name}]}
+        end
+      end
+
+      context "with a network uri that doesn't exist" do
+        subject { lambda { @vcloud.get_network(URI.parse('https://www.fakey.com/api/v0.8/network/999')) } }
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
+    end
+  end
+else
+end
+

data/spec/vcloud/terremark/ecloud/requests/get_node_spec.rb

@@ -0,0 +1,41 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :get_node }
+
+    describe "#get_node" do
+      context "with a valid nodes_uri" do
+        before { @node = @vcloud.get_node(@mock_node.href) }
+        subject { @node }
+
+        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 { @node.body }
+
+          it { should have(9).keys }
+
+          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(:Description) { should == @mock_node.description }
+          its(:IpAddress) { should == @mock_node.ip_address }
+
+        end
+      end
+
+      context "with a public_ips_uri that doesn't exist" do
+        subject { lambda { @vcloud.get_node(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/vcloud/terremark/ecloud/requests/get_nodes_spec.rb

@@ -0,0 +1,58 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, 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/vcloud/terremark/ecloud/requests/get_public_ip_spec.rb

@@ -0,0 +1,38 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, 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/vcloud/terremark/ecloud/requests/get_public_ips_spec.rb

@@ -0,0 +1,52 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, 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/vcloud/terremark/ecloud/requests/get_vapp_spec.rb

@@ -0,0 +1,126 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, 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
+else
+end

data/spec/vcloud/terremark/ecloud/requests/get_vdc_spec.rb

@@ -0,0 +1,113 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, 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
+else
+end

data/spec/vcloud/terremark/ecloud/requests/instantiate_vapp_template_spec.rb

@@ -0,0 +1,96 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe "Fog::Vcloud, 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::Vcloud::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
+else
+end

data/spec/vcloud/terremark/ecloud/requests/login_spec.rb

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

data/spec/vcloud/terremark/ecloud/requests/power_off_spec.rb

@@ -0,0 +1,34 @@
+require 'vcloud/spec_helper'
+
+if Fog.mocking?
+  describe Fog::Vcloud, :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
+