fog 0.3.16 → 0.3.17

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

@@ -9,26 +9,24 @@ if Fog.mocking?
 
     describe "#delete_internet_service" do
       context "with a valid internet service uri" do
-        subject { @vcloud.delete_internet_service(@mock_service[:href]) }
+        subject { @vcloud.delete_internet_service(@mock_service.href) }
 
         it_should_behave_like "all delete responses"
 
-        let(:public_ip) { @vcloud.vdcs.first.public_ips.first }
+        let(:public_ip) { @vcloud.vdcs.first.public_ips.detect {|i| i.name == @mock_public_ip.name } }
+
+        it "should change the mock data" do
+          expect { subject }.to change { @mock_public_ip.internet_service_collection.items.count }.by(-1)
+        end
 
         it "should change the count by -1" do
-          public_ip.internet_services.length.should == 2
-          subject
-          public_ip.internet_services.reload.length.should == 1
+          expect { subject }.to change { public_ip.reload.internet_services.reload.length }.by(-1)
         end
 
         describe "#body" do
           its(:body) { should == '' }
         end
-
-
-
       end
-
     end
   end
 else

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

@@ -9,16 +9,12 @@ if Fog.mocking?
 
     describe "#delete_node" do
       context "with a valid node service uri" do
-        subject { @vcloud.delete_node(@mock_node[:href]) }
+        subject { @vcloud.delete_node(@mock_node.href) }
 
-        #it_should_behave_like "all delete responses"
-
-        let(:internet_service) { @vcloud.vdcs.first.public_ips.first.internet_services.first }
+        it_should_behave_like "all delete responses"
 
         it "should change the count by -1" do
-          internet_service.nodes.length.should == 2
-          subject
-          internet_service.nodes.reload.length.should == 1
+          expect { subject }.to change { @vcloud.get_nodes(@mock_node_collection.href).body[:NodeService].length }.by(-1)
         end
       end
 

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

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+shared_examples_for "a failed vapp deletion" do
+  it "should not change the mock data" do
+    expect { subject }.to change { @mock_vdc.virtual_machines.count }.by(0)
+  end
+
+  it "should not change the model data" do
+    expect { subject }.to change { vdc.reload.servers.reload.count }.by(0)
+  end
+
+  describe "#body" do
+    its(:body) { should == '' }
+  end
+
+  describe "#headers" do
+    its(:headers) { should_not include "Location" }
+  end
+end
+
+#FIXME: Make this more sane with rspec2
+if Fog.mocking?
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :delete_vapp }
+
+    describe "#delete_vapp" do
+      context "with a valid vapp uri" do
+        subject { @vcloud.delete_vapp(@mock_vm.href) }
+        let(:vdc) { @vcloud.vdcs.first }
+
+        context "when there are no internet service nodes attached" do
+          it_should_behave_like "all delete responses"
+
+          it "should change the mock data" do
+            expect { subject }.to change { @mock_vdc.virtual_machines.count }.by(-1)
+          end
+
+          it "should change the model data" do
+            expect { subject }.to change { vdc.reload.servers.reload.count }.by(-1)
+          end
+
+          describe "#body" do
+            its(:body) { should == '' }
+          end
+
+          describe "#headers" do
+            its(:headers) { should include "Location" }
+          end
+        end
+
+        context "when there are internet service nodes attached" do
+          before do
+            vdc.public_ips.first.internet_services.create(:name => "#{@mock_vm.name} service", :port => 1231, :protocol => "TCP", :description => "", :enabled => true).tap do |internet_service|
+              internet_service.nodes.create(:name => "#{@mock_vm.name} node", :port => 1231, :description => "", :enabled => true, :ip_address => @mock_vm.ip)
+            end
+          end
+
+          it_should_behave_like "all delete responses"
+          it_should_behave_like "a failed vapp deletion"
+        end
+
+        context "when the VM is powered on" do
+          before do
+            @mock_vm.power_on!
+          end
+
+          it_should_behave_like "all delete responses"
+          it_should_behave_like "a failed vapp deletion"
+        end
+      end
+
+      context "with a vapp uri that doesn't exist" do
+        subject { lambda { @vcloud.delete_vapp(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_catalog_item_spec.rb

@@ -10,7 +10,7 @@ if Fog.mocking?
       context "with a valid catalog_item_uri" do
         before { @catalog_item = @vcloud.get_catalog_item(@vcloud.vdcs.first.catalog.first.href) }
         subject { @catalog_item }
-        let(:catalog_item_id) { @catalog_item.body[:href].split("/").last.split("-").first }
+        let(:mock_data_catalog_item) { @mock_data.catalog_item_from_href(@catalog_item.body[:href]) }
 
         it_should_behave_like "all responses"
         it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.catalogItem+xml" }
@@ -30,12 +30,13 @@ if Fog.mocking?
 
           describe "Entity" do
             subject { @catalog_item.body[:Entity] }
+            let(:mock_data_catalog_item) { @mock_data.catalog_item_from_href(@catalog_item.body[:href]) }
 
             it { should have(3).items }
 
-            its(:name) { should == "Item 0" }
+            its(:name) { should == mock_data_catalog_item.name }
             its(:type) { should == "application/vnd.vmware.vcloud.vAppTemplate+xml" }
-            its(:href) { should == Fog::Vcloud::Terremark::Ecloud::Mock.vapp_template_href(:id => catalog_item_id) }
+            its(:href) { should == mock_data_catalog_item.vapp_template.href }
           end
 
           describe "Link" do
@@ -44,8 +45,8 @@ if Fog.mocking?
             it { should have(4).items }
 
             its(:rel)  { should == "down" }
-            its(:href) { should == Fog::Vcloud::Terremark::Ecloud::Mock.catalog_item_customization_href(:id => catalog_item_id) }
-            its(:name) { should == "Customization Options" }
+            its(:href) { should == mock_data_catalog_item.customization.href }
+            its(:name) { should == mock_data_catalog_item.customization.name }
             its(:type) { should == "application/vnd.tmrk.ecloud.catalogItemCustomizationParameters+xml" }
           end
         end

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

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe "#get_catalog" do
       context "with a valid vdc catalog_uri" do
-        before { @catalog = @vcloud.get_catalog(@mock_vdc[:href] + "/catalog") }
+        before { @catalog = @vcloud.get_catalog(@mock_vdc.catalog.href) }
         subject { @catalog }
 
         it_should_behave_like "all responses"
@@ -21,7 +21,7 @@ if Fog.mocking?
 
           it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
 
-          its(:name) { should == "The catalog" }
+          its(:name) { should == @mock_vdc.catalog.name }
 
           it { should include :CatalogItems }
 

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

@@ -1,6 +1,28 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
 if Fog.mocking?
+  shared_examples_for "the expected internet service item" do
+    specify { service.should be_an_instance_of Hash }
+    specify { service.should have(11).attributes }
+    specify { service[:Name].should == mock_service.name }
+    specify { service[:Id].should == mock_service.object_id.to_s }
+    specify { service[:Href].should == mock_service.href }
+
+    specify { service[:PublicIpAddress].should be_an_instance_of Hash }
+    specify { service[:PublicIpAddress].should have(3).attributes }
+    specify { service[:PublicIpAddress][:Name].should == mock_ip.name }
+    specify { service[:PublicIpAddress][:Href].should == mock_ip.href }
+    specify { service[:PublicIpAddress][:Id].should == mock_ip.object_id.to_s }
+
+    specify { service[:Port].should == mock_service.port.to_s }
+    specify { service[:Protocol].should == mock_service.protocol }
+    specify { service[:Enabled].should == mock_service.enabled.to_s }
+    specify { service[:Timeout].should == mock_service.timeout.to_s }
+    specify { service[:Description].should == mock_service.description }
+    specify { service[:RedirectURL].should == (mock_service.redirect_url || "") }
+    specify { service[:Monitor].should == "" }
+  end
+
   describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
     subject { @vcloud }
 
@@ -8,7 +30,7 @@ if Fog.mocking?
 
     describe "#get_internet_services" do
       context "with a valid VDC internet_services_uri" do
-        before { @services = @vcloud.get_internet_services( @mock_vdc[:href] + "/internetServices" ) }
+        before { @services = @vcloud.get_internet_services(@mock_vdc_service_collection.href) }
         subject { @services }
 
         it_should_behave_like "all responses"
@@ -29,26 +51,10 @@ if Fog.mocking?
 
             [0,1,2,3].each do |idx|
               let(:service) { subject[idx] }
-              let(:mock_service) { @mock_vdc[:public_ips].map { |ip| ip[:services] }.flatten[idx] }
-              let(:mock_ip) { @mock_vdc[:public_ips].detect { |ip| ip[:services].detect { |ipservice| ipservice[:id] == service[:Id] } } }
-              specify { service.should be_an_instance_of Hash }
-              specify { service.should have(11).attributes }
-              specify { service[:Name].should == mock_service[:name] }
-              specify { service[:Id].should == mock_service[:id] }
-              specify { service[:Href].should == Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(mock_service) }
-
-              specify { service[:PublicIpAddress].should be_an_instance_of Hash }
-              specify { service[:PublicIpAddress].should have(3).attributes }
-              specify { service[:PublicIpAddress][:Name].should == mock_ip[:name] }
-              specify { service[:PublicIpAddress][:Id].should == mock_ip[:id] }
-
-              specify { service[:Port].should == mock_service[:port] }
-              specify { service[:Protocol].should == mock_service[:protocol] }
-              specify { service[:Enabled].should == mock_service[:enabled] }
-              specify { service[:Timeout].should == mock_service[:timeout] }
-              specify { service[:Description].should == mock_service[:description] }
-              specify { service[:RedirectURL].should == mock_service[:redirect_url] }
-              specify { service[:Monitor].should == "" }
+              let(:mock_service) { @mock_vdc.public_ip_collection.items.map {|ip| ip.internet_service_collection.items }.flatten[idx] }
+              let(:mock_ip) { mock_service._parent._parent }
+
+              it_should_behave_like "the expected internet service item"
             end
           end
         end
@@ -56,8 +62,7 @@ if Fog.mocking?
 
       context "with a valid Public IP uri" do
         before do
-          @mock_public_ip = @mock_vdc[:public_ips].first
-          @services = @vcloud.get_internet_services( @mock_public_ip[:href] + "/internetServices" ) 
+          @services = @vcloud.get_internet_services(@mock_service_collection.href)
         end
         subject { @services }
 
@@ -79,26 +84,10 @@ if Fog.mocking?
 
             [0,1].each do |idx|
               let(:service) { subject[idx] }
-              let(:mock_service) { @mock_public_ip[:services][idx] }
+              let(:mock_service) { @mock_service_collection.items[idx] }
               let(:mock_ip) { @mock_public_ip }
-              specify { service.should be_an_instance_of Hash }
-              specify { service.should have(11).attributes }
-              specify { service[:Name].should == mock_service[:name] }
-              specify { service[:Id].should == mock_service[:id] }
-              specify { service[:Href].should == Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(mock_service) }
-
-              specify { service[:PublicIpAddress].should be_an_instance_of Hash }
-              specify { service[:PublicIpAddress].should have(3).attributes }
-              specify { service[:PublicIpAddress][:Name].should == mock_ip[:name] }
-              specify { service[:PublicIpAddress][:Id].should == mock_ip[:id] }
-
-              specify { service[:Port].should == mock_service[:port] }
-              specify { service[:Protocol].should == mock_service[:protocol] }
-              specify { service[:Enabled].should == mock_service[:enabled] }
-              specify { service[:Timeout].should == mock_service[:timeout] }
-              specify { service[:Description].should == mock_service[:description] }
-              specify { service[:RedirectURL].should == mock_service[:redirect_url] }
-              specify { service[:Monitor].should == "" }
+
+              it_should_behave_like "the expected internet service item"
             end
           end
         end

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

@@ -9,10 +9,7 @@ if Fog.mocking?
     describe "#get_network_ip" do
       context "with a valid ip_uri" do
         before do
-          @mock_network = @mock_vdc[:networks][0]
-          @mock_ip = @mock_network[:ips].keys.first
-          @mock_ip_href = "#{Fog::Vcloud::Terremark::Ecloud::Mock.extension_url}/ip/#{@mock_ip.gsub('.','')}"
-          @ip = @vcloud.get_network_ip( @mock_ip_href )
+          @ip = @vcloud.get_network_ip(@mock_network_ip.href)
         end
 
         subject { @ip }
@@ -23,9 +20,9 @@ if Fog.mocking?
         describe "#body" do
           subject { @ip.body }
 
-          its(:Name) { should == @mock_ip }
-          its(:Href) { should == @mock_ip_href }
-          its(:Id)   { should == @mock_ip.gsub('.','') }
+          its(:Name) { should == @mock_network_ip.name }
+          its(:Href) { should == @mock_network_ip.href }
+          its(:Id)   { should == @mock_network_ip.object_id.to_s }
 
         end
       end

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

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe "#get_network_ips" do
       context "with a valid VDC network ips_uri" do
-        before { @ips = @vcloud.get_network_ips( @mock_network[:href] + "/ips" ) }
+        before { @ips = @vcloud.get_network_ips(@mock_network_ip_collection.href) }
         subject { @ips }
 
         it_should_behave_like "all responses"

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

@@ -1,35 +1,43 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
 if Fog.mocking?
-  describe Fog::Vcloud, :type => :mock_tmrk_ecloud_request do
+  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, :type => :vcloud_request do
+    describe "#get_network" do
       context "with a valid network uri" do
-        before { @network = @vcloud.get_network( @mock_network[:href] ) }
+        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
+        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
 
-          it { should have_key_with_value :type, "application/vnd.vmware.vcloud.network+xml" }
-          it { should have_key_with_value :Features, {:FenceMode => "isolated"} }
-          it { should have_key_with_value :href, @mock_network[:href] }
-          it { should have_key_with_value :name, @mock_network[:name] }
-          it { should have_key_with_value :Configuration, {:Gateway => @mock_network[:gateway],
-                                                           :Netmask => @mock_network[:netmask] } }
-
+          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"

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

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe "#get_node" do
       context "with a valid nodes_uri" do
-        before { @node = @vcloud.get_node(@mock_node[:href]) }
+        before { @node = @vcloud.get_node(@mock_node.href) }
         subject { @node }
 
         it_should_behave_like "all responses"
@@ -19,13 +19,13 @@ if Fog.mocking?
 
           it { should have(9).keys }
 
-          its(:Href) { should == @mock_node[:href] }
-          its(:Id) { should == @mock_node[:id] }
-          its(:Name) { should == @mock_node[:name] }
-          its(:Enabled) { should == @mock_node[:enabled] }
-          its(:Port) { should == @mock_node[:port] }
-          its(:Description) { should == @mock_node[:description]}
-          its(:IpAddress) { should == @mock_node[:ip_address]}
+          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

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

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe "#get_nodes" do
       context "with a valid nodes_uri" do
-        before { @nodes = @vcloud.get_nodes(@mock_service[:href] + "/nodeServices") }
+        before { @nodes = @vcloud.get_nodes(@mock_node_collection.href) }
         subject { @nodes }
 
         it_should_behave_like "all responses"
@@ -22,22 +22,22 @@ if Fog.mocking?
           describe "[:NodeService]" do
             subject { @nodes.body[:NodeService] }
 
-            it { should have(@mock_service[:nodes].length).nodes }
+            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_service[:nodes][idx] }
-                let(:keys) { subject.keys.sort {|a,b| a.to_s <=> b.to_s } }
+                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[:id] }
-                its(:Name) { should == mock_node[:name] }
-                its(:Enabled) { should == mock_node[:enabled] }
-                its(:Port) { should == mock_node[:port] }
-                its(:IpAddress) { should == mock_node[:ip_address] }
-                its(:Description) { should == mock_node[:description] }
+                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