fog 0.5.3 → 0.6.0

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

@@ -1,25 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Real
-          basic_request :power_off, 202, 'POST'
-        end
-
-        class Mock
-          def power_off(vapp_uri)
-            if vapp = mock_data.virtual_machine_from_href(vapp_uri)
-              vapp.power_off!
-
-              builder = Builder::XmlMarkup.new
-              mock_it 200, builder.Task(xmlns)
-            else
-              mock_error 200, "401 Unauthorized"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Real
-          basic_request :power_on, 202, 'POST'
-        end
-
-        class Mock
-          def power_on(vapp_uri)
-            if vapp = mock_data.virtual_machine_from_href(vapp_uri)
-              vapp.power_on!
-
-              builder = Builder::XmlMarkup.new
-              mock_it 200, builder.Task(xmlns)
-            else
-              mock_error 200, "401 Unauthorized"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Real
-          basic_request :power_reset, 202, 'POST'
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud
-
-        class Real
-          basic_request :power_shutdown, 204, 'POST'
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Vcloud < Fog::Vcloud
-        request_path 'fog/vcloud/terremark/vcloud/requests'
-        request :get_vdc
-
-        class Real < Fog::Vcloud::Real
-
-          def initialize(options = {})
-            location = caller.first
-            warning = "[yellow][WARN] Fog::Vcloud::Terremark::Vcloud is deprecated, to be replaced with Vcloud 1.0 someday/maybe[/]"
-            warning << " [light_black](" << location << ")[/] "
-            Formatador.display_line(warning)
-            super
-          end
-
-          def supporting_versions
-            ["0.8", "0.8a-ext1.6"]
-          end
-
-        end
-
-        class Mock < Fog::Vcloud::Mock
-
-          def initialize(options = {})
-            location = caller.first
-            warning = "[yellow][WARN] Fog::Vcloud::Terremark::Vcloud is deprecated, to be replaced with Vcloud 1.0 someday/maybe[/]"
-            warning << " [light_black](" << location << ")[/] "
-            Formatador.display_line(warning)
-            super
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/fog/vcloud/terremark/vcloud/requests/get_vdc.rb

@@ -1,57 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Vcloud
-
-        class Real
-          # Handled by the main Vcloud get_vdc
-        end
-
-        class Mock
-          #
-          #Based off of:
-          #https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/09-get-vdc.aspx
-
-          def get_vdc(vdc_uri)
-            vdc_uri = ensure_unparsed(vdc_uri)
-            if vdc = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:href] == vdc_uri }
-              xml = Builder::XmlMarkup.new
-              mock_it 200,
-                xml.Vdc(xmlns.merge(:href => vdc[:href], :name => vdc[:name])) {
-                  xml.Link(:rel => "down",
-                           :href => vdc[:href] + "/catalog",
-                           :type => "application/vnd.vmware.vcloud.catalog+xml",
-                           :name => vdc[:name])
-                  xml.Link(:rel => "down",
-                           :href => vdc[:href] + "/publicIps",
-                           :type => "application/xml",
-                           :name => "Public IPs")
-                  xml.Link(:rel => "down",
-                           :href => vdc[:href] + "/internetServices",
-                           :type => "application/xml",
-                           :name => "Internet Services")
-                  xml.ResourceEntities {
-                    vdc[:vms].each do |vm|
-                      xml.ResourceEntity(:href => vm[:href],
-                                         :type => "application/vnd.vmware.vcloud.vApp+xml",
-                                         :name => vm[:name])
-                    end
-                  }
-                  xml.AvailableNetworks {
-                    vdc[:networks].each do |network|
-                      xml.Network(:href => network[:href],
-                                  :type => "application/vnd.vmware.vcloud.network+xml",
-                                  :name => network[:name])
-                    end
-                  }
-                }, { 'Content-Type' => 'application/vnd.vmware.vcloud.vdc+xml'}
-            else
-              mock_error 200, "401 Unauthorized"
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

data/spec/vcloud/bin_spec.rb

@@ -1,28 +0,0 @@
-require 'vcloud/spec_helper'
-
-describe Vcloud do
-  it { should be_initialized }
-
-  it { should have_at_least(1).services }
-
-  describe "#registered_services" do
-    subject { Vcloud.registered_services }
-
-    it { should have_at_least(1).services }
-  end
-
-  describe "when indexing it like an array" do
-    describe "with a service that exists" do
-      it "should return something when indexed with a configured service" do
-        Vcloud[:ecloud].should_not be_nil
-      end
-    end
-
-    describe "with a service that does not exist" do
-      it "should raise an ArgumentError" do
-        lambda {Vcloud[:foozle]}.should raise_error(ArgumentError)
-      end
-    end
-
-  end
-end

data/spec/vcloud/models/vdc_spec.rb

@@ -1,51 +0,0 @@
-require 'vcloud/spec_helper'
-
-if Fog.mocking?
-  describe "Fog::Vcloud::Vdc", :type => :mock_vcloud_model do
-
-    describe :class do
-      subject { Fog::Vcloud::Vdc }
-
-      it { should have_identity(:href) }
-
-      it { should have_only_these_attributes([:href, :name, :type, :description, :other_links, :compute_capacity, :storage_capacity, :available_networks,
-                                              :resource_entities, :enabled, :vm_quota, :nic_quota, :network_quota, :allocation_model]) }
-    end
-
-    context "with no uri" do
-
-      subject { Fog::Vcloud::Vdc.new() }
-
-      it { should(have_all_attributes_be_nil) }
-
-    end
-
-    context "as a collection member" do
-      subject { @vcloud.vdcs[0].reload }
-
-      it { should be_an_instance_of(Fog::Vcloud::Vdc) }
-
-      its(:href)                  { should == @mock_vdc.href }
-      its(:identity)              { should == @mock_vdc.href }
-      its(:name)                  { should == @mock_vdc.name }
-      its(:other_links)           { should have(7).items }
-      its(:resource_entities)     { should have(3).items }
-      its(:available_networks)    { should have(2).items }
-
-      its(:compute_capacity)      { should be_an_instance_of(Hash) }
-      its(:compute_capacity)      { should == {:Cpu =>
-                                                {:Units => "Mhz", :Allocated => @mock_vdc.cpu_allocated.to_s, :Limit => @mock_vdc.cpu_allocated.to_s},
-                                               :Memory =>
-                                                {:Units => "MB", :Allocated => @mock_vdc.memory_allocated.to_s, :Limit => @mock_vdc.memory_allocated.to_s}} }
-      its(:storage_capacity)      { should be_an_instance_of(Hash) }
-      its(:storage_capacity)      { should == {:Limit => @mock_vdc.storage_allocated.to_s, :Units=>"MB", :Allocated => @mock_vdc.storage_allocated.to_s} }
-
-      its(:vm_quota)              { should == "0" }
-      its(:nic_quota)             { should == "0" }
-      its(:network_quota)         { should == "0" }
-
-      its(:enabled)               { should == "true" }
-
-    end
-  end
-end

data/spec/vcloud/models/vdcs_spec.rb

@@ -1 +0,0 @@
-require 'spec_helper'

data/spec/vcloud/requests/get_network_spec.rb

@@ -1,44 +0,0 @@
-require 'vcloud/spec_helper'
-
-if Fog.mocking?
-  describe Fog::Vcloud, :type => :mock_vcloud_request do
-    subject { @vcloud }
-
-    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 }
-
-        it_should_behave_like "all responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.network+xml") }
-
-        describe :body do
-          subject { @network.body }
-
-          it { should have(9).keys }
-
-          it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-          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(:Description, @mock_network.name) }
-          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,
-                                                           :Dns => @mock_network.dns }) }
-        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")
-      end
-    end
-  end
-else
-
-  describe Fog::Vcloud, :type => :vcloud_request do
-  end
-
-end

data/spec/vcloud/requests/get_vdc_spec.rb

@@ -1,62 +0,0 @@
-require 'vcloud/spec_helper'
-
-#
-# WARNING: INCOMPLETE
-#
-
-if Fog.mocking?
-  describe Fog::Vcloud, :type => :mock_vcloud_request do
-    subject { @vcloud }
-
-    it { should respond_to(:get_vdc) }
-
-    describe :get_vdc, :type => :vcloud_request 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 responses"
-        it { should have_headers_denoting_a_content_type_of("application/vnd.vmware.vcloud.vdc+xml") }
-
-        describe :body do
-          subject { @vdc.body }
-
-          it { should have(16).items }
-
-          it_should_behave_like("it has the standard vcloud v0.8 xmlns attributes")   # 3 keys
-
-          its(:name)            { should == @mock_vdc.name }
-          its(:href)            { should == @mock_vdc.href }
-          its(:VmQuota)         { should == "0" }
-          its(:Description)     { should == @mock_vdc.name + " VDC" }
-          its(:NicQuota)        { should == "0" }
-          its(:IsEnabled)       { should == "true" }
-          its(:NetworkQuota)    { should == "0" }
-          its(:AllocationModel) { should == "AllocationPool" }
-          its(:Link)            { should have(7).links }
-          its(:ResourceEntities) { should have(1).resource }
-
-          let(:resource_entities) { subject[:ResourceEntities][:ResourceEntity] }
-          specify { resource_entities.should have(3).vapps  }
-          #FIXME: test for the resources
-
-          its(:ComputeCapacity) { should == {:Memory => { :Units => "MB", :Allocated => @mock_vdc.memory_allocated.to_s, :Limit => @mock_vdc.memory_allocated.to_s },
-                                             :Cpu => { :Units => "Mhz", :Allocated => @mock_vdc.cpu_allocated.to_s, :Limit => @mock_vdc.cpu_allocated.to_s } } }
-
-          its(:StorageCapacity) { should == {:Units => "MB", :Allocated => @mock_vdc.storage_allocated.to_s, :Limit => @mock_vdc.storage_allocated.to_s } }
-
-          let(:available_networks) { subject[:AvailableNetworks][:Network] }
-          specify { available_networks.should have(2).networks }
-          #FIXME :test the available networks
-
-        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')) } }
-        it_should_behave_like("a request for a resource that doesn't exist")
-      end
-    end
-  end
-end
-
-

data/spec/vcloud/requests/get_versions_spec.rb

@@ -1,54 +0,0 @@
-require 'vcloud/spec_helper'
-
-shared_examples_for "real or mock get_versions requests" do
-
-  subject { @vcloud }
-
-  it { should respond_to(:get_versions) }
-
-  describe "#get_versions" do
-    subject { @vcloud.get_versions( @vcloud.versions_uri ) }
-
-    it_should_behave_like "all responses"
-
-    describe "body" do
-      subject { @vcloud.get_versions( @vcloud.versions_uri ).body }
-
-      it { should have(4).keys }
-      it_should_behave_like "it has the standard xmlns attributes"   # 2 keys
-
-      its(:xmlns) { should == "http://www.vmware.com/vcloud/versions" }
-
-      its(:VersionInfo) { should be_either_a_hash_or_array }
-
-      describe ":VersionInfo" do
-        subject { arrayify(@vcloud.get_versions( @vcloud.versions_uri ).body[:VersionInfo]) }
-
-        specify {
-          subject.each do |version_info|
-            version_info.should include(:LoginUrl)
-            version_info[:LoginUrl].should be_a_url
-            version_info.should include(:Version)
-            version_info[:Version].should be_an_instance_of(String)
-          end
-        }
-      end
-    end
-  end
-end
-
-if Fog.mocking?
-  describe Fog::Vcloud, :type => :mock_vcloud_request do
-
-    it_should_behave_like "real or mock get_versions requests"
-
-    describe "body" do
-      subject { @vcloud.get_versions( @vcloud.versions_uri ).body }
-      its(:VersionInfo) { should == { :LoginUrl => @mock_version.login_url , :Version => @mock_version.version } }
-    end
-  end
-else
-  describe Fog::Vcloud, :type => :vcloud_request do
-    it_should_behave_like "real or mock get_versions requests"
-  end
-end

data/spec/vcloud/requests/login_spec.rb

@@ -1,24 +0,0 @@
-require 'vcloud/spec_helper'
-
-shared_examples_for "real or mock login requests" do
-  subject { @vcloud }
-  it_should_behave_like "all login requests"
-end
-
-if Fog.mocking?
-  describe Fog::Vcloud, :type => :mock_vcloud_request do
-    it_should_behave_like "real or mock login requests"
-
-    describe "#body" do
-      subject { @vcloud.login.body }
-      its(:Org) { should == { :type => "application/vnd.vmware.vcloud.org+xml",
-                              :href => @mock_organization.href,
-                              :name => @mock_organization.name} }
-    end
-  end
-else
-  describe Fog::Vcloud, :type => :vcloud_request do
-    it_should_behave_like "real or mock login requests"
-  end
-end
-