fog 0.2.0 → 0.2.1

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

@@ -1,63 +1,41 @@
-require "spec_helper"
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
-describe Fog::Vcloud, :type => :tmrk_ecloud_request do
-  subject { @vcloud }
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
 
-  it { should respond_to :get_network }
+    it { should respond_to :get_network }
 
-  describe :get_network, :type => :vcloud_request do
-    context "with a valid network uri" do
-      before { @network = @vcloud.get_network(URI.parse(@mock_network[:href])) }
-      subject { @network }
+    describe :get_network, :type => :vcloud_request do
+      context "with a valid network uri" do
+        before { @network = @vcloud.get_network( @mock_network[:href] ) }
+        subject { @network }
 
-      it_should_behave_like "all requests"
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
 
-      its(:headers) { should include "Content-Type" }
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudNetwork }
+        describe :body do
+          subject { @network.body }
 
-      describe :headers do
-        let(:header) { @network.headers["Content-Type"] }
-        specify { header.should == "application/vnd.vmware.vcloud.network+xml" }
-      end
-
-      describe :body do
-        subject { @network.body }
-
-        it_should_behave_like "it has a vcloud v0.8 xmlns"
-
-        its(:configuration) { should be_an_instance_of Struct::VcloudNetworkConfiguration }
-        its(:features)      { should be_an_instance_of Array }
-        its(:ips_link)      { should be_an_instance_of Struct::VcloudLink }
-        its(:href)          { should == URI.parse("https://fakey.com/api/v0.8/network/31") }
-        its(:type)          { should == "application/vnd.vmware.vcloud.network+xml" }
-        its(:name)          { should == @mock_network[:name] }
-
-        describe :configuration do
-          subject { @network.body.configuration }
+          it { should have(9).keys }
 
-          its(:gateway) { should == "1.2.3.1" }
-          its(:netmask) { should == "255.255.255.0" }
-        end
+          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
 
-        describe :ips_link do
-          subject { @network.body.ips_link }
-          its(:href) { should == URI.parse(@mock_network[:href] + "/ips") }
-          its(:rel)  { should == "down" }
-          its(:type) { should == "application/xml" }
-          its(:name) { should == "IP Addresses" }
-        end
+          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] } }
 
-        describe "FenceMode Feature" do
-          subject { @network.body.features.detect { |feature| feature.is_a?(Struct::VcloudNetworkFenceMode) } }
-          its(:mode) { should == "isolated" }
         end
-
       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"
+      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_public_ip_spec.rb

@@ -1,40 +1,39 @@
-require "spec_helper"
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
-describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
-  subject { @vcloud }
+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 }
+    it { should respond_to :get_public_ip }
 
-  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(URI.parse("#{@base_url}/extensions/publicIp/#{@mock_ip[:id]}"))
-      end
-
-      subject { @public_ip }
-
-      it_should_behave_like "all requests"
+    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] )
+        end
 
-      its(:headers) { should include "Content-Type" }
-      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.publicIp+xml" }
+        subject { @public_ip }
 
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudPublicIp }
+        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 }
+        describe "#body" do
+          subject { @public_ip.body }
 
-        its(:name) { should == @mock_ip[:name] }
-        its(:href) { should == URI.parse("#{@base_url}/extensions/publicIp/#{@mock_ip[:id]}") }
-        its(:id)   { should == @mock_ip[:id] }
+          its(:Name) { should == @mock_ip[:name] }
+          its(:Href) { should == @mock_ip[:href] }
+          its(:Id)   { should == @mock_ip[:id] }
 
+        end
       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')) } }
+      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"
+        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

@@ -1,44 +1,52 @@
-require "spec_helper"
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
-describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
-  subject { @vcloud }
+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 }
+    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(URI.parse(@mock_vdc[:href] + "/publicIps")) }
-      subject { @public_ips }
+    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")) }
+        subject { @public_ips }
 
-      it_should_behave_like "all requests"
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.tmrk.ecloud.publicIpsList+xml" }
 
-      its(:headers) { should include "Content-Type" }
-      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.publicIpsList+xml" }
+        describe "#body" do
+          subject { @public_ips.body }
 
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudList }
+          it { should have(1).item }
 
-      describe "#body" do
-        describe "#links" do
-          subject { @public_ips.body.links }
+          describe "[:PublicIPAddress]" do
+            subject { @public_ips.body[:PublicIPAddress] }
 
-          it { should have(3).ips }
+            it { should have(@mock_vdc[:public_ips].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] }
+              end
+
+            end
 
-          [0,1,2].each do |idx|
-            let(:ip) { subject[idx] }
-            let(:mock_ip) { @mock_vdc[:public_ips][idx] }
-            specify { ip.should be_an_instance_of Struct::TmrkEcloudPublicIp }
-            specify { ip.name.should == mock_ip[:name] }
-            specify { ip.id.should == mock_ip[:id] }
-            specify { ip.href.should == URI.parse("#{@base_url}/extensions/publicIp/#{mock_ip[:id]}") }
           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')) } }
+      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"
+        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

@@ -1,135 +1,110 @@
-require "spec_helper"
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
-describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
-  subject { @vcloud }
+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 }
+    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 }
+    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 requests"
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.vdc+xml" }
 
-      its(:headers) { should include "Content-Type" }
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudVdc }
+        describe "#body" do
+          subject { @vdc.body }
 
-      describe "#headers" do
-        let(:header) { @vdc.headers["Content-Type"] }
-        specify { header.should == "application/vnd.vmware.vcloud.vdc+xml" }
-      end
-
-      describe "#body" do
-        subject { @vdc.body }
+          it { should have(11).items }
 
-        it_should_behave_like "it has a vcloud v0.8 xmlns"
-        it_should_behave_like "a tmrk vdc"
+          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
 
-        it { should respond_to :storage_capacity }
-        it { should respond_to :cpu_capacity }
-        it { should respond_to :memory_capacity }
-        it { should respond_to :deployed_vm_quota }
-        it { should respond_to :instantiated_vm_quota }
+          its(:Description) { should == "" }
+          its(:StorageCapacity) { should == {:Units => "bytes * 10^9", :Allocated => @mock_vdc[:storage][:allocated], :Used => @mock_vdc[:storage][:used] } }
+          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] },
+                                             :DeployedVmsQuota => { :Limit => "-1", :Used => "-1" } } }
 
-        its(:name) { should == @mock_vdc[:name] }
-        its(:href) { should == URI.parse(@mock_vdc[:href]) }
-        its(:description) { should == '' }
+          its(:Link) { should have(4).links }
 
-        describe "#links" do
-          subject { @vdc.body.links }
-          it { should have(4).links }
-
-          describe "[0]" do
-            subject { @vdc.body.links[0] }
-            it_should_behave_like "a vdc catalog link"
+          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[:href]}/catalog" }
+            its(:name) { should == @mock_vdc[:name] }
           end
-
-          describe "[1]" do
-            subject { @vdc.body.links[1] }
-
-            it_should_behave_like "all rel=down vcloud links"
-            it_should_behave_like "all tmrk ecloud publicIpList links"
-
-            specify { subject.href.should == URI.parse(@mock_vdc[:href].sub('/vdc','/extensions/vdc') + "/publicIps") }
+          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" }
           end
-
-          describe "[2]" do
-            subject { @vdc.body.links[2] }
-
-            it_should_behave_like "all rel=down vcloud links"
-            it_should_behave_like "all tmrk ecloud internetServicesList links"
-
-            specify { subject.href.should == URI.parse(@mock_vdc[:href] + "/internetServices") }
+          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" }
           end
-
-          describe "[3]" do
-            subject { @vdc.body.links[3] }
-
-            it_should_behave_like "all rel=down vcloud links"
-            it_should_behave_like "all tmrk ecloud firewallAclList links"
-
-            specify { subject.href.should == URI.parse(@mock_vdc[:href].sub('/vdc','/extensions/vdc') + "/firewallAcls") }
+          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" }
           end
-        end
 
-        describe "#networks" do
-          subject { @vdc.body.networks }
-          it_should_behave_like "the mocked tmrk network links"
-        end
-
-        describe "#storage_capacity" do
-          subject { @vdc.body.storage_capacity }
-
-          its(:units) { should == "bytes * 10^9" }
-          its(:allocated) { should == @mock_vdc[:storage][:allocated] }
-          its(:used) { should == @mock_vdc[:storage][:used] }
-        end
+          let(:resource_entities) { subject[:ResourceEntities][:ResourceEntity] }
+          specify { resource_entities.should have(@mock_vdc[:vms].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] }
+            end
+            context "[1]" do
+              subject { @vdc.body[:ResourceEntities][:ResourceEntity][1] }
+              it { should be_a_vapp_link_to @mock_vdc[:vms][1] }
+            end
+            context "[2]" do
+              subject { @vdc.body[:ResourceEntities][:ResourceEntity][2] }
+              it { should be_a_vapp_link_to @mock_vdc[:vms][2] }
+            end
+          end
 
-        describe "#cpu_capacity" do
-          subject { @vdc.body.cpu_capacity }
-          its(:units) { should == "hz * 10^6" }
-          its(:allocated) { should == @mock_vdc[:cpu][:allocated] }
-          its(:used) { should == nil }
-          its(:limit) { should == nil }
-        end
+          its(:name)            { should == @mock_vdc[:name] }
 
-        describe "#memory_capacity" do
-          subject { @vdc.body.memory_capacity }
-          it { should be_an_instance_of Struct::VcloudXCapacity }
-          its(:units) { should == "bytes * 2^20" }
-          its(:allocated) { should == @mock_vdc[:memory][:allocated] }
-          its(:used) { should == nil }
-          its(:limit) { should == nil }
-        end
+          let(:available_networks) { subject[:AvailableNetworks][:Network] }
+          specify { available_networks.should have(2).networks }
 
-        describe "#deployed_vm_quota" do
-          subject { @vdc.body.deployed_vm_quota }
-          it { should be_an_instance_of Struct::VcloudXCapacity }
-          its(:limit) { should == -1 }
-          its(:used) { should == -1 }
-          its(:units) { should == nil }
-          its(:allocated) { should == nil }
-        end
-        describe "#instantiated_vm_quota" do
-          subject { @vdc.body.instantiated_vm_quota }
-          it { should be_an_instance_of Struct::VcloudXCapacity }
-          its(:limit) { should == -1 }
-          its(:used) { should == -1 }
-          its(:units) { should == nil }
-          its(:allocated) { should == nil }
-        end
-        describe "#resource_entities" do
-          subject { @vdc.body.resource_entities }
-          it_should_behave_like "the mocked tmrk resource entity links"
+          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
-    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')) } }
+      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"
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
     end
   end
+else
 end