fog 0.3.31 → 0.3.32

data/lib/fog/zerigo/requests/dns/update_zone.rb

@@ -0,0 +1,78 @@
+module Fog
+  module Zerigo
+    class DNS
+      class Real
+
+        # Update the parameters of a zone
+        # ==== Parameters
+        #
+        # * zone_id<~Integer>
+        # * options<~Hash> - optional paramaters
+        #   * default_ttl<~Integer>
+        #   * ns_type<~String>
+        #   * ns1<~String> - required if ns_type == sec
+        #   * nx_ttl<~Integer> -
+        #   * slave_nameservers<~String> - required if ns_type == pri
+        #   * axfr_ips<~String> - comma-separated list of IPs or IP blocks allowed to perform AXFRs
+        #   * custom_nameservers<~String> - comma-separated list of custom nameservers
+        #   * custom_ns<~String> - indicates if vanity (custom) nameservers are enabled for this domain
+        #   * hostmaster<~String> - email of the DNS administrator or hostmaster
+        #   * notes<~String> - notes about the domain
+        #   * restrict_axfr<~String> - indicates if AXFR transfers should be restricted to IPs in axfr-ips
+        #   * tag_list<~String> - List of all tags associated with this domain
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * 'status'<~Integer> - 200 for success
+        def update_zone( zone_id, options = {})
+
+          optional_tags= ''
+          options.each { |option, value|
+            case option
+            when :default_ttl
+              optional_tags+= "<default-ttl>#{value}</default-ttl>"
+            when :ns_type
+              optional_tags+= "<ns-type>#{value}</ns-type>"
+            when :ns1
+              optional_tags+= "<ns1>#{value}</ns1>"
+            when :nx_ttl
+              optional_tags+= "<nx-ttl type='interger'>#{value}</nx-ttl>"
+            when :slave_nameservers
+              optional_tags+= "<slave-nameservers>#{value}</slave-nameservers>"
+            when :axfr_ips
+              optional_tags+= "<axfr-ips>#{value}</axfr-ips>"
+            when :custom_nameservers
+              optional_tags+= "<custom-nameservers>#{value}</custom-nameservers>"
+            when :custom_ns
+              optional_tags+= "<custom-ns>#{value}</custom-ns>"
+            when :hostmaster
+              optional_tags+= "<hostmaster>#{value}</hostmaster>"
+            when :notes
+              optional_tags+= "<notes>#{value}</notes>"
+            when :restrict_axfr
+              optional_tags+= "<restrict-axfr>#{value}</restrict-axfr>"
+            when :tag_list
+              optional_tags+= "<tag-list>#{value}</tag-list>"
+            end
+          }
+          
+          request(
+            :body     => %Q{<?xml version="1.0" encoding="UTF-8"?><zone>#{optional_tags}</zone>},
+            :expects  => 200,
+            :method   => 'PUT',
+            :path     => "/api/1.1/zones/#{zone_id}.xml"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def update_zone(zone_id, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 require 'spec'
 require 'open-uri'
 require 'fog'
-Fog.bin = true
 require 'fog/core/bin'
 require 'fog/vcloud/bin'
 
@@ -36,7 +35,3 @@ end
 unless defined?(GENTOO_AMI)
   GENTOO_AMI = 'ami-5ee70037'
 end
-
-def lorem_file
-  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
-end

data/spec/vcloud/spec_helper.rb

@@ -233,6 +233,7 @@ def setup_ecloud_mock_data
   @mock_public_ip = @mock_public_ip_collection.items.first
   @mock_service_collection = @mock_public_ip.internet_service_collection
   @mock_service = @mock_service_collection.items.first
+  @mock_backup_service = @mock_vdc_service_collection.backup_internet_services.first
   @mock_node_collection = @mock_service.node_collection
   @mock_node = @mock_node_collection.items.first
   @mock_catalog = @mock_vdc.catalog
@@ -273,13 +274,13 @@ Spec::Runner.configure do |config|
     Fog::Vcloud::Mock.data_reset
     Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
     setup_ecloud_mock_data
-    @vcloud = Fog::Vcloud::Terremark::Ecloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
+    @vcloud = Fog::Vcloud::Terremark::Ecloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   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::Terremark::Ecloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
+    @vcloud = Fog::Vcloud::Terremark::Ecloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   end
 end
 

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

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::BackupInternetService", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud.vdcs[0].backup_internet_services[0] }
+
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::BackupInternetService }
+
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:href, :name, :id, :protocol, :enabled, :description, :timeout, :redirect_url, :monitor] }
+    end
+
+    context "with no uri" do
+
+      subject { Fog::Vcloud::Terremark::Ecloud::BackupInternetService.new() }
+      it { should have_all_attributes_be_nil }
+
+    end
+
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].backup_internet_services[0].reload }
+
+      let(:composed_service_data) { @vcloud.vdcs[0].backup_internet_services[0].send(:_compose_service_data) }
+
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::BackupInternetService }
+
+      its(:href)                  { should == @mock_backup_service.href }
+      its(:identity)              { should == @mock_backup_service.href }
+      its(:name)                  { should == @mock_backup_service.name }
+      its(:id)                    { should == @mock_backup_service.object_id.to_s }
+      its(:protocol)              { should == @mock_backup_service.protocol }
+      its(:enabled)               { should == @mock_backup_service.enabled.to_s }
+      its(:description)           { should == @mock_backup_service.description }
+      its(:timeout)               { should == @mock_backup_service.timeout.to_s }
+      its(:redirect_url)          { should == (@mock_backup_service.redirect_url || "") }
+      its(:monitor)               { should == nil }
+
+      specify { composed_service_data[:href].should == subject.href.to_s }
+      specify { composed_service_data[:name].should == subject.name }
+      specify { composed_service_data[:id].should == subject.id.to_s }
+      specify { composed_service_data[:protocol].should == subject.protocol }
+      specify { composed_service_data[:enabled].should == subject.enabled.to_s }
+      specify { composed_service_data[:description].should == subject.description }
+      specify { composed_service_data[:timeout].should == subject.timeout.to_s }
+    end
+  end
+else
+end

data/spec/vcloud/terremark/ecloud/models/backup_internet_services_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 a VDC" do
+      subject { @vcloud.vdcs[0] }
+
+      it { should respond_to :backup_internet_services }
+
+      describe :class do
+        subject { @vcloud.vdcs[0].backup_internet_services.class }
+        its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::BackupInternetService }
+      end
+
+      describe :backup_internet_services do
+        subject { @vcloud.vdcs[0].backup_internet_services }
+
+        it { should respond_to :create }
+
+        it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::BackupInternetServices }
+
+        its(:length) { should == 1 }
+
+        it { should have_members_of_the_right_model }
+      end
+    end
+  end
+else
+end

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

@@ -8,7 +8,7 @@ if Fog.mocking?
       subject { Fog::Vcloud::Terremark::Ecloud::InternetService }
 
       it { should have_identity :href }
-      it { should have_only_these_attributes [:href, :name, :id, :protocol, :port, :enabled, :description, :public_ip, :timeout, :redirect_url, :monitor] }
+      it { should have_only_these_attributes [:href, :name, :id, :protocol, :port, :enabled, :description, :public_ip, :timeout, :redirect_url, :monitor, :backup_service_data] }
     end
 
     context "with no uri" do
@@ -31,18 +31,19 @@ if Fog.mocking?
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::InternetService }
 
-      its(:href)                  { should == @mock_service.href }
-      its(:identity)              { should == @mock_service.href }
-      its(:name)                  { should == @mock_service.name }
-      its(:id)                    { should == @mock_service.object_id.to_s }
-      its(:protocol)              { should == @mock_service.protocol }
-      its(:port)                  { should == @mock_service.port.to_s }
-      its(:enabled)               { should == @mock_service.enabled.to_s }
-      its(:description)           { should == @mock_service.description }
-      its(:public_ip)             { should == public_ip }
-      its(:timeout)               { should == @mock_service.timeout.to_s }
-      its(:redirect_url)          { should == @mock_service.redirect_url }
-      its(:monitor)               { should == nil }
+      its(:href)               { should == @mock_service.href }
+      its(:identity)           { should == @mock_service.href }
+      its(:name)               { should == @mock_service.name }
+      its(:id)                 { should == @mock_service.object_id.to_s }
+      its(:protocol)           { should == @mock_service.protocol }
+      its(:port)               { should == @mock_service.port.to_s }
+      its(:enabled)            { should == @mock_service.enabled.to_s }
+      its(:description)        { should == @mock_service.description }
+      its(:public_ip)          { should == public_ip }
+      its(:timeout)            { should == @mock_service.timeout.to_s }
+      its(:redirect_url)       { should == @mock_service.redirect_url }
+      its(:monitor)            { should == nil }
+      its(:backup_service_uri) { should be_nil }
 
       specify { composed_public_ip_data[:href].should == public_ip[:Href].to_s }
       specify { composed_public_ip_data[:name].should == public_ip[:Name] }
@@ -56,6 +57,24 @@ if Fog.mocking?
       specify { composed_service_data[:enabled].should == subject.enabled.to_s }
       specify { composed_service_data[:description].should == subject.description }
       specify { composed_service_data[:timeout].should == subject.timeout.to_s }
+
+      context "with a backup internet service" do
+        before { @mock_service[:backup_service] = @mock_backup_service }
+
+        its(:backup_service_uri) { should == @mock_backup_service.href }
+      end
+
+      describe "#backup_service_uri=" do
+        specify do
+          expect { subject.backup_service_uri = @mock_backup_service.href }.
+            to change { subject.backup_service_uri }.from(nil).to(@mock_backup_service.href)
+        end
+
+        specify do
+          expect { subject.backup_service_uri = @mock_backup_service.href }.
+            to change { subject.send(:_compose_service_data)[:backup_service_uri] }.from(nil).to(@mock_backup_service.href)
+        end
+      end
     end
   end
 else

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

@@ -8,7 +8,7 @@ if Fog.mocking?
       subject { Fog::Vcloud::Terremark::Ecloud::Network }
 
       it { should have_identity :href }
-      it { should have_only_these_attributes [:href, :name, :features, :links, :type, :gateway, :broadcast, :address, :rnat, :extension_href] }
+      it { should have_only_these_attributes [:href, :name, :features, :links, :type, :gateway, :broadcast, :address, :rnat, :extension_href, :network_type, :vlan, :friendly_name] }
     end
 
     context "with no uri" do
@@ -32,13 +32,16 @@ if Fog.mocking?
       its(:address)               { should == @mock_network.address }
       its(:rnat)                  { should == @mock_network.rnat }
       its(:extension_href)        { should == @mock_network.extensions.href }
+      its(:network_type)          { should == @mock_network.extensions.type }
+      its(:vlan)                  { should == @mock_network.extensions.vlan }
+      its(:friendly_name)         { should == @mock_network.extensions.friendly_name }
 
       it { should have(1).features }
 
       describe :features do
-        let(:feature) { subject.features[0] }
-        specify { feature.should be_an_instance_of Hash }
-        specify { feature[:FenceMode].should == @mock_network.features[0][:value] }
+        let(:feature) { subject.features.first }
+        specify { feature.should be_an_instance_of Array }
+        specify { feature.last.should == @mock_network.features[0][:value] }
       end
 
       it { should have(2).links }

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

@@ -26,6 +26,26 @@ if Fog.mocking?
       its(:cpus)                  { should == { :count => @mock_vm.cpus, :units => nil } }
       its(:memory)                { should == { :amount => @mock_vm.memory, :units => nil } }
       its(:disks)                 { should == @mock_vm.to_configure_vapp_hash[:disks] }
+
+      describe "question methods" do
+        describe "#ready?" do
+          before { subject.power_off }
+
+          it { should be_ready }
+        end
+
+        describe "#on?" do
+          before { subject.power_on }
+
+          it { should be_on }
+        end
+
+        describe "#off?" do
+          before { subject.power_off }
+
+          it { should be_off }
+        end
+      end
     end
 
     context "as a new server without all info" do

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

@@ -0,0 +1,60 @@
+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_backup_internet_service }
+
+    describe "#add_backup_internet_service" do
+      before do
+        @new_backup_service_data = {
+          :name => "Test Service",
+          :protocol => "HTTP",
+          :enabled => "true",
+          :description => "this is a test",
+          :redirect_url => ""
+        }
+      end
+
+      context "with a valid vdc uri" do
+        subject { @vcloud.add_backup_internet_service(@mock_vdc.internet_service_collection.href, @new_backup_service_data ) }
+
+        it "has the right number of Internet Services after" do
+          expect { subject }.to change { @vcloud.get_internet_services(@mock_vdc.internet_service_collection.href).body[:InternetService].size }.by(1)
+        end
+
+        it_should_behave_like "all responses"
+
+        let(:body) { subject.body }
+
+        its(:body) { should be_an_instance_of Hash }
+        specify { body[:Href].should_not be_empty }
+        specify { body[:Name].should == @new_backup_service_data[:name] }
+        specify { body[:Protocol].should == @new_backup_service_data[:protocol] }
+        specify { body[:Enabled].should == @new_backup_service_data[:enabled] }
+        specify { body[:Description].should == @new_backup_service_data[:description] }
+        specify { body[:RedirectURL].should == @new_backup_service_data[:redirect_url] }
+        specify { body[:Monitor].should == nil }
+        # so broken
+        specify { body[:IsBackupService].should == "false" }
+
+        it "should update the mock object properly" do
+          subject
+
+          backup_internet_service = @vcloud.mock_data.backup_internet_service_from_href(body[:Href])
+          backup_internet_service.object_id.to_s.should == body[:Id]
+          backup_internet_service.node_collection.items.should be_empty
+        end
+      end
+
+      context "with a vdc uri that doesn't exist" do
+        subject { lambda { @vcloud.add_backup_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @new_backup_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

@@ -26,6 +26,7 @@ if Fog.mocking?
             @service_data[:description] = "TEST BOOM"
             @service_data[:redirect_url] = "http://google.com"
             @service_data[:port] = "80"
+            @service_data[:backup_service_uri] = @mock_backup_service.href
           end
 
           it "should change data" do
@@ -36,12 +37,14 @@ if Fog.mocking?
             result.body[:Description].should == @service_data[:description]
             result.body[:RedirectURL].should == @service_data[:redirect_url]
             result.body[:Port].should        == @service_data[:port]
+            result.body[:BackupService][:Href].should == @service_data[:backup_service_uri]
 
             new_result = @vcloud.get_internet_services(@mock_public_ip.internet_service_collection.href).body[:InternetService].first
 
             new_result[:Description].should == @service_data[:description]
             new_result[:RedirectURL].should == @service_data[:redirect_url]
             new_result[:Port].should        == @service_data[:port]
+            new_result[:BackupService][:Href].should == @service_data[:backup_service_uri]
           end
         end
       end

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

@@ -0,0 +1,55 @@
+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_network_ip }
+
+    describe "#configure_network_ip" do
+      let(:original_network_ip) { @vcloud.get_network_ip(@mock_network_ip.href).body }
+      let(:network_ip_data) do
+        {
+          :id => original_network_ip[:Id],
+          :href => original_network_ip[:Href],
+          :name => original_network_ip[:Name],
+          :status => original_network_ip[:Status],
+          :server => original_network_ip[:Server],
+          :rnat => "1.2.3.4"
+        }
+      end
+
+      context "with a valid network ip uri" do
+
+        subject { @vcloud.configure_network_ip(@mock_network_ip.href, network_ip_data) }
+
+        it_should_behave_like "all responses"
+
+        describe "#body" do
+          subject { @vcloud.configure_network_ip(@mock_network_ip.href, network_ip_data).body }
+
+          #Stuff that shouldn't change
+          its(:Href) { should == @mock_network_ip.href }
+          its(:Id) { should == @mock_network_ip.object_id.to_s }
+          its(:Name) { should == @mock_network_ip.ip }
+          its(:Status) { should == @mock_network_ip.status }
+
+          #Stuff that should change
+          it "should change the rnat" do
+            expect { subject }.to change { @vcloud.get_network_ip(@mock_network_ip.href).body[:RnatAddress] }.
+              from(@mock_network.rnat).
+              to(network_ip_data[:rnat])
+          end
+        end
+
+      end
+
+      context "with a nodes uri that doesn't exist" do
+        subject { lambda { @vcloud.configure_network_ip(URI.parse('https://www.fakey.c/piv8vc99'), network_ip_data) } }
+
+        it_should_behave_like "a request for a resource that doesn't exist"
+      end
+    end
+  end
+else
+end