fog 0.3.16 → 0.3.17

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

@@ -103,16 +103,17 @@ module Fog
 
           def instantiate_vapp_template(catalog_item_uri, options = {})
             validate_instantiate_vapp_template_options(catalog_item_uri, options)
-            catalog_item, _ = catalog_item_and_vdc_from_catalog_item_uri(catalog_item_uri)
+            catalog_item = mock_data.catalog_item_from_href(catalog_item_uri)
 
             xml = nil
-            if vdc = vdc_from_uri(options[:vdc_uri])
-              vapp_id = rand(1000)
-              vapp_uri = Fog::Vcloud::Terremark::Ecloud::Mock.vapp_href(:id => vapp_id)
-              options.update(:id => vapp_id.to_s, :href => vapp_uri, :disks => catalog_item[:disks], :ip => random_ip_in_network(options[:network_uri]), :status => 2)
-              vdc[:vms] << options
-
-              xml = generate_instantiate_vapp_template_response(vdc[:href], options[:name], vapp_uri)
+            if vdc = mock_data.vdc_from_href(options[:vdc_uri])
+              if network = mock_data.network_from_href(options[:network_uri])
+                new_vm = MockVirtualMachine.new({ :name => options[:name], :ip => network.random_ip, :cpus => options[:cpus], :memory => options[:memory] }, vdc)
+                new_vm.disks.push(*catalog_item.disks.dup)
+                vdc.virtual_machines << new_vm
+
+                xml = generate_instantiate_vapp_template_response(new_vm)
+              end
             end
 
             if xml
@@ -124,23 +125,16 @@ module Fog
 
           private
 
-          def random_ip_in_network(network_uri)
-            network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:href] == network_uri }
-            subnet_ipaddr = IPAddr.new(network[:subnet])
-            ips = subnet_ipaddr.to_range.to_a[3..-2]
-            ips[rand(ips.size)].to_s
-          end
-
-          def generate_instantiate_vapp_template_response(vdc_uri, vapp_name, vapp_uri)
+          def generate_instantiate_vapp_template_response(vapp)
             builder = Builder::XmlMarkup.new
             builder.VApp(xmlns.merge(
-                                     :href => vapp_uri,
+                                     :href => vapp.href,
                                      :type => "application/vnd.vmware.vcloud.vApp+xml",
-                                     :name => vapp_name,
+                                     :name => vapp.name,
                                      :status => 0,
                                      :size => 4
                                      )) {
-              builder.Link(:rel => "up", :href => vdc_uri, :type => "application/vnd.vmware.vcloud.vdc+xml")
+              builder.Link(:rel => "up", :href => vapp._parent.href, :type => "application/vnd.vmware.vcloud.vdc+xml")
             }
           end
         end

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

@@ -8,8 +8,15 @@ module Fog
         end
 
         class Mock
-          def power_off(off_uri)
-            Fog::Mock.not_implemented
+          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

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

@@ -9,10 +9,8 @@ module Fog
 
         class Mock
           def power_on(vapp_uri)
-            vapp, vdc = vapp_and_vdc_from_vapp_uri(vapp_uri)
-
-            if vapp
-              vapp[:status] = 4
+            if vapp = mock_data.virtual_machine_from_href(vapp_uri)
+              vapp.power_on!
 
               builder = Builder::XmlMarkup.new
               mock_it 200, builder.Task(xmlns)

data/spec/vcloud/bin_spec.rb

@@ -1,21 +1,18 @@
-require 'spec_helper'
+require 'spec/vcloud/spec_helper'
 
 describe Vcloud do
   it { should be_initialized }
 
-  it { should have(3).services }
+  it { should have_at_least(1).services }
 
   describe "#registered_services" do
     subject { Vcloud.registered_services }
 
-    it { should == ":ecloud, :etest, :vcloud" }
+    it { should have_at_least(1).services }
   end
 
   describe "when indexing it like an array" do
     describe "with a service that exists" do
-      before do
-        Fog::Vcloud.should_receive(:new).and_return(true)
-      end
       it "should return something when indexed with a configured service" do
         Vcloud[:ecloud].should_not be_nil
       end

data/spec/vcloud/models/vdc_spec.rb

@@ -21,24 +21,24 @@ if Fog.mocking?
     end
 
     context "as a collection member" do
-      subject { @vcloud.vdcs[0].reload; @vcloud.vdcs[0] }
+      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(: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], :Limit => @mock_vdc[:cpu][:allocated]}, 
+      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], :Limit => @mock_vdc[:memory][:allocated]}} }
+                                                {: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], :Units=>"MB", :Allocated => @mock_vdc[:storage][:allocated]} }
+      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" }

data/spec/vcloud/requests/get_network_spec.rb

@@ -8,7 +8,7 @@ if Fog.mocking?
 
     describe :get_network, :type => :vcloud_request do
       context "with a valid network uri" do
-        before { @network = @vcloud.get_network(URI.parse(@mock_network[:href])) }
+        before { @network = @vcloud.get_network(URI.parse(@mock_network.href)) }
         subject { @network }
 
         it_should_behave_like "all responses"
@@ -21,13 +21,13 @@ if Fog.mocking?
 
           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, "" }
-          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] } }
+          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

data/spec/vcloud/requests/get_organization_spec.rb

@@ -23,20 +23,20 @@ if Fog.mocking?
           it { should have(6).keys }
 
           it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
-          it { should have_key_with_value :href, @mock_organization[:info][:href] }
-          it { should have_key_with_value :name, @mock_organization[:info][:name] }
-          it { should have_key_with_array :Link, @mock_organization[:vdcs].map { |vdc|
+          it { should have_key_with_value :href, @mock_organization.href }
+          it { should have_key_with_value :name, @mock_organization.name }
+          it { should have_key_with_array :Link, @mock_organization.vdcs.map { |vdc|
                                                  [{ :type => "application/vnd.vmware.vcloud.vdc+xml",
-                                                    :href => vdc[:href],
-                                                    :name => vdc[:name],
+                                                    :href => vdc.href,
+                                                    :name => vdc.name,
                                                     :rel => "down" },
                                                   { :type => "application/vnd.vmware.vcloud.catalog+xml",
-                                                    :href => vdc[:href] + "/catalog",
-                                                    :name => vdc[:name] + " Catalog",
+                                                    :href => vdc.catalog.href,
+                                                    :name => vdc.catalog.name,
                                                     :rel => "down" },
                                                   { :type => "application/vnd.vmware.vcloud.tasksList+xml",
-                                                    :href => vdc[:href] + "/tasksList",
-                                                    :name => vdc[:name] + " Tasks List",
+                                                    :href => vdc.task_list.href,
+                                                    :name => vdc.task_list.name,
                                                     :rel => "down" }]
                                                   }.flatten }
 

data/spec/vcloud/requests/get_vdc_spec.rb

@@ -12,7 +12,7 @@ if Fog.mocking?
 
     describe :get_vdc, :type => :vcloud_request do
       context "with a valid vdc uri" do
-        before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc[:href])) }
+        before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc.href)) }
         subject { @vdc }
 
         it_should_behave_like "all responses"
@@ -25,10 +25,10 @@ if Fog.mocking?
 
           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(:name)            { should == @mock_vdc.name }
+          its(:href)            { should == @mock_vdc.href }
           its(:VmQuota)         { should == "0" }
-          its(:Description)     { should == @mock_vdc[:name] + " VDC" }
+          its(:Description)     { should == @mock_vdc.name + " VDC" }
           its(:NicQuota)        { should == "0" }
           its(:IsEnabled)       { should == "true" }
           its(:NetworkQuota)    { should == "0" }
@@ -40,10 +40,10 @@ if Fog.mocking?
           specify { resource_entities.should have(3).vapps  }
           #FIXME: test for the resources
 
-          its(:ComputeCapacity) { should == {:Memory => { :Units => "MB", :Allocated => @mock_vdc[:memory][:allocated], :Limit => @mock_vdc[:memory][:allocated] },
-                                             :Cpu => { :Units => "Mhz", :Allocated => @mock_vdc[:cpu][:allocated], :Limit => @mock_vdc[:cpu][:allocated] } } }
+          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], :Limit => @mock_vdc[:storage][:allocated] } }
+          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 }

data/spec/vcloud/requests/get_versions_spec.rb

@@ -44,7 +44,7 @@ if Fog.mocking?
 
     describe "body" do
       subject { @vcloud.get_versions( @vcloud.versions_uri ).body }
-      its(:VersionInfo) { should == { :LoginUrl => @mock_version[:login_url] , :Version => @mock_version[:version] } }
+      its(:VersionInfo) { should == { :LoginUrl => @mock_version.login_url , :Version => @mock_version.version } }
     end
   end
 else

data/spec/vcloud/requests/login_spec.rb

@@ -12,8 +12,8 @@ if Fog.mocking?
     describe "#body" do
       subject { @vcloud.login.body }
       its(:Org) { should == { :type => "application/vnd.vmware.vcloud.org+xml",
-                              :href => @mock_organization[:info][:href],
-                              :name => @mock_organization[:info][:name]} }
+                              :href => @mock_organization.href,
+                              :name => @mock_organization.name} }
     end
   end
 else

data/spec/vcloud/spec_helper.rb

@@ -216,16 +216,36 @@ 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_generic_mock_data
+  @mock_version = @mock_data.versions.first
+  @mock_organization = @mock_data.organizations.first
+  @mock_vdc = @mock_organization.vdcs.first
+  @mock_vm = @mock_vdc.virtual_machines.first
+  @mock_network = @mock_vdc.networks.first
+end
+
 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
+  @base_url = Fog::Vcloud::Terremark::Ecloud::Mock.base_url
+  @mock_data = Fog::Vcloud::Terremark::Ecloud::Mock.data
+  setup_generic_mock_data
+  @mock_vdc_service_collection = @mock_vdc.internet_service_collection
+  @mock_public_ip_collection = @mock_vdc.public_ip_collection
+  @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_node_collection = @mock_service.node_collection
+  @mock_node = @mock_node_collection.items.first
+  @mock_catalog = @mock_vdc.catalog
+  @mock_catalog_item = @mock_catalog.items.first
+  @mock_network_ip_collection = @mock_network.ip_collection
+  @mock_network_ip = @mock_network_ip_collection.items.values.first
+  @mock_network_extensions = @mock_network.extensions
+end
+
+def setup_vcloud_mock_data
+  @base_url = Fog::Vcloud::Mock.base_url
+  @mock_data = Fog::Vcloud::Mock.data
+  setup_generic_mock_data
 end
 
 Spec::Runner.configure do |config|
@@ -238,27 +258,17 @@ Spec::Runner.configure do |config|
   end
 
   config.before(:all, :type => :mock_vcloud_model) do
-    @base_url = Fog::Vcloud::Mock.base_url
-    @mock_data = Fog::Vcloud::Mock.data
-    @mock_version = @mock_data[:versions][0]
-    @mock_organization = @mock_data[:organizations][0]
-    @mock_vdc = @mock_organization[:vdcs][0]
-    @mock_network = @mock_vdc[:networks][0]
-  end
-  config.before(:all, :type => :mock_vcloud_request) do
-    @mock_data = Fog::Vcloud::Mock.data
-    @base_url = Fog::Vcloud::Mock.base_url
-    @mock_version = @mock_data[:versions][0]
-    @mock_organization = @mock_data[:organizations][0]
-    @mock_vdc = @mock_organization[:vdcs][0]
-    @mock_network = @mock_vdc[:networks][0]
-  end
-  config.before(:all, :type => :mock_vcloud_model) do
+    Fog::Vcloud::Mock.data_reset
+    setup_vcloud_mock_data
     @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   end
-  config.before(:each, :type => :mock_vcloud_request) do
+
+  config.before(:all, :type => :mock_vcloud_request) do
+    Fog::Vcloud::Mock.data_reset
+    setup_vcloud_mock_data
     @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   end
+
   config.before(:each, :type => :mock_tmrk_ecloud_request) do
     Fog::Vcloud::Mock.data_reset
     Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
@@ -312,6 +322,11 @@ Spec::Matchers.define :have_key_with_array do |expected_key, expected_array|
   match do |actual|
     actual[expected_key].all? { |item| expected_array.include?(item) } && actual[expected_key].length == expected_array.length
   end
+  failure_message_for_should do |actual|
+    "Items not found in array:\n#{expected_array.select { |expected_item| !actual[expected_key].include?(expected_item) }.map { |item| item.inspect }.join("\n")}\n"  +
+    "Orignal items:\n#{actual[expected_key].map { |item| item.inspect }.join("\n") }\n"+
+    "Length Difference: #{expected_array.length - actual[expected_key].length}"
+  end
 end
 
 Spec::Matchers.define :have_headers_denoting_a_content_type_of do |expected|
@@ -332,8 +347,8 @@ Spec::Matchers.define :be_a_vapp_link_to do |expected|
   match do |actual|
     actual.is_a?(Hash) and
     actual[:type] == "application/vnd.vmware.vcloud.vApp+xml" and
-    actual[:href] == expected[:href] and
-    actual[:name] == expected[:name]
+    actual[:href] == expected.href and
+    actual[:name] == expected.name
   end
 end
 
@@ -341,8 +356,8 @@ Spec::Matchers.define :be_a_network_link_to do |expected|
   match do |actual|
     actual.is_a?(Hash) and
     actual[:type] == "application/vnd.vmware.vcloud.network+xml" and
-    actual[:href] == expected[:href] and
-    actual[:name] == expected[:name]
+    actual[:href] == expected.href and
+    actual[:name] == expected.name
   end
 end
 

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

@@ -2,10 +2,6 @@ require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
 if Fog.mocking?
   describe "Fog::Vcloud::Terremark::Ecloud::InternetService", :type => :mock_tmrk_ecloud_model do
-    before do
-      @mock_service_uri = "#{@base_url}/extensions/internetService/#{@mock_service[:id]}"
-    end
-
     subject { @vcloud.vdcs[0].public_ips[0].internet_services[0] }
 
     describe :class do
@@ -35,17 +31,17 @@ if Fog.mocking?
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::InternetService }
 
-      its(:href)                  { should == @mock_service_uri }
-      its(:identity)              { should == @mock_service_uri }
-      its(:name)                  { should == @mock_service[:name] }
-      its(:id)                    { should == @mock_service[:id] }
-      its(:protocol)              { should == @mock_service[:protocol] }
-      its(:port)                  { should == @mock_service[:port] }
-      its(:enabled)               { should == @mock_service[:enabled] }
-      its(:description)           { should == @mock_service[:description] }
+      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] }
-      its(:redirect_url)          { should == @mock_service[:redirect_url] }
+      its(:timeout)               { should == @mock_service.timeout.to_s }
+      its(:redirect_url)          { should == @mock_service.redirect_url }
       its(:monitor)               { should == nil }
 
       specify { composed_public_ip_data[:href].should == public_ip[:Href].to_s }

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

@@ -12,22 +12,19 @@ if Fog.mocking?
     end
 
     context "with no uri" do
-
       subject { Fog::Vcloud::Terremark::Ecloud::Ip.new() }
-      it { should have_all_attributes_be_nil }
 
+      it { should have_all_attributes_be_nil }
     end
 
     context "as a collection member" do
-      subject        { @vcloud.vdcs[0].networks[0].ips[0].reload; @vcloud.vdcs[0].networks[0].ips[0] }
-      let(:status)   { @mock_network[:ips].keys.include?(@vcloud.vdcs[0].networks[0].ips[0].name) ? "Assigned" : nil }
-      let(:server)   { @mock_network[:ips][@vcloud.vdcs[0].networks[0].ips[0].name] }
+      subject { @ip = @vcloud.vdcs[0].networks[0].ips[0] }
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Ip }
 
-      its(:name)   { should == IPAddr.new(@mock_network[:name]).to_range.to_a[3].to_s }
-      its(:status) { should == status }
-      its(:server) { should == server }
+      its(:name) { should == @mock_data.network_ip_from_href(@ip.href).name }
+      its(:status) { should == @mock_data.network_ip_from_href(@ip.href).status }
+      its(:server) { should == @mock_data.network_ip_from_href(@ip.href).used_by.name }
 
     end
   end

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

@@ -4,7 +4,7 @@ if Fog.mocking?
   describe "Fog::Vcloud::Terremark::Ecloud::Ips", :type => :mock_tmrk_ecloud_model do
     subject { @vcloud }
 
-    it { should_not respond_to :ips }
+    it { should respond_to :ips }
 
     describe :class do
       subject { @vcloud.vdcs[0].networks[0].ips.class }
@@ -12,7 +12,7 @@ if Fog.mocking?
     end
 
     describe :ips do
-      subject { @vcloud.vdcs[0].networks[0].ips.reload; @vcloud.vdcs[0].networks[0].ips }
+      subject { @vcloud.vdcs[0].networks[0].ips.reload }
       it { should_not respond_to :create }
 
       it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Ips }