fog 0.3.16 → 0.3.17

data/spec/vcloud/terremark/ecloud/models/network_spec.rb

@@ -8,7 +8,7 @@ if Fog.mocking?
       subject { Fog::Vcloud::Terremark::Ecloud::Network }
 
       it { should have_identity :href }
-      it { should have_only_these_attributes [:href, :name, :id, :features, :links, :type, :gateway, :broadcast, :address, :rnat, :extension_href] }
+      it { should have_only_these_attributes [:href, :name, :features, :links, :type, :gateway, :broadcast, :address, :rnat, :extension_href] }
     end
 
     context "with no uri" do
@@ -19,27 +19,26 @@ if Fog.mocking?
     end
 
     context "as a collection member" do
-      subject { @vcloud.vdcs[0].networks[0].reload; @vcloud.vdcs[0].networks[0] }
+      subject { @vcloud.vdcs[0].networks[0].reload }
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Network }
 
-      its(:href)                  { should == @mock_network[:href] }
-      its(:identity)              { should == @mock_network[:href] }
-      its(:name)                  { should == @mock_network[:name] }
+      its(:href)                  { should == @mock_network.href }
+      its(:identity)              { should == @mock_network.href }
+      its(:name)                  { should == @mock_network.name }
       its(:type)                  { should == "application/vnd.vmware.vcloud.network+xml" }
-      its(:id)                    { should == @mock_network[:id] }
-      its(:gateway)               { should == @mock_network[:gateway] }
-      its(:broadcast)             { should == IPAddr.new(@mock_network[:subnet]).to_range.last.to_s }
-      its(:address)               { should == @mock_network[:subnet].split("/")[0] }
-      its(:rnat)                  { should == @mock_network[:rnat] }
-      its(:extension_href)        { should == @mock_network[:extension_href] }
+      its(:gateway)               { should == @mock_network.gateway }
+      its(:broadcast)             { should == @mock_network.broadcast }
+      its(:address)               { should == @mock_network.address }
+      its(:rnat)                  { should == @mock_network.rnat }
+      its(:extension_href)        { should == @mock_network.extensions.href }
 
       it { should have(1).features }
 
       describe :features do
         let(:feature) { subject.features[0] }
         specify { feature.should be_an_instance_of Hash }
-        specify { feature[:FenceMode].should == @mock_network[:features][0][:value] }
+        specify { feature[:FenceMode].should == @mock_network.features[0][:value] }
       end
 
       it { should have(2).links }
@@ -48,17 +47,17 @@ if Fog.mocking?
         context "[0]" do
           let(:link) { subject.links[0] }
           specify { link[:rel].should == "down" }
-          specify { link[:href].should == "#{@mock_network[:href]}/ips" }
+          specify { link[:href].should == @mock_network_ip_collection.href }
           specify { link[:type].should == "application/xml" }
-          specify { link[:name].should == "IP Addresses" }
+          specify { link[:name].should == @mock_network_ip_collection.name }
         end
 
         context "[1]" do
           let(:link) { subject.links[1] }
           specify { link[:rel].should == "down" }
-          specify { link[:href].should == @mock_network[:extension_href] }
+          specify { link[:href].should == @mock_network.extensions.href }
           specify { link[:type].should == "application/xml" }
-          specify { link[:name].should == @mock_network[:name] }
+          specify { link[:name].should == @mock_network.name }
         end
       end
 

data/spec/vcloud/terremark/ecloud/models/node_spec.rb

@@ -24,13 +24,13 @@ if Fog.mocking?
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Node }
 
-      its(:href)                  { should == @mock_node[:href] }
-      its(:identity)              { should == @mock_node[:href] }
-      its(:name)                  { should == @mock_node[:name] }
-      its(:id)                    { should == @mock_node[:id] }
-      its(:port)                  { should == @mock_node[:port] }
-      its(:enabled)               { should == @mock_node[:enabled] }
-      its(:description)           { should == @mock_node[:description] }
+      its(:href)                  { should == @mock_node.href }
+      its(:identity)              { should == @mock_node.href }
+      its(:name)                  { should == @mock_node.name }
+      its(:id)                    { should == @mock_node.object_id.to_s }
+      its(:port)                  { should == @mock_node.port.to_s }
+      its(:enabled)               { should == @mock_node.enabled.to_s }
+      its(:description)           { should == @mock_node.description }
 
     end
   end

data/spec/vcloud/terremark/ecloud/models/nodes_spec.rb

@@ -19,7 +19,7 @@ if Fog.mocking?
 
         it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Nodes }
 
-        its(:length) { should == 2 }
+        its(:length) { should == 3 }
 
         it { should have_members_of_the_right_model }
       end

data/spec/vcloud/terremark/ecloud/models/public_ip_spec.rb

@@ -2,10 +2,6 @@ require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
 if Fog.mocking?
   describe "Fog::Vcloud::Terremark::Ecloud::PublicIp", :type => :mock_tmrk_ecloud_model do
-    before do
-      @mock_ip = @mock_vdc[:public_ips].first
-    end
-
     subject { @vcloud }
 
     describe :class do
@@ -27,10 +23,10 @@ if Fog.mocking?
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIp }
 
-      its(:href)                  { should == @mock_ip[:href] }
-      its(:identity)              { should == @mock_ip[:href] }
-      its(:name)                  { should == @mock_ip[:name] }
-      its(:id)                    { should == @mock_ip[:id] }
+      its(:href)                  { should == @mock_public_ip.href }
+      its(:identity)              { should == @mock_public_ip.href }
+      its(:name)                  { should == @mock_public_ip.name }
+      its(:id)                    { should == @mock_public_ip.object_id.to_s }
 
       its(:internet_services)     { should have(2).services }
 

data/spec/vcloud/terremark/ecloud/models/server_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Vdc", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
+
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::Server }
+
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:href, :type, :name, :status, :network_connections, :os, :virtual_hardware, :storage_size, :links] }
+    end
+
+    context "with no uri" do
+      subject { Fog::Vcloud::Terremark::Ecloud::Server.new() }
+
+      it { should have_all_attributes_be_nil }
+    end
+
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].servers.first }
+
+      its(:href)                  { should == @mock_vm.href }
+      its(:identity)              { should == @mock_vm.href }
+      its(:name)                  { should == @mock_vm.name }
+      its(:cpus)                  { should == { :count => @mock_vm.cpus, :units => nil } }
+      its(:memory)                { should == { :amount => @mock_vm.memory, :units => nil } }
+      its(:disks)                 { should == @mock_vm.to_configure_vapp_hash[:disks] }
+    end
+
+    context "as a new server without all info" do
+      before { @vcloud.return_vapp_as_creating! "test123" }
+
+      subject { @vcloud.vdcs[0].servers.create(@mock_catalog_item.href, { :name => "test123", :row => "foo", :group => "bar", :network_uri => @mock_network.href }) }
+
+      its(:cpus)                  { should be_nil }
+      its(:memory)                { should be_nil }
+      its(:disks)                 { should == [] }
+    end
+  end
+else
+end

data/spec/vcloud/terremark/ecloud/models/vdc_spec.rb

@@ -22,26 +22,26 @@ if Fog.mocking?
     end
 
     context "as a collection member" do
-      subject { @vcloud.vdcs[0].reload; @vcloud.vdcs[0] }
+      subject { @vcloud.vdcs[0].reload }
 
-      its(:href)                  { should == @mock_vdc[:href] }
-      its(:identity)              { should == @mock_vdc[:href] }
-      its(:name)                  { should == @mock_vdc[:name] }
+      its(:href)                  { should == @mock_vdc.href }
+      its(:identity)              { should == @mock_vdc.href }
+      its(:name)                  { should == @mock_vdc.name }
       its(:public_ips)            { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIps }
       its(:other_links)           { should have(4).items }
       its(:resource_entities)     { should have(3).items }
       its(:available_networks)    { should have(2).items }
 
       its(:compute_capacity)      { should == {:Memory =>
-                                                {:Allocated => @mock_vdc[:memory][:allocated], :Units => "bytes * 2^20"}, 
+                                                {:Allocated => @mock_vdc.memory_allocated.to_s, :Units => "bytes * 2^20"}, 
                                                :DeployedVmsQuota =>
                                                 {:Limit => "-1", :Used => "-1"},
                                                :InstantiatedVmsQuota =>
                                                 {:Limit => "-1", :Used => "-1"}, 
                                                :Cpu =>
-                                                {:Allocated => @mock_vdc[:cpu][:allocated], :Units => "hz * 10^6"}} }
+                                                {:Allocated => @mock_vdc.cpu_allocated.to_s, :Units => "hz * 10^6"}} }
 
-      its(:storage_capacity)      { should == {:Allocated => @mock_vdc[:storage][:allocated], :Used => @mock_vdc[:storage][:used], :Units => "bytes * 10^9"} }
+      its(:storage_capacity)      { should == {:Allocated => @mock_vdc.storage_allocated.to_s, :Used => @mock_vdc.storage_used.to_s, :Units => "bytes * 10^9"} }
 
       its(:deployed_vm_quota)     { should == nil }
       its(:instantiated_vm_quota) { should == nil }

data/spec/vcloud/terremark/ecloud/models/vdcs_spec.rb

@@ -21,7 +21,7 @@ if Fog.mocking?
 
       it { should have_members_of_the_right_model }
 
-      its(:organization_uri) { should == @mock_organization[:info][:href] }
+      its(:organization_uri) { should == @mock_organization.href }
     end
   end
 else

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

@@ -8,7 +8,8 @@ if Fog.mocking?
 
     describe "#add_internet_service" do
       before do
-        @public_ip = @vcloud.vdcs[0].public_ips[0]
+        @public_ip = @vcloud.vdcs.first.public_ips.detect {|p| p.name == @mock_public_ip.name }
+
         @new_service_data = { :name => "Test Service",
                               :protocol => "HTTP",
                               :port => "80",
@@ -18,16 +19,10 @@ if Fog.mocking?
       end
 
       context "with a valid Public IP uri" do
-        it "has the right number of Internet Services before" do
-          before_services = @vcloud.get_internet_services(@public_ip.href)
-          before_services.body[:InternetService].should have(2).services
-        end
-
-        subject { @vcloud.add_internet_service(@public_ip.href.to_s + "/internetServices", @new_service_data ) }
+        subject { @vcloud.add_internet_service(@public_ip.internet_services.href, @new_service_data ) }
 
         it "has the right number of Internet Services after" do
-          subject
-          @vcloud.get_internet_services(@public_ip.href).body[:InternetService].should have(3).services
+          expect { subject }.to change { @vcloud.get_internet_services(@public_ip.internet_services.href).body[:InternetService].size }.by(1)
         end
 
         it_should_behave_like "all responses"
@@ -43,19 +38,19 @@ if Fog.mocking?
         specify { body[:RedirectURL].should == @new_service_data[:redirect_url] }
         specify { body[:Monitor].should == nil }
 
-        let(:public_ip) { subject.body[:PublicIpAddress] }
-        specify { public_ip.should be_an_instance_of Hash }
-        specify { public_ip[:Name].should == @public_ip.name }
-        specify { public_ip[:Id].should == @public_ip.id }
+        let(:referenced_public_ip) { subject.body[:PublicIpAddress] }
+        specify { referenced_public_ip.should be_an_instance_of Hash }
+        specify { referenced_public_ip[:Name].should == @public_ip.name }
+        specify { referenced_public_ip[:Id].should == @public_ip.id }
 
         it "should update the mock object properly" do
           subject
-          ip, service = @vcloud.mock_ip_and_service_from_service_url(body[:Href])
-          service[:href].should == body[:Href]
-          service[:id].should == body[:Id]
-          service[:nodes].should == []
-        end
 
+          public_ip_internet_service = @vcloud.mock_data.public_ip_internet_service_from_href(body[:Href])
+
+          public_ip_internet_service.object_id.to_s.should == body[:Id]
+          public_ip_internet_service.node_collection.items.should be_empty
+        end
       end
 
       context "with a public_ips_uri that doesn't exist" do

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

@@ -18,26 +18,30 @@ if Fog.mocking?
 
       context "with a valid node services uri" do
 
-        subject { @vcloud.add_node(@mock_service[:href] + "/nodeServices", new_node_data) }
+        subject { @vcloud.add_node(@mock_service.node_collection.href, new_node_data) }
 
         it_should_behave_like "all responses"
 
         let(:service) { @vcloud.vdcs.first.public_ips.first.internet_services.first }
 
         it "should change the count by 1" do
-          service.nodes.length.should == 2
-          subject
-          service.nodes.reload.length.should == 3
+          expect { subject }.to change { @vcloud.get_nodes(@mock_service.node_collection.href).body[:NodeService].length}.by(1)
         end
 
         describe "#body" do
-          subject { @vcloud.add_node(@mock_service[:href] + "/nodeServices", new_node_data).body }
+          subject { @vcloud.add_node(@mock_service.node_collection.href, new_node_data).body }
           its(:Enabled) { should == new_node_data[:enabled] }
           its(:Port) { should == new_node_data[:port] }
           its(:IpAddress) { should == new_node_data[:ip_address] }
           its(:Name) { should == new_node_data[:name] }
           its(:Description) { should == new_node_data[:description] }
         end
+
+        describe "added mock data" do
+          let(:added_mock_node) { @vcloud.mock_data.public_ip_internet_service_node_from_href(subject.body[:Href]) }
+
+          specify { added_mock_node._parent.should == @mock_service.node_collection }
+        end
       end
 
       context "with a nodes uri that doesn't exist" do

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

@@ -8,9 +8,8 @@ if Fog.mocking?
 
     describe "#configure_internet_service" do
       before do
-        @public_ip = @vcloud.vdcs.first.public_ips.first
-        @original_service = @vcloud.get_internet_services(@public_ip.href).body[:InternetService].first
-        @ip_data = { :id => @public_ip.id, :name => @public_ip.name, :href => @public_ip.href.to_s }
+        @original_service = @vcloud.get_internet_services(@mock_public_ip.internet_service_collection.href).body[:InternetService].first
+        @ip_data = { :id => @mock_public_ip.object_id, :name => @mock_public_ip.name, :href => @mock_public_ip.href.to_s }
         @service_data = { :name => @original_service[:Name], :protocol => @original_service[:Protocol],
                           :port => @original_service[:Port], :description => @original_service[:Description],
                           :enabled => @original_service[:Enabled], :redirect_url => @original_service[:RedirectURL],
@@ -18,7 +17,6 @@ if Fog.mocking?
       end
 
       context "with a valid Internet Service uri and valid data" do
-
         subject { @vcloud.configure_internet_service(@original_service[:Href], @service_data, @ip_data) }
 
         it_should_behave_like "all responses"
@@ -29,23 +27,23 @@ if Fog.mocking?
             @service_data[:redirect_url] = "http://google.com"
             @service_data[:port] = "80"
           end
+
           it "should change data" do
             @original_service[:Description].should == @mock_service[:description]
             @original_service[:RedirectURL].should == @mock_service[:redirect_url]
-            @original_service[:Port].should == @mock_service[:port]
+            @original_service[:Port].should == @mock_service[:port].to_s
             result = subject
             result.body[:Description].should == @service_data[:description]
             result.body[:RedirectURL].should == @service_data[:redirect_url]
             result.body[:Port].should        == @service_data[:port]
 
-            new_result = @vcloud.get_internet_services(@public_ip.href).body[:InternetService].first
+            new_result = @vcloud.get_internet_services(@mock_public_ip.internet_service_collection.href).body[:InternetService].first
 
             new_result[:Description].should == @service_data[:description]
             new_result[:RedirectURL].should == @service_data[:redirect_url]
             new_result[:Port].should        == @service_data[:port]
           end
         end
-
       end
 
       context "with an internet_services_uri that doesn't exist" do

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

@@ -7,44 +7,38 @@ if Fog.mocking?
     it { should respond_to :configure_node }
 
     describe "#configure_node" do
-      let(:original_node) { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first }
+      let(:original_node) { @vcloud.get_node(@mock_node.href).body }
       let(:node_data) { { :name => "TEST BOOM", :enabled => "false", :description => "TEST BOOM DESC" } }
 
       context "with a valid node service uri" do
 
-        subject { @vcloud.configure_node(@mock_node[:href],node_data) }
+        subject { @vcloud.configure_node(@mock_node.href,node_data) }
 
         it_should_behave_like "all responses"
 
         describe "#body" do
-          subject { @vcloud.configure_node(@mock_node[:href],node_data).body }
-
-          its(:Description) { should == node_data[:description] }
-          its(:Href) { should == @mock_node[:href] }
-          its(:Name) { should == node_data[:name] }
-          its(:Id) { should == @mock_node[:id] }
-          its(:Port) { should == @mock_node[:port] }
-          its(:Enabled) { should == node_data[:enabled] }
-          its(:IpAddress) { should == @mock_node[:ip_address] }
+          subject { @vcloud.configure_node(@mock_node.href,node_data).body }
+
+          #Stuff that shouldn't change
+          its(:Href) { should == @mock_node.href }
+          its(:Id) { should == @mock_node.object_id.to_s }
+          its(:Port) { should == @mock_node.port.to_s }
+          its(:IpAddress) { should == @mock_node.ip_address }
+
+          #Stuff that should change
+          it "should change the name" do
+            expect { subject }.to change { @vcloud.get_node(@mock_node.href).body[:Name] }.to(node_data[:name])
+          end
+
+          it "should change enabled" do
+            expect { subject }.to change { @vcloud.get_node(@mock_node.href).body[:Enabled] }.to(node_data[:enabled])
+          end
+
+          it "should change the description" do
+            expect { subject }.to change { @vcloud.get_node(@mock_node.href).body[:Description] }.to(node_data[:description])
+          end
         end
 
-        it "should change the name" do
-          original_node.name.should == @mock_node[:name]
-          subject
-          original_node.reload.name.should == node_data[:name]
-        end
-
-        it "should change enabled" do
-          original_node.enabled.should == @mock_node[:enabled]
-          subject
-          original_node.reload.enabled.should == node_data[:enabled]
-        end
-
-        it "should change the description" do
-          original_node.description.should == @mock_node[:description]
-          subject
-          original_node.reload.description.should == node_data[:description]
-        end
       end
 
       context "with a nodes uri that doesn't exist" do

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

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+shared_examples_for "a successful configure vapp" do
+  specify { after_vapp_data.should == new_vapp_data }
+
+  describe "#body" do
+    its(:body) { should == '' }
+  end
+
+  describe "#headers" do
+    its(:headers) { should include "Location" }
+  end
+end
+
+if Fog.mocking?
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :configure_vapp }
+
+    let(:original_vapp_data) { vapp_data.dup }
+    let(:vapp_data)          { @mock_vm.to_configure_vapp_hash }
+    let(:changed_vapp_data)  { {} }
+    let(:new_vapp_data)      { vapp_data.update(changed_vapp_data) }
+    let(:after_vapp_data)    { @mock_vm.to_configure_vapp_hash }
+
+    describe "#configure_vapp" do
+      context "with a valid vapp uri" do
+        before { original_vapp_data; subject }
+
+        subject { @vcloud.configure_vapp(@mock_vm.href, new_vapp_data) }
+
+        context "when changing nothing" do
+          it_should_behave_like "a successful configure vapp"
+        end
+
+        context "when changing CPUs" do
+          let(:changed_vapp_data) { { :cpus => @mock_vm.cpus * 2 } }
+
+          it_should_behave_like "a successful configure vapp"
+        end
+
+        context "when changing memory" do
+          let(:changed_vapp_data) { { :memory => @mock_vm.memory * 2 } }
+
+          it_should_behave_like "a successful configure vapp"
+        end
+
+        context "when removing a disk" do
+          let(:changed_vapp_data) { { :disks => original_vapp_data[:disks][0...1] } }
+
+          it_should_behave_like "a successful configure vapp"
+        end
+
+        context "when adding a disk" do
+          let(:changed_vapp_data) { { :disks => original_vapp_data[:disks] + [{ :number => "5", :size => 10 * 1024 * 1024, :resource => (10 * 1024 * 1024).to_s }] } }
+
+          it_should_behave_like "a successful configure vapp"
+        end
+      end
+
+      context "with an internet_services_uri that doesn't exist" do
+        subject { lambda { @vcloud.configure_vapp(URI.parse('https://www.fakey.c/piv8vc99'), new_vapp_data) } }
+
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
+    end
+  end
+else
+end
+