fog 0.2.6 → 0.2.7

data/fog.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'fog'
-  s.version           = '0.2.6'
-  s.date              = '2010-06-29'
+  s.version           = '0.2.7'
+  s.date              = '2010-06-30'
   s.rubyforge_project = 'fog'
 
   ## Make sure your summary is short. The description may be as long
@@ -528,17 +528,24 @@ Gem::Specification.new do |s|
     spec/vcloud/terremark/ecloud/models/ips_spec.rb
     spec/vcloud/terremark/ecloud/models/network_spec.rb
     spec/vcloud/terremark/ecloud/models/networks_spec.rb
+    spec/vcloud/terremark/ecloud/models/node_spec.rb
+    spec/vcloud/terremark/ecloud/models/nodes_spec.rb
     spec/vcloud/terremark/ecloud/models/public_ip_spec.rb
     spec/vcloud/terremark/ecloud/models/public_ips_spec.rb
     spec/vcloud/terremark/ecloud/models/vdc_spec.rb
     spec/vcloud/terremark/ecloud/models/vdcs_spec.rb
     spec/vcloud/terremark/ecloud/requests/add_internet_service_spec.rb
+    spec/vcloud/terremark/ecloud/requests/add_node_spec.rb
     spec/vcloud/terremark/ecloud/requests/configure_internet_service_spec.rb
+    spec/vcloud/terremark/ecloud/requests/configure_node_spec.rb
     spec/vcloud/terremark/ecloud/requests/delete_internet_service_spec.rb
+    spec/vcloud/terremark/ecloud/requests/delete_node_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_internet_services_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_network_ip_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_network_ips_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_network_spec.rb
+    spec/vcloud/terremark/ecloud/requests/get_node_spec.rb
+    spec/vcloud/terremark/ecloud/requests/get_nodes_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_public_ip_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_public_ips_spec.rb
     spec/vcloud/terremark/ecloud/requests/get_vdc_spec.rb

data/lib/fog.rb

@@ -39,7 +39,7 @@ require 'fog/vcloud'
 module Fog
 
   unless const_defined?(:VERSION)
-    VERSION = '0.2.6'
+    VERSION = '0.2.7'
   end
 
   module Mock

data/lib/fog/vcloud.rb

@@ -353,11 +353,15 @@ module Fog
         response = Excon::Response.new
 
         #Parse the response body into a hash
-        document = Fog::ToHashDocument.new
-        parser = Nokogiri::XML::SAX::PushParser.new(document)
-        parser << mock_data
-        parser.finish
-        response.body = document.body
+        if mock_data.empty?
+          response.body = mock_data
+        else
+          document = Fog::ToHashDocument.new
+          parser = Nokogiri::XML::SAX::PushParser.new(document)
+          parser << mock_data
+          parser.finish
+          response.body = document.body
+        end
 
         response.status = status
         response.headers = mock_headers

data/lib/fog/vcloud/model.rb

@@ -6,8 +6,9 @@ module Fog
       alias_method :loaded?, :loaded
 
       def reload
-        super
+        instance = super
         @loaded = true
+        instance
       end
 
       def load_unless_loaded!

data/lib/fog/vcloud/terremark/ecloud.rb

@@ -86,11 +86,15 @@ module Fog
                       :services => [
                         { :id => "71", :href => extension_url + "/internetService/71", :port => "80", :protocol => 'HTTP', :enabled => "true",
                           :timeout => "2", :name => 'Web Site', :description => 'Web Servers', :redirect_url => 'http://fakey.com',
-                          :nodes => [ {:ip => "1.2.3.5", :name => "Test Node 1", :port => "80", :enabled => "true", :description => "web 1" }
+                          :nodes => [ {:id => "81", :href => extension_url + "/nodeService/81", :ip_address => "1.2.3.5",
+                                       :name => "Test Node 1", :port => "80", :enabled => "true", :description => "web 1" },
+                                      {:id => "82", :href => extension_url + "/nodeService/82", :ip_address => "1.2.3.6",
+                                       :name => "Test Node 2", :port => "80", :enabled => "true", :description => "web 2" },
                                     ] },
                         { :id => "72", :href => extension_url + "/internetService/72", :port => "7000", :protocol => 'HTTP', :enabled => "true",
                           :timeout => "2", :name => 'An SSH Map', :description => 'SSH 1', :redirect_url => '',
-                          :nodes => [ {:ip => "1.2.3.5", :name => "SSH", :port => "22", :enabled => "true", :description => "web ssh" } 
+                          :nodes => [ {:id => "83", :href => extension_url + "/nodeService/83", :ip_address => "1.2.3.5",
+                                       :name => "SSH", :port => "22", :enabled => "true", :description => "web ssh" } 
                                     ] }
                       ]
                     },
@@ -149,6 +153,30 @@ module Fog
             { :xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" }
           end
 
+          def mock_ip_from_service_url(uri)
+            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |pip| pip[:services].detect { |service| service[:href] == uri } }
+          end
+
+          def mock_ip_and_service_from_service_url(uri)
+            if ip = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.compact.detect { |pip| pip[:services].detect { |service| service[:href] == uri } }
+              if service = ip[:services].detect { |service| service[:href] == uri }
+                [ip, service]
+              else
+                [ip, nil]
+              end
+            else
+              [nil, nil]
+            end
+          end
+
+          def mock_node_from_url(uri)
+            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.map { |pip| pip[:services] }.flatten.map { |service| service[:nodes] }.flatten.detect { |node| node[:href] == uri }
+          end
+
+          def mock_service_from_node_url(uri)
+            mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.map { |pip| pip[:services] }.flatten.map { |service| service }.detect {|service| service[:nodes].map { |node| node[:href] }.include?(uri) }
+          end
+
           def mock_data
             Fog::Vcloud::Terremark::Ecloud::Mock.data
           end

data/lib/fog/vcloud/terremark/ecloud/requests/add_internet_service.rb

@@ -66,25 +66,9 @@ module Fog
             internet_services_uri = ensure_unparsed(internet_services_uri)
 
             if ip = ip_from_uri(internet_services_uri)
-              new_service = service_data.merge!( { :id => rand(1000), :timeout => 2 } )
+              new_service = service_data.merge!( { :href => Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href( { :id =>  rand(1000) } ), :timeout => 2 } )
               ip[:services] << new_service
-              builder = Builder::XmlMarkup.new
-              xml = builder.InternetService(:xmlns => "urn:tmrk:eCloudExtensions-2.0",
-                                            :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
-                builder.Id(new_service[:id])
-                builder.Href(Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(new_service))
-                builder.Name(new_service[:name])
-                builder.PublicIpAddress {
-                  builder.Id(ip[:id])
-                  builder.Href(Fog::Vcloud::Terremark::Ecloud::Mock.public_ip_href(ip))
-                  builder.Name(ip[:name])
-                }
-                builder.Protocol(new_service[:protocol])
-                builder.Port(new_service[:port])
-                builder.Enabled(new_service[:enabled])
-                builder.Description(new_service[:description])
-                builder.Timeout(new_service[:timeout])
-              }
+              xml = generate_internet_service_response( service_data, ip )
 
               mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
             else

data/lib/fog/vcloud/terremark/ecloud/requests/add_node.rb

@@ -46,7 +46,17 @@ module Fog
         module Mock
 
           def add_node(nodes_uri, node_data)
-            Fog::Mock.not_implemented
+            validate_node_data(node_data)
+            nodes_uri = ensure_unparsed(nodes_uri)
+            service_uri = nodes_uri.gsub('/nodeServices','')
+            ip, service = mock_ip_and_service_from_service_url(service_uri)
+            if ip and service
+              id = rand(1000)
+              service[:nodes] << node_data.merge!( :id => id.to_s, :href => Fog::Vcloud::Terremark::Ecloud::Mock.extension_url + "/nodeService/#{id}" )
+              mock_it 200, mock_node_service_response(node_data, ecloud_xmlns), { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
           end
         end
       end

data/lib/fog/vcloud/terremark/ecloud/requests/configure_internet_service.rb

@@ -4,7 +4,7 @@ module Fog
       module Ecloud
         module Real
 
-          def generate_configure_internet_service_response(service_data,ip_address_data)
+          def generate_internet_service_response(service_data,ip_address_data)
             builder = Builder::XmlMarkup.new
             builder.InternetService(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
                                     :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
@@ -38,7 +38,7 @@ module Fog
             validate_public_ip_address_data(ip_address_data)
 
             request(
-              :body     => generate_configure_internet_service_response(service_data, ip_address_data),
+              :body     => generate_internet_service_response(service_data, ip_address_data),
               :expects  => 200,
               :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
               :method   => 'PUT',
@@ -67,7 +67,7 @@ module Fog
             if ip = ip_from_uri(ip_address_data[:href])
               if service = ip[:services].detect { |service| service[:id] == internet_service_uri.split('/')[-1] }
                 ip[:services][ip[:services].index(service)] = service_data
-                xml = generate_configure_internet_service_response(service_data, ip)
+                xml = generate_internet_service_response(service_data, ip)
               end
             end
 

data/lib/fog/vcloud/terremark/ecloud/requests/configure_node.rb

@@ -34,7 +34,18 @@ module Fog
         module Mock
 
           def configure_node(node_uri, node_data)
-            Fog::Mock.not_implemented
+            node_uri = ensure_unparsed(node_uri)
+
+            validate_node_data(node_data, true)
+
+            if node = mock_node_from_url(node_uri)
+              node[:name] = node_data[:name]
+              node[:enabled] = node_data[:enabled]
+              node[:description] = node_data[:description]
+              mock_it 200, mock_node_service_response(node, ecloud_xmlns), { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
           end
         end
       end

data/lib/fog/vcloud/terremark/ecloud/requests/delete_internet_service.rb

@@ -10,7 +10,20 @@ module Fog
         module Mock
 
           def delete_internet_service(service_uri)
-            Fog::Mock.not_implemented
+
+            deleted = false
+            if ip = mock_ip_from_service_url(service_uri)
+              if service = ip[:services].detect { |service| service[:href] == service_uri }
+                ip[:services].delete(service)
+                deleted = true
+              end
+            end
+
+            if deleted
+              mock_it 200, '', { }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
           end
         end
       end

data/lib/fog/vcloud/terremark/ecloud/requests/delete_node.rb

@@ -10,7 +10,16 @@ module Fog
         module Mock
 
           def delete_node(node_uri)
-            Fog::Mock.not_implemented
+            node_uri = ensure_unparsed(node_uri)
+
+            node = mock_node_from_url(node_uri)
+            service = mock_service_from_node_url(node_uri)
+            if node and service
+              service[:nodes].delete(node)
+              mock_it 200, '', {}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
           end
         end
       end

data/lib/fog/vcloud/terremark/ecloud/requests/get_node.rb

@@ -8,8 +8,35 @@ module Fog
         end
 
         module Mock
+
+          #
+          # Based on http://support.theenterprisecloud.com/kb/default.asp?id=641&Lang=1&SID=
+          #
+          #
+          #
+          def mock_node_service_response(node, xmlns)
+            xml = Builder::XmlMarkup.new
+            xml.NodeService(xmlns) {
+              xml.Id(node[:id])
+              xml.Href(node[:href])
+              xml.Name(node[:name])
+              xml.IpAddress(node[:ip_address])
+              xml.Port(node[:port])
+              xml.Enabled(node[:enabled])
+              xml.Description(node[:description])
+            }
+          end
+
           def get_node(node_uri)
-            Fog::Mock.not_implemented
+
+            node_uri = ensure_unparsed(node_uri)
+
+            if node = mock_node_from_url(node_uri)
+              xml = Builder::XmlMarkup.new
+              mock_it 200, mock_node_service_response(node, ecloud_xmlns), { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
           end
         end
       end

data/lib/fog/vcloud/terremark/ecloud/requests/get_nodes.rb

@@ -8,8 +8,34 @@ module Fog
         end
 
         module Mock
+
+          #
+          # Based off of:
+          # http://support.theenterprisecloud.com/kb/default.asp?id=637&Lang=1&SID=
+          #
           def get_nodes(nodes_uri)
-            Fog::Mock.not_implemented
+            nodes_uri = ensure_unparsed(nodes_uri)
+            service_uri = nodes_uri.gsub('/nodeServices','')
+            ip, service = mock_ip_and_service_from_service_url(service_uri)
+            if ip and service
+              xml = Builder::XmlMarkup.new
+              mock_it 200,
+                xml.NodeServices(ecloud_xmlns) {
+                  service[:nodes].each do |node|
+                    xml.NodeService {
+                      xml.Id(node[:id])
+                      xml.Href(node[:href])
+                      xml.Name(node[:name])
+                      xml.IpAddress(node[:ip_address])
+                      xml.Port(node[:port])
+                      xml.Enabled(node[:enabled])
+                      xml.Description(node[:description])
+                    }
+                  end
+                }, { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
           end
         end
       end

data/spec/vcloud/spec_helper.rb

@@ -28,6 +28,7 @@ Fog.mock! if ENV['FOG_MOCK']
 require "#{current_directory}/../../lib/fog/vcloud/bin"
 
 shared_examples_for "all responses" do
+  it { should be_an_instance_of Excon::Response }
   it { should respond_to :body }
   it { should respond_to :headers }
   it { should have_at_least(1).body }
@@ -36,6 +37,13 @@ shared_examples_for "all responses" do
   its(:headers) { should be_an_instance_of Hash }
 end
 
+shared_examples_for "all delete responses" do
+  it { should be_an_instance_of Excon::Response }
+  it { should respond_to :body }
+  it { should respond_to :headers }
+  its(:headers) { should be_an_instance_of Hash }
+end
+
 shared_examples_for "it has a Content-Type header" do
   its(:headers) { should include "Content-Type" }
 end
@@ -194,6 +202,18 @@ Spec::Example::ExampleGroupFactory.register(:vcloud_request, Class.new(Spec::Exa
 Spec::Example::ExampleGroupFactory.register(:tmrk_ecloud_request, Class.new(Spec::Example::ExampleGroup))
 Spec::Example::ExampleGroupFactory.register(:tmrk_vcloud_request, Class.new(Spec::Example::ExampleGroup))
 
+def setup_ecloud_mock_data
+    @base_url = Fog::Vcloud::Terremark::Ecloud::Mock.base_url
+    @mock_data = Fog::Vcloud::Terremark::Ecloud::Mock.data
+    @mock_version = @mock_data[:versions].first
+    @mock_organization = @mock_data[:organizations].first
+    @mock_vdc = @mock_organization[:vdcs].first
+    @mock_public_ip = @mock_vdc[:public_ips].first
+    @mock_service = @mock_public_ip[:services].first
+    @mock_node = @mock_service[:nodes].first
+    @mock_network = @mock_vdc[:networks].first
+end
+
 Spec::Runner.configure do |config|
   config.after(:all) do
     Fog::Vcloud::Mock.data_reset
@@ -221,32 +241,15 @@ Spec::Runner.configure do |config|
     @vcloud = Fog::Vcloud.new(:username => "", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   end
   config.before(:each, :type => :mock_tmrk_ecloud_request) do
-    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
-  end
-  config.before(:all, :type => :mock_tmrk_ecloud_request) do
-    @base_url = Fog::Vcloud::Terremark::Ecloud::Mock.base_url
-    @mock_data = Fog::Vcloud::Terremark::Ecloud::Mock.data
-    @mock_version = @mock_data[:versions].first
-    @mock_organization = @mock_data[:organizations].first
-    @mock_vdc = @mock_organization[:vdcs].first
-    @mock_public_ip = @mock_vdc[:public_ips].first
-    @mock_service = @mock_public_ip[:services].first
-    @mock_network = @mock_vdc[:networks].first
-  end
-  config.after(:all, :type => :mock_tmrk_ecloud_request) do
+    Fog::Vcloud::Mock.data_reset
     Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
-  end
-  config.before(:all, :type => :mock_tmrk_ecloud_model) do
-    @base_url = Fog::Vcloud::Terremark::Ecloud::Mock.base_url
-    @mock_data = Fog::Vcloud::Terremark::Ecloud::Mock.data
-    @mock_version = @mock_data[:versions].first
-    @mock_organization = @mock_data[:organizations].first
-    @mock_vdc = @mock_organization[:vdcs].first
-    @mock_public_ip = @mock_vdc[:public_ips].first
-    @mock_service = @mock_public_ip[:services].first
-    @mock_network = @mock_vdc[:networks].first
+    setup_ecloud_mock_data
+    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
   end
   config.before(:each, :type => :mock_tmrk_ecloud_model) do
+    Fog::Vcloud::Mock.data_reset
+    Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
+    setup_ecloud_mock_data
     @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
   end
 end

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

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Node", :type => :mock_tmrk_ecloud_model do
+
+    subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first }
+
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::Node }
+
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:href, :ip_address, :description, :name, :port, :enabled, :id] }
+    end
+
+    context "with no uri" do
+
+      subject { Fog::Vcloud::Terremark::Ecloud::Node.new() }
+      it { should have_all_attributes_be_nil }
+
+    end
+
+    context "as a collection member" do
+      subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first.reload }
+
+      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] }
+
+    end
+  end
+else
+end

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

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::InternetServices", :type => :mock_tmrk_ecloud_model do
+    context "as an attribute of an internet_service" do
+      subject { @vcloud.vdcs.first.public_ips.first.internet_services.first }
+
+      it { should respond_to :nodes }
+
+      describe :class do
+        subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.class }
+        its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Node }
+      end
+
+      describe :nodes do
+        subject { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes }
+
+        it { should respond_to :create }
+
+        it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Nodes }
+
+        its(:length) { should == 2 }
+
+        it { should have_members_of_the_right_model }
+      end
+    end
+  end
+else
+end

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

@@ -35,11 +35,13 @@ if Fog.mocking?
         let(:body) { subject.body }
 
         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" }
+        specify { body[:Href].should_not be_empty }
+        specify { body[:Name].should == @new_service_data[:name] }
+        specify { body[:Protocol].should == @new_service_data[:protocol] }
+        specify { body[:Enabled].should == @new_service_data[:enabled] }
+        specify { body[:Description].should == @new_service_data[:description] }
+        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 }

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

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+if Fog.mocking?
+  #FIXME: with rspec2
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :add_node }
+
+    describe "#add_node" do
+
+      let(:new_node_data) { { :ip_address  => '1.2.3.4',
+                              :name        => 'Foo',
+                              :port        => '9090',
+                              :enabled     => 'true',
+                              :description => 'Foo Service'
+                            } }
+
+      context "with a valid node services uri" do
+
+        subject { @vcloud.add_node(@mock_service[:href] + "/nodeServices", 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
+        end
+
+        describe "#body" do
+          subject { @vcloud.add_node(@mock_service[:href] + "/nodeServices", 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
+      end
+
+      context "with a nodes uri that doesn't exist" do
+        subject { lambda { @vcloud.add_node(URI.parse('https://www.fakey.c/piv8vc99'), new_node_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_node_spec.rb

@@ -0,0 +1,58 @@
+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_node }
+
+    describe "#configure_node" do
+      let(:original_node) { @vcloud.vdcs.first.public_ips.first.internet_services.first.nodes.first }
+      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) }
+
+        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] }
+        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
+        subject { lambda { @vcloud.configure_node(URI.parse('https://www.fakey.c/piv8vc99'), node_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/delete_internet_service_spec.rb

@@ -1,36 +1,35 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
+#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_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
+      context "with a valid internet service uri" do
+        subject { @vcloud.delete_internet_service(@mock_service[: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 }
+        it_should_behave_like "all delete responses"
 
-    #    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
+        let(:public_ip) { @vcloud.vdcs.first.public_ips.first }
 
-    #  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
+        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')) } }
+        describe "#body" do
+          its(:body) { should == '' }
+        end
 
-    #    it_should_behave_like "a request for a resource that doesn't exist"
-    #  end
-    #end
+
+
+      end
+
+    end
   end
 else
 end

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

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+if Fog.mocking?
+  #FIXME: with rspec2
+  describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :delete_node }
+
+    describe "#delete_node" do
+      context "with a valid node service uri" do
+        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 change the count by -1" do
+          internet_service.nodes.length.should == 2
+          subject
+          internet_service.nodes.reload.length.should == 1
+        end
+      end
+
+      context "with a nodes uri that doesn't exist" do
+        subject { lambda { @vcloud.delete_node(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_node_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_node }
+
+    describe "#get_node" do
+      context "with a valid nodes_uri" do
+        before { @node = @vcloud.get_node(@mock_node[:href]) }
+        subject { @node }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.tmrk.ecloud.nodeService+xml" }
+
+        describe "#body" do
+          subject { @node.body }
+
+          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]}
+
+        end
+      end
+
+      context "with a public_ips_uri that doesn't exist" do
+        subject { lambda { @vcloud.get_node(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_nodes_spec.rb

@@ -0,0 +1,58 @@
+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_nodes }
+
+    describe "#get_nodes" do
+      context "with a valid nodes_uri" do
+        before { @nodes = @vcloud.get_nodes(@mock_service[:href] + "/nodeServices") }
+        subject { @nodes }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.tmrk.ecloud.nodeService+xml" }
+
+        describe "#body" do
+          subject { @nodes.body }
+
+          it { should have(3).items }
+
+          describe "[:NodeService]" do
+            subject { @nodes.body[:NodeService] }
+
+            it { should have(@mock_service[:nodes].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 } }
+                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] }
+              end
+
+            end
+
+          end
+
+        end
+      end
+
+      context "with a public_ips_uri that doesn't exist" do
+        subject { lambda { @vcloud.get_nodes(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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 6
-  version: 0.2.6
+  - 7
+  version: 0.2.7
 platform: ruby
 authors: 
 - geemus (Wesley Beary)
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-29 00:00:00 -05:00
+date: 2010-06-30 00:00:00 -05:00
 default_executable: fog
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -617,17 +617,24 @@ files:
 - spec/vcloud/terremark/ecloud/models/ips_spec.rb
 - spec/vcloud/terremark/ecloud/models/network_spec.rb
 - spec/vcloud/terremark/ecloud/models/networks_spec.rb
+- spec/vcloud/terremark/ecloud/models/node_spec.rb
+- spec/vcloud/terremark/ecloud/models/nodes_spec.rb
 - spec/vcloud/terremark/ecloud/models/public_ip_spec.rb
 - spec/vcloud/terremark/ecloud/models/public_ips_spec.rb
 - spec/vcloud/terremark/ecloud/models/vdc_spec.rb
 - spec/vcloud/terremark/ecloud/models/vdcs_spec.rb
 - spec/vcloud/terremark/ecloud/requests/add_internet_service_spec.rb
+- spec/vcloud/terremark/ecloud/requests/add_node_spec.rb
 - spec/vcloud/terremark/ecloud/requests/configure_internet_service_spec.rb
+- spec/vcloud/terremark/ecloud/requests/configure_node_spec.rb
 - spec/vcloud/terremark/ecloud/requests/delete_internet_service_spec.rb
+- spec/vcloud/terremark/ecloud/requests/delete_node_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_internet_services_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_network_ip_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_network_ips_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_network_spec.rb
+- spec/vcloud/terremark/ecloud/requests/get_node_spec.rb
+- spec/vcloud/terremark/ecloud/requests/get_nodes_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_public_ip_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_public_ips_spec.rb
 - spec/vcloud/terremark/ecloud/requests/get_vdc_spec.rb