fog 0.2.0 → 0.2.1

data/spec/aws/requests/simpledb/put_attributes_spec.rb

@@ -18,6 +18,24 @@ describe 'SimpleDB.put_attributes' do
       actual.body['BoxUsage'].should be_a(Float)
     end
 
+    it 'conditional put should succeed' do
+      AWS[:sdb].put_attributes(@domain_name, 'foo', { 'version' => '1' })
+      AWS[:sdb].put_attributes(@domain_name, 'foo', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])
+      actual = AWS[:sdb].put_attributes(@domain_name, 'foo', { 'version' => '3' }, :expect => { 'version' => '2' }, :replace => ['version'])
+      actual.body['RequestId'].should be_a(String)
+      actual.body['BoxUsage'].should be_a(Float)
+    end
+
+    it 'conditional put should raise Conflict error' do
+      actual = AWS[:sdb].put_attributes(@domain_name, 'foo', { 'version' => '2' }, :replace => ['version'])
+      actual.body['RequestId'].should be_a(String)
+      actual.body['BoxUsage'].should be_a(Float)
+
+      lambda {
+        actual = AWS[:sdb].put_attributes(@domain_name, 'foo', { 'version' => '2' }, :expect => { 'version' => '1' }, :replace => ['version'])
+      }.should raise_error(Excon::Errors::Conflict)
+    end
+
   end
   describe 'failure' do
 

data/spec/vcloud/bin_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Vcloud do
   it { should be_initialized }
 
-  it { should have(2).services }
+  it { should have(3).services }
 
   describe "#registered_services" do
     subject { Vcloud.registered_services }
 
-    it { should == ":ecloud, :vcloud" }
+    it { should == ":ecloud, :etest, :vcloud" }
   end
 
   describe "when indexing it like an array" do

data/spec/vcloud/models/vdc_spec.rb

@@ -1,46 +1,52 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe "Fog::Vcloud::Vdc", :type => :vcloud_model do
+if Fog.mocking?
+  describe "Fog::Vcloud::Vdc", :type => :mock_vcloud_model do
 
-  describe :class do
-    subject { Fog::Vcloud::Vdc }
+    describe :class do
+      subject { Fog::Vcloud::Vdc }
 
-    it { should have_identity :href }
+      it { should have_identity :href }
 
-    it { should have_only_these_attributes [:allocation_model, :cpu_capacity, :description, :enabled, :href, :memory_capacity, :name, :network_links, :network_quota,
-                                            :nic_quota, :other_links, :resource_entity_links, :storage_capacity, :vcloud_type, :vm_quota, :xmlns] }
-  end
+      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
+    context "with no uri" do
 
-    subject { Fog::Vcloud::Vdc.new() }
+      subject { Fog::Vcloud::Vdc.new() }
 
-    its(:href) { should be_nil }
-    its(:identity) { should be_nil }
-  end
+      it { should have_all_attributes_be_nil }
 
-  context "as a collection member" do
-    subject { @vcloud.vdcs[0] }
+    end
 
-    its(:href)                  { should == URI.parse(@mock_vdc[:href]) }
-    its(:identity)              { should == URI.parse(@mock_vdc[:href]) }
-    its(:name)                  { should == @mock_vdc[:name] }
-    its(:other_links)           { should have(7).items }
-    its(:resource_entity_links) { should have(3).items }
-    its(:network_links)         { should have(2).items }
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].reload; @vcloud.vdcs[0] }
 
-    its(:cpu_capacity)          { should == Struct::VcloudXCapacity.new('Mhz',@mock_vdc[:cpu][:allocated], nil, @mock_vdc[:cpu][:allocated]) }
-    its(:memory_capacity)       { should == Struct::VcloudXCapacity.new('MB',@mock_vdc[:memory][:allocated], nil, @mock_vdc[:memory][:allocated]) }
-    its(:storage_capacity)      { should == Struct::VcloudXCapacity.new('MB',@mock_vdc[:storage][:allocated], nil, @mock_vdc[:storage][:allocated]) }
+      it { should be_an_instance_of Fog::Vcloud::Vdc }
 
-    its(:vm_quota)              { should == 0 }
-    its(:nic_quota)             { should == 0 }
-    its(:network_quota)         { should == 0 }
+      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(:enabled)               { should == true }
-
-  end
+      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]}, 
+                                               :Memory =>
+                                                {:Units => "MB", :Allocated => @mock_vdc[:memory][:allocated], :Limit => @mock_vdc[:memory][:allocated]}} }
+      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(:vm_quota)              { should == "0" }
+      its(:nic_quota)             { should == "0" }
+      its(:network_quota)         { should == "0" }
 
+      its(:enabled)               { should == "true" }
 
+    end
+  end
+else
 end

data/spec/vcloud/requests/get_network_spec.rb

@@ -1,55 +1,44 @@
-require "spec_helper"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
-describe Fog::Vcloud, :type => :vcloud_request do
-  subject { @vcloud }
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { @vcloud }
 
-  it { should respond_to :get_network }
+    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 }
+    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 requests"
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.network+xml" }
 
-      its(:headers) { should include "Content-Type" }
-      its(:body) { should be_an_instance_of Struct::VcloudNetwork }
+        describe :body do
+          subject { @network.body }
 
-      describe :headers do
-        let(:header) { @network.headers["Content-Type"] }
-        specify { header.should == "application/vnd.vmware.vcloud.network+xml" }
-      end
-
-      describe :body do
-        subject { @network.body }
-
-        it_should_behave_like "it has a vcloud v0.8 xmlns"
-
-        its(:configuration) { should be_an_instance_of Struct::VcloudNetworkConfiguration }
-        its(:features)      { should be_an_instance_of Array }
-        its(:href)          { should == URI.parse("https://fakey.com/api/v0.8/network/31") }
-        its(:type)          { should == "application/vnd.vmware.vcloud.network+xml" }
-        its(:name)          { should == @mock_network[:name] }
-        its(:description)   { should == @mock_network[:name] }
-
-        describe :configuration do
-          subject { @network.body.configuration }
-
-          its(:gateway) { should == "1.2.3.1" }
-          its(:netmask) { should == "255.255.255.0" }
-          its(:dns)     { should == "8.8.8.8" }
-        end
+          it { should have(9).keys }
 
-        describe "FenceMode Feature" do
-          subject { @network.body.features.detect { |feature| feature.is_a?(Struct::VcloudNetworkFenceMode) } }
-          its(:mode) { should == "isolated" }
+          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] } }
         end
-
       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"
+      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_organization_spec.rb

@@ -1,46 +1,53 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe Fog::Vcloud, :type => :vcloud_request do
-  subject { @vcloud }
-
-  it { should respond_to :get_organization }
-
-  describe "#get_organization" do
-    context "with a valid organization uri" do
-      before { @organization = @vcloud.get_organization(@vcloud.default_organization_uri) }
-      subject { @organization }
-
-      it_should_behave_like "all requests"
-
-      its(:headers) { should include "Content-Type" }
-      its(:body) { should be_an_instance_of Struct::VcloudOrganization }
-
-      describe :headers do
-        let(:header){ @organization.headers["Content-Type"] }
-        specify{ header.should == "application/vnd.vmware.vcloud.org+xml" }
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { @vcloud }
+
+    it { should respond_to :get_organization }
+
+    describe "#get_organization" do
+      context "with a valid organization uri" do
+        before { @organization = @vcloud.get_organization(@vcloud.default_organization_uri) }
+        subject { @organization }
+
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.org+xml" }
+
+        describe "#body" do
+          subject { @organization.body }
+
+
+          let(:links) { subject[:Link] }
+
+          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|
+                                                 [{ :type => "application/vnd.vmware.vcloud.vdc+xml",
+                                                    :href => vdc[:href],
+                                                    :name => vdc[:name],
+                                                    :rel => "down" },
+                                                  { :type => "application/vnd.vmware.vcloud.catalog+xml",
+                                                    :href => vdc[:href] + "/catalog",
+                                                    :name => vdc[:name] + " Catalog",
+                                                    :rel => "down" },
+                                                  { :type => "application/vnd.vmware.vcloud.tasksList+xml",
+                                                    :href => vdc[:href] + "/tasksList",
+                                                    :name => vdc[:name] + " Tasks List",
+                                                    :rel => "down" }]
+                                                  }.flatten }
+
+        end
       end
-
-      describe "#body" do
-        subject { @organization.body }
-
-        it_should_behave_like "it has a vcloud v0.8 xmlns"
-
-        its(:links) { should have(@mock_organization[:vdcs].length * 3).links }
-        its(:name) { should == @mock_organization[:info][:name] }
-        its(:href) { should == URI.parse(@mock_organization[:info][:href]) }
-
-        let(:link) { subject.links[0] }
-        specify { link.should be_an_instance_of Struct::VcloudLink }
-        specify { link.rel.should == "down" }
-        specify { link.href.should == URI.parse(@mock_vdc[:href]) }
-        specify { link.type.should == "application/vnd.vmware.vcloud.vdc+xml" }
-        specify { link.name.should == @mock_vdc[:name] }
+      context "with an organization uri that doesn't exist" do
+        subject { lambda { @vcloud.get_organization(URI.parse('https://www.fakey.com/api/v0.8/org/999')) } }
+        it_should_behave_like "a request for a resource that doesn't exist"
       end
     end
-    context "with an organization uri that doesn't exist" do
-      subject { lambda { @vcloud.get_organization(URI.parse('https://www.fakey.com/api/v0.8/org/999')) } }
-      it_should_behave_like "a request for a resource that doesn't exist"
-    end
   end
+else
 end
 

data/spec/vcloud/requests/get_vdc_spec.rb

@@ -1,53 +1,63 @@
-require "spec_helper"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 #
 # WARNING: INCOMPLETE
 #
 
-describe Fog::Vcloud, :type => :vcloud_request do
-  subject { @vcloud }
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { @vcloud }
 
-  it { should respond_to :get_vdc }
+    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 }
+    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 requests"
+        it_should_behave_like "all responses"
+        it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.vdc+xml" }
 
-      its(:headers) { should include "Content-Type" }
-      its(:body) { should be_an_instance_of Struct::VcloudVdc }
+        describe :body do
+          subject { @vdc.body }
 
-      describe :headers do
-        let(:header) { @vdc.headers["Content-Type"] }
-        specify { header.should == "application/vnd.vmware.vcloud.vdc+xml" }
-      end
+          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 }
 
-      describe :body do
-        subject { @vdc.body }
+          let(:resource_entities) { subject[:ResourceEntities][:ResourceEntity] }
+          specify { resource_entities.should have(3).vapps  }
+          #FIXME: test for the resources
 
-        it_should_behave_like "it has a vcloud v0.8 xmlns"
+          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(:links) { should have(7).links }
-        its(:resource_entities) { should have(3).links }
-        its(:networks) { should have(2).networks }
+          its(:StorageCapacity) { should == {:Units => "MB", :Allocated => @mock_vdc[:storage][:allocated], :Limit => @mock_vdc[:storage][:allocated] } }
 
-        its(:name) { should == @mock_vdc[:name] }
-        its(:href) { should == URI.parse(@mock_vdc[:href]) }
+          let(:available_networks) { subject[:AvailableNetworks][:Network] }
+          specify { available_networks.should have(2).networks }
+          #FIXME :test the available networks
 
-        let(:link) { subject.links[0] }
-        specify { link.should be_an_instance_of Struct::VcloudLink }
-        specify { link.rel.should == "up" }
-        specify { link.href.should == URI.parse(@mock_organization[:info][:href]) }
-        specify { link.type.should == "application/vnd.vmware.vcloud.org+xml" }
+        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
-    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
+else
 end
 
 

data/spec/vcloud/requests/get_versions_spec.rb

@@ -1,28 +1,28 @@
-require 'spec_helper'
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
-describe Fog::Vcloud, :type => :vcloud_request do
-  subject { @vcloud }
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { @vcloud }
 
-  it { should respond_to :get_versions }
+    it { should respond_to :get_versions }
 
-  describe "#get_versions" do
-    before { @versions = @vcloud.get_versions }
-    subject { @versions }
+    describe "#get_versions" do
+      before { @versions = @vcloud.get_versions( @vcloud.versions_uri ) }
+      subject { @versions }
 
-    it_should_behave_like "all requests"
+      it_should_behave_like "all responses"
 
-    its(:body) { should have(1).version }
+      describe "body" do
+        subject { @versions.body }
 
-    describe "body.first" do
-      let(:version) { @versions.body.first }
-      subject { version }
+        it { should have(4).keys }
+        it_should_behave_like "it has the standard xmlns attributes"   # 2 keys
 
-      its(:login_url) { should == @mock_version[:login_url] }
-
-      its(:version) { should == @mock_version[:version] }
-
-      its(:supported) { should == @mock_version[:supported] }
+        its(:xmlns) { should == "http://www.vmware.com/vcloud/versions" }
+        its(:VersionInfo) { should == { :LoginUrl => @mock_version[:login_url] , :Version => @mock_version[:version] } }
 
+      end
     end
   end
+else
 end

data/spec/vcloud/requests/login_spec.rb

@@ -1,8 +1,11 @@
-require 'spec_helper'
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
-describe Fog::Vcloud, :type => :vcloud_request do
-  subject { @vcloud }
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { @vcloud }
 
-  it_should_behave_like "all login requests"
+    it_should_behave_like "all login requests"
+  end
+else
 end