fog 0.2.0 → 0.2.1

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

@@ -1,57 +1,60 @@
-require "spec_helper"
-
-describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
-  subject { @vcloud }
-
-  it { should respond_to :add_internet_service }
-
-  describe "#add_internet_service" do
-    before do
-      @public_ip = @vcloud.vdcs[0].public_ips[0]
-      @new_service_data = { :name => "Test Service",
-                            :protocol => "HTTP",
-                            :port => "80",
-                            :enabled => "true",
-                            :description => "this is a test" }
-    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.links.should have(2).links
+require File.join(File.dirname(__FILE__), '..', '..', '..', '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 :add_internet_service }
+
+    describe "#add_internet_service" do
+      before do
+        @public_ip = @vcloud.vdcs[0].public_ips[0]
+        @new_service_data = { :name => "Test Service",
+                              :protocol => "HTTP",
+                              :port => "80",
+                              :enabled => "true",
+                              :description => "this is a test",
+                              :redirect_url => "" }
       end
 
-      subject { @vcloud.add_internet_service(@public_ip.href.to_s + "/internetServices", @new_service_data ) }
+      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
 
-      it "has the right number of Internet Services after" do
-        subject
-        @vcloud.get_internet_services(@public_ip.href).body.links.should have(3).links
-      end
+        subject { @vcloud.add_internet_service(@public_ip.href.to_s + "/internetServices", @new_service_data ) }
 
-      it_should_behave_like "all requests"
+        it "has the right number of Internet Services after" do
+          subject
+          @vcloud.get_internet_services(@public_ip.href).body[:InternetService].should have(3).services
+        end
 
-      let(:body) { subject.body }
+        it_should_behave_like "all responses"
 
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudInternetService }
-      specify { body.href.to_s.should == Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href( { :id => 372 } ) }
-      specify { body.name.should == "Test Service" }
-      specify { body.protocol.should == "HTTP" }
-      specify { body.enabled.should == true }
-      specify { body.description.should == "this is a test" }
+        let(:body) { subject.body }
 
-      let(:public_ip) { subject.body.public_ip }
-      specify { public_ip.should be_an_instance_of Struct::TmrkEcloudPublicIp }
-      specify { public_ip.name.should == @public_ip.name }
-      specify { public_ip.id.should == @public_ip.id }
-      specify { public_ip.type.should == "application/vnd.tmrk.ecloud.publicIp+xml" }
+        its(:body) { should be_an_instance_of Hash }
+        specify { body[:Href].should == Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href( { :id => 372 } ) }
+        specify { body[:Name].should == "Test Service" }
+        specify { body[:Protocol].should == "HTTP" }
+        specify { body[:Enabled].should == "true" }
+        specify { body[:Description].should == "this is a test" }
 
-    end
+        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 }
 
-    context "with a public_ips_uri that doesn't exist" do
-      subject { lambda { @vcloud.add_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @new_service_data ) } }
+      end
 
-      it_should_behave_like "a request for a resource that doesn't exist"
+      context "with a public_ips_uri that doesn't exist" do
+        subject { lambda { @vcloud.add_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @new_service_data ) } }
+
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
     end
   end
+else
 end
 

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

@@ -1,44 +1,49 @@
-require "spec_helper"
-
-describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
-  subject { @vcloud }
-
-  it { should respond_to :configure_internet_service }
-
-  describe "#configure_internet_service" do
-    before do
-      @public_ip = @vcloud.vdcs[0].public_ips[0]
-      @original_service = @vcloud.get_internet_services(@public_ip.href).body.links.first
-      @service_data = {}
-      @original_service.each_pair { |sym, data| @service_data[sym] = data }
-      @ip_data = { :id => @public_ip.id, :name => @public_ip.name, :href => @public_ip.href.to_s }
-    end
+require File.join(File.dirname(__FILE__), '..', '..', '..', '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 :configure_internet_service }
+
+    describe "#configure_internet_service" do
+      before do
+        @public_ip = @vcloud.vdcs[0].public_ips[0]
+        @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 }
+        @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],
+                          :id => @original_service[:Id], :href => @original_service[:Href], :timeout => @original_service[:Timeout] }
+      end
 
-    context "with a valid Internet Service uri and valid data" do
+      context "with a valid Internet Service uri and valid data" do
 
-      subject { @vcloud.configure_internet_service(@original_service.href, @service_data, @ip_data) }
+        subject { @vcloud.configure_internet_service(@original_service[:Href], @service_data, @ip_data) }
 
-      it_should_behave_like "all requests"
+        it_should_behave_like "all responses"
 
-      context "with some changed data" do
-        before do
-          @service_data[:description] = "TEST BOOM"
+        context "with some changed data" do
+          before do
+            @service_data[:description] = "TEST BOOM"
+          end
+          it "should change data" do
+            @original_service[:Description].should == "Web Servers"
+            result = subject
+            result.body[:Description].should == "TEST BOOM"
+            @vcloud.get_internet_services(@public_ip.href).body[:InternetService].first[:Description].should == "TEST BOOM"
+          end
         end
-        it "should change data" do
-          @original_service.description.should == "Web Servers"
-          result = subject
-          result.body.description.should == "TEST BOOM"
-          @vcloud.get_internet_services(@public_ip.href).body.links.first.description.should == "TEST BOOM"
-        end
-      end
 
-    end
+      end
 
-    context "with an internet_services_uri that doesn't exist" do
-      subject { lambda { @vcloud.configure_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @service_data, @ip_data ) } }
+      context "with an internet_services_uri that doesn't exist" do
+        subject { lambda { @vcloud.configure_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @service_data, @ip_data ) } }
 
-      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/delete_internet_service_spec.rb

@@ -1,34 +1,37 @@
-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 :delete_internet_service }
+    #it { should respond_to :delete_internet_service }
 
-  describe "#delete_internet_service" do
-    before do
-      @public_ip = @vcloud.vdcs[0].public_ips[0]
-      @before_services = @vcloud.get_internet_services(@public_ip.href)
-    end
+    #describe "#delete_internet_service" do
+    #  before do
+    #    @public_ip = @vcloud.vdcs[0].public_ips[0]
+    #    @before_services = @vcloud.get_internet_services(@public_ip.href)
+    #  end
 
-    context "with a valid internet service uri" do
-      subject { @vcloud.delete_internet_service(@before_services.body.links[0].href) }
+    #  context "with a valid internet service uri" do
+    #    subject { @vcloud.delete_internet_service(@before_services.body.tap{|o| pp o}.links[0].href) }
+    #
+    #    specify { @before_services.body.links.should have(2).links }
 
-      specify { @before_services.body.links.should have(2).links }
+    #    it "has the right number of Internet Services after" do
+    #      subject
+    #      after_services = @vcloud.get_internet_services(@public_ip.href)
+    #      after_services.body.links.should have(1).link
+    #    end
 
-      it "has the right number of Internet Services after" do
-        subject
-        after_services = @vcloud.get_internet_services(@public_ip.href)
-        after_services.body.links.should have(1).link
-      end
+    #  end
 
-    end
+    #  context "with a public_ips_uri that doesn't exist" do
+    #    subject { lambda { @vcloud.delete_internet_service(URI.parse('https://www.fakey.c/piv8vc99')) } }
 
-    context "with a public_ips_uri that doesn't exist" do
-      subject { lambda { @vcloud.delete_internet_service(URI.parse('https://www.fakey.c/piv8vc99')) } }
-
-      it_should_behave_like "a request for a resource that doesn't exist"
-    end
+    #    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_internet_services_spec.rb

@@ -1,57 +1,65 @@
-require "spec_helper"
-
-describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
-  subject { @vcloud }
-
-  it { should respond_to :get_internet_services }
-
-  describe "#get_internet_services" do
-    context "with a valid VDC internet_services_uri" do
-      before { @services = @vcloud.get_internet_services(URI.parse(@mock_vdc[:href] + "/internetServices")) }
-      subject { @services }
-
-      it_should_behave_like "all requests"
-
-      its(:headers) { should include "Content-Type" }
-      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.internetServicesList+xml" }
-
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudList }
-
-      describe "#body" do
-        describe "#links" do
-          subject { @services.body.links }
-
-          it { should have(4).services }
-
-          [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 Struct::TmrkEcloudInternetService }
-            specify { service.name.should == mock_service[:name] }
-            specify { service.id.should == mock_service[:id] }
-            specify { service.href.should == URI.parse(Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(mock_service)) }
-            specify { service.type.should == "application/vnd.tmrk.ecloud.internetService+xml" }
-            specify { service.public_ip.should be_an_instance_of Struct::TmrkEcloudPublicIp }
-            specify { service.public_ip.name.should == mock_ip[:name] }
-            specify { service.public_ip.id.should == mock_ip[:id] }
-            specify { service.public_ip.type.should == "application/vnd.tmrk.ecloud.publicIp+xml" }
-            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.url_send_string.should == nil }
-            specify { service.http_header.should == nil }
+require File.join(File.dirname(__FILE__), '..', '..', '..', '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_internet_services }
+
+    describe "#get_internet_services" do
+      context "with a valid VDC internet_services_uri" do
+        before { @services = @vcloud.get_internet_services( @mock_vdc[:href] + "/internetServices" ) }
+        subject { @services }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.tmrk.ecloud.internetServicesList+xml" }
+
+        describe "#body" do
+          subject { @services.body }
+
+          it { should have(3).items }
+
+          its(:xmlns) { should == "urn:tmrk:eCloudExtensions-2.3" }
+          its(:xmlns_i) { should == "http://www.w3.org/2001/XMLSchema-instance" }
+
+          context "[:InternetService]" do
+            subject { @services.body[:InternetService] }
+
+            it { should have(4).items }
+
+            [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 == "" }
+              specify { service[:Monitor].should == "" }
+            end
           end
         end
       end
-    end
 
-    context "with a public_ips_uri that doesn't exist" do
-      subject { lambda { @vcloud.get_internet_services(URI.parse('https://www.fakey.c/piv8vc99')) } }
+      context "with a public_ips_uri that doesn't exist" do
+        subject { lambda { @vcloud.get_internet_services(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_network_ip_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', '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_ip }
+
+    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 )
+        end
+
+        subject { @ip }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.tmrk.ecloud.ip+xml" }
+
+        describe "#body" do
+          subject { @ip.body }
+
+          its(:Name) { should == @mock_ip }
+          its(:Href) { should == @mock_ip_href }
+          its(:Id)   { should == @mock_ip.gsub('.','') }
+
+        end
+      end
+
+      context "with an ip_uri that doesn't exist" do
+        subject { lambda { @vcloud.get_network_ip('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_network_ips_spec.rb

@@ -1,54 +1,59 @@
-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_network_ips }
+    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(URI.parse(@mock_network[:href] + "/ips")) }
-      subject { @ips }
+    describe "#get_network_ips" do
+      context "with a valid VDC network ips_uri" do
+        before { @ips = @vcloud.get_network_ips( @mock_network[:href] + "/ips" ) }
+        subject { @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.ipAddressesList+xml" }
 
-      its(:headers) { should include "Content-Type" }
-      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.ipAddressesList+xml" }
+        describe "#body" do
+          subject { @ips.body }
 
-      its(:body) { should be_an_instance_of Struct::TmrkEcloudNetworkIps }
+          it { should have(1).item }
 
-      describe "#body" do
-        describe "#addresses" do
-          subject { @ips.body.addresses }
+          context "[:IpAddress]" do
+            subject { @ips.body[:IpAddress] }
 
-          it { should have(252).addresses }
-
-          describe "one we know is assigned" do
-            let(:address) { subject[0] }
-
-            specify { address.status.should == "Assigned" }
-            specify { address.server.should == "Broom 1" }
-            specify { address.name.should == "1.2.3.3" }
+            # 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
 
-          describe "one we know is not assigned" do
-            let(:address) { subject[100] }
-
-            specify { address.status.should == "Available" }
-            specify { address.server.should == nil }
-            specify { address.name.should == "1.2.3.103" }
-
+          context "one we know is assigned" do
+            let(:address) { @ips.body[:IpAddress][0] }
+            specify { address.should have(5).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 assigned" do
+            let(:address) { @ips.body[:IpAddress][100] }
+            specify { address.should have(4).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
-    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')) } }
+      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"
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
     end
   end
+else
 end