fog 0.3.16 → 0.3.17

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

@@ -9,8 +9,7 @@ if Fog.mocking?
     describe "#get_public_ip" do
       context "with a valid public_ip_uri" do
         before do
-          @mock_ip = @mock_vdc[:public_ips].first
-          @public_ip = @vcloud.get_public_ip( @mock_ip[:href] )
+          @public_ip = @vcloud.get_public_ip(@mock_public_ip.href)
         end
 
         subject { @public_ip }
@@ -21,9 +20,9 @@ if Fog.mocking?
         describe "#body" do
           subject { @public_ip.body }
 
-          its(:Name) { should == @mock_ip[:name] }
-          its(:Href) { should == @mock_ip[:href] }
-          its(:Id)   { should == @mock_ip[:id] }
+          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

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

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe "#get_public_ips" do
       context "with a valid public_ips_uri" do
-        before { @public_ips = @vcloud.get_public_ips(URI.parse(@mock_vdc[:href] + "/publicIps")) }
+        before { @public_ips = @vcloud.get_public_ips(@mock_public_ip_collection.href) }
         subject { @public_ips }
 
         it_should_behave_like "all responses"
@@ -22,16 +22,16 @@ if Fog.mocking?
           describe "[:PublicIPAddress]" do
             subject { @public_ips.body[:PublicIPAddress] }
 
-            it { should have(@mock_vdc[:public_ips].length).addresses }
+            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_vdc[:public_ips][idx] }
-                its(:Href) { should == public_ip[:href] }
-                its(:Id) { should == public_ip[:id] }
-                its(:Name) { should == public_ip[:name] }
+                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

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

@@ -8,11 +8,9 @@ if Fog.mocking?
 
     describe "#get_vapp" do
       context "with a valid vapp_uri" do
-        before { @vapp = @vcloud.get_vapp(vm_data[:href]) }
+        before { @vapp = @vcloud.get_vapp(@mock_vm.href) }
         subject { @vapp }
         let(:vapp_id) { @vapp.body[:href].split("/").last }
-        let(:vm_data) { @vcloud.mock_data[:organizations].first[:vdcs].first[:vms].first }
-        let(:vdc) { @vcloud.vdcs.first }
 
         it_should_behave_like "all responses"
         it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.vApp+xml" }
@@ -20,21 +18,26 @@ if Fog.mocking?
         describe "#body" do
           subject { @vapp.body }
 
-          specify { subject.keys.sort_by(&:to_s).should == [:Link, :NetworkConnectionSection, :OperatingSystemSection, :VirtualHardwareSection, :href, :name, :status, :type, :xmlns, :xmlns_xsd, :xmlns_xsi] }
+          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 == vm_data[:href] }
-          its(:name) { should == vm_data[:name] }
-          its(:status) { should == vm_data[:status].to_s }
-          its(:size) { (vm_data[:disks].inject(0) {|s, d| s += d[:size] } * 1024).to_s }
+          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 == vdc.href }
+            its(:href) { should == @mock_vdc.href }
           end
 
           describe "NetworkConnectionSection" do
@@ -45,7 +48,7 @@ if Fog.mocking?
             describe "NetworkConnection" do
               subject { @vapp.body[:NetworkConnectionSection][:NetworkConnection] }
 
-              its(:IpAddress) { should == vm_data[:ip] }
+              its(:IpAddress) { should == @mock_vm.ip }
             end
           end
 
@@ -64,20 +67,20 @@ if Fog.mocking?
             describe "Item" do
               subject { @vapp.body[:VirtualHardwareSection][:Item] }
 
-              it { should have(4).items }
+              it { should have(5).items }
 
-              specify { subject.map {|i| i[:ResourceType] }.sort.should == %w(3 4 6 17).sort }
+              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 == vm_data[:cpus].to_s }
+                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 == vm_data[:memory].to_s }
+                its(:VirtualQuantity) { should == @mock_vm.memory.to_s }
               end
 
               describe "SCSI controller" do
@@ -86,12 +89,26 @@ if Fog.mocking?
                 its(:Address) { should == "0" }
               end
 
-              describe "Hard Disk 1" do
-                subject { @vapp.body[:VirtualHardwareSection][:Item].detect {|i| i[:ResourceType] == "17" } }
+              describe "Hard Disks" do
+                subject { @vapp.body[:VirtualHardwareSection][:Item].find_all {|i| i[:ResourceType] == "17" } }
 
-                its(:AddressOnParent) { should == "0" }
-                its(:VirtualQuantity) { should == (vm_data[:disks].first[:size] * 1024).to_s }
-                its(:HostResource)    { should == (vm_data[:disks].first[:size] * 1024).to_s }
+                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

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

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe "#get_vdc" do
       context "with a valid vdc uri" do
-        before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc[:href])) }
+        before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc.href)) }
         subject { @vdc }
 
         it_should_behave_like "all responses"
@@ -21,11 +21,14 @@ if Fog.mocking?
 
           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], :Used => @mock_vdc[:storage][:used] } }
+          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] },
-                                             :Cpu => { :Units => "hz * 10^6", :Allocated => @mock_vdc[:cpu][:allocated] },
+                                             :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 }
@@ -35,49 +38,49 @@ if Fog.mocking?
             it { should have(4).attributes }
             its(:type) { should == "application/vnd.vmware.vcloud.catalog+xml" }
             its(:rel)  { should == "down" }
-            its(:href) { should == "#{@mock_vdc[:href]}/catalog" }
-            its(:name) { should == @mock_vdc[:name] }
+            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[:extension_href]}/publicIps"}
-            its(:name) { should == "Public IPs" }
+            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[:extension_href]}/internetServices"}
-            its(:name) { should == "Internet Services" }
+            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[:extension_href]}/firewallAcls"}
-            its(:name) { should == "Firewall Access List" }
+            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[:vms].length).vapps  }
+          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[:vms][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[:vms][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[:vms][2] }
+              it { should be_a_vapp_link_to @mock_vdc.virtual_machines[2] }
             end
           end
 
@@ -89,11 +92,11 @@ if Fog.mocking?
           describe "[:AvailableNetworks][:Network]" do
             context "[0]" do
               subject { @vdc.body[:AvailableNetworks][:Network][0] }
-              it { should be_a_network_link_to @mock_vdc[:networks][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] }
+              it { should be_a_network_link_to @mock_vdc.networks[1] }
             end
           end
         end

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

@@ -8,20 +8,24 @@ if Fog.mocking?
 
     describe "#instantiate_vapp_template" do
       let(:vdc) { @vcloud.vdcs.first }
+      let(:mock_vdc) { @mock_vdc }
+
       let(:catalog_item) { vdc.catalog.first }
-      let(:catalog_item_data) { @vcloud.catalog_item_and_vdc_from_catalog_item_uri(catalog_item.href).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],
+          :network_uri => @mock_network.href,
           :row => "test row",
           :group => "test group",
           :memory => 1024,
           :cpus => 2,
-          :vdc_uri => vdc.href
+          :vdc_uri => @mock_vdc.href
         }
       end
-      let(:added_mock_data) { @vcloud.vdc_from_uri(vdc.href)[:vms].last }
+
+      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) }
@@ -31,25 +35,30 @@ if Fog.mocking?
         it { should have_headers_denoting_a_content_type_of "application/xml" }
 
         it "updates the mock data properly" do
-          expect { template_instantiation }.to change { @vcloud.vdc_from_uri(vdc.href)[:vms].count }.by(1)
+          expect { subject }.to change { mock_vdc.virtual_machines.size }.by(1)
         end
 
         describe "added mock data" do
-          subject { template_instantiation; added_mock_data }
+          before  { template_instantiation }
+          subject { added_mock_data }
 
-          it { should include :id }
-          it { should include :href }
-          it { should include :disks }
-          it { should include :ip }
-          its(:status) { should == 2 }
+          it { should be_an_instance_of Fog::Vcloud::MockDataClasses::MockVirtualMachine }
 
-          its(:disks) { should == catalog_item_data[:disks] }
-
-          specify { subject.values_at(*new_vapp_data.keys).should == new_vapp_data.values }
+          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
-          subject { template_instantiation; vdc.servers.reload.detect {|s| s.href == added_mock_data[:href] }.reload }
+          before  { template_instantiation }
+          subject { vdc.servers.reload.detect {|s| s.href == added_mock_data.href }.reload }
 
           its(:name) { should == new_vapp_data[:name] }
         end
@@ -61,7 +70,7 @@ if Fog.mocking?
 
           it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
 
-          its(:href) { should =~ %r{/vapp/\d+$} }
+          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" }
@@ -76,7 +85,8 @@ if Fog.mocking?
 
             its(:rel)  { should == "up" }
             its(:type) { should == "application/vnd.vmware.vcloud.vdc+xml" }
-            its(:href) { should == vdc.href }
+            # WHAT
+            its(:href) { blah = vdc.href; should == blah }
           end
         end
       end

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

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '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
+

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

@@ -8,14 +8,13 @@ if Fog.mocking?
 
     describe :power_on, :type => :vcloud_request do
       context "with a valid vapp uri" do
-        let(:vm_data) { @vcloud.mock_data[:organizations].first[:vdcs].first[:vms].first }
-        before { vm_data[:status] = 2; @power_on = @vcloud.power_on(@vcloud.vdcs.first.servers.first.href + "/power/action/powerOn") }
+        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 { vm_data[:status].should == 4 }
+        specify { @mock_vm.status.should == 4 }
 
         describe :body do
           subject { @power_on.body }
@@ -25,7 +24,7 @@ if Fog.mocking?
       end
 
       context "with a vapp uri that doesn't exist" do
-        subject { lambda { @vcloud.get_network(URI.parse('https://www.fakey.com/api/v0.8/vapp/9999')) } }
+        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

data/spec/vcloud/vcloud_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'spec/vcloud/spec_helper.rb'
 
 if Fog.mocking?
   describe Fog::Vcloud, :type => :mock_vcloud_request do
@@ -12,7 +12,7 @@ if Fog.mocking?
 
     it { should have_at_least(1).supported_versions }
 
-    its(:default_organization_uri) { should == @mock_organization[:info][:href] }
+    its(:default_organization_uri) { should == @mock_organization.href }
 
   end
 end

data/tests/helpers/storage/directory_tests.rb

@@ -16,6 +16,14 @@ def directory_tests(connection, mocks_implemented = true)
       @directory.destroy
     end
 
+    tests("#public=(true)").succeeds do
+      @directory.public=(true)
+    end
+
+    tests("#respond_to?(:public_url)").succeeds do
+      @directory.respond_to?(:public_url)
+    end
+
   end
 
   tests('failure') do

data/tests/helpers/storage/file_tests.rb

@@ -20,6 +20,10 @@ def file_tests(connection, mocks_implemented = true)
       @file.destroy
     end
 
+    tests("#respond_to?(:public_url)").succeeds do
+      @directory.respond_to?(:public_url)
+    end
+
   end
 
   tests('failure') do