fog 0.2.0 → 0.2.1

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

@@ -1,28 +1,28 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::Ips", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
-
-  it { should_not respond_to :ips }
-
-  describe :class do
-    subject { @vcloud.vdcs[0].networks[0].ips.class }
-    its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Ip }
-    its(:get_request) { should be_nil }
-    its(:all_request) { should be_nil }
-    its(:vcloud_type) { should be_nil }
-    it { should_not respond_to :create }
-  end
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Ips", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
+
+    it { should_not respond_to :ips }
+
+    describe :class do
+      subject { @vcloud.vdcs[0].networks[0].ips.class }
+      its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Ip }
+    end
 
-  describe :ips do
-    subject { @vcloud.vdcs[0].networks[0].ips }
+    describe :ips do
+      subject { @vcloud.vdcs[0].networks[0].ips.reload; @vcloud.vdcs[0].networks[0].ips }
+      it { should_not respond_to :create }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Ips }
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Ips }
 
-    its(:length) { should == 252 }
+      its(:length) { should == 252 }
 
-    it { should have_members_of_the_right_model }
+      it { should have_members_of_the_right_model }
+    end
   end
+else
 end
 
 

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

@@ -1,65 +1,69 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::Network", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Network", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
 
-  describe :class do
-    subject { Fog::Vcloud::Terremark::Ecloud::Network }
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::Network }
 
-    it { should have_identity :href }
-    it { should have_only_these_attributes [:href, :name, :features, :configuration, :ips_link, :type, :xmlns] }
-  end
-
-  context "with no uri" do
-
-    subject { Fog::Vcloud::Terremark::Ecloud::Network.new() }
-
-    its(:href)          { should be_nil }
-    its(:identity)      { should be_nil }
-    its(:name)          { should be_nil }
-    its(:type)          { should be_nil }
-    its(:features)      { should be_nil }
-    its(:configuration) { should be_nil }
-    its(:ips_link)      { should be_nil }
-    its(:xmlns)         { should be_nil }
-  end
-
-  context "as a collection member" do
-    subject { @vcloud.vdcs[0].networks[0] }
-
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Network }
-
-    it_should_behave_like "it has a vcloud v0.8 xmlns"
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:href, :name, :id, :features, :links, :type, :gateway, :broadcast, :address, :rnat, :extension_href] }
+    end
 
-    its(:href)                  { should == URI.parse(@mock_network[:href]) }
-    its(:identity)              { should == URI.parse(@mock_network[:href]) }
-    its(:name)                  { should == @mock_network[:name] }
-    its(:type)                  { should == "application/vnd.vmware.vcloud.network+xml" }
+    context "with no uri" do
 
-    it { should have(1).features }
+      subject { Fog::Vcloud::Terremark::Ecloud::Network.new() }
 
-    describe :features do
-      let(:feature) { subject.features[0] }
-      specify { feature.should be_an_instance_of Struct::VcloudNetworkFenceMode }
-      specify { feature.mode.should == "isolated" }
+      it { should have_all_attributes_be_nil }
     end
 
-    describe :configurations do
-      let(:configuration) { subject.configuration }
-      specify { configuration.should be_an_instance_of Struct::VcloudNetworkConfiguration }
-      specify { configuration.gateway.should == @mock_network[:gateway] }
-      specify { configuration.netmask.should == @mock_network[:netmask] }
-      specify { configuration.dns.should be_nil }
-    end
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].networks[0].reload; @vcloud.vdcs[0].networks[0] }
+
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Network }
+
+      its(:href)                  { should == @mock_network[:href] }
+      its(:identity)              { should == @mock_network[:href] }
+      its(:name)                  { should == @mock_network[:name] }
+      its(:type)                  { should == "application/vnd.vmware.vcloud.network+xml" }
+      its(:id)                    { should == @mock_network[:id] }
+      its(:gateway)               { should == @mock_network[:gateway] }
+      its(:broadcast)             { should == IPAddr.new(@mock_network[:subnet]).to_range.last.to_s }
+      its(:address)               { should == @mock_network[:subnet].split("/")[0] }
+      its(:rnat)                  { should == @mock_network[:rnat] }
+      its(:extension_href)        { should == @mock_network[:extension_href] }
+
+      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] }
+      end
+
+      it { should have(2).links }
+
+      describe :links do
+        context "[0]" do
+          let(:link) { subject.links[0] }
+          specify { link[:rel].should == "down" }
+          specify { link[:href].should == "#{@mock_network[:href]}/ips" }
+          specify { link[:type].should == "application/xml" }
+          specify { link[:name].should == "IP Addresses" }
+        end
+
+        context "[1]" do
+          let(:link) { subject.links[1] }
+          specify { link[:rel].should == "down" }
+          specify { link[:href].should == @mock_network[:extension_href] }
+          specify { link[:type].should == "application/xml" }
+          specify { link[:name].should == @mock_network[:name] }
+        end
+      end
 
-    describe :ips_link do
-      let(:ips_link) { subject.ips_link }
-      specify { ips_link.rel.should == "down" }
-      specify { ips_link.href.should == URI.parse(@mock_network[:href] + "/ips") }
-      specify { ips_link.type.should == "application/xml" }
-      specify { ips_link.name.should == "IP Addresses" }
     end
-
   end
+else
 end
 

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

@@ -1,26 +1,27 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::Networks", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Networks", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
 
-  it { should respond_to :networks }
+    it { should respond_to :networks }
 
-  describe :class do
-    subject { @vcloud.networks.class }
-    its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Network }
-    its(:get_request) { should == :get_network }
-    its(:all_request) { should be_an_instance_of Proc }
-    its(:vcloud_type) { should == "application/vnd.vmware.vcloud.network+xml" }
-  end
+    describe :class do
+      subject { @vcloud.networks.class }
+      its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Network }
+    end
 
-  describe :networks do
-    subject { @vcloud.vdcs[0].networks }
+    describe :networks do
+      subject { @vcloud.vdcs[0].networks }
+      it { should_not respond_to :create }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Networks }
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Networks }
 
-    its(:length) { should == 2 }
+      its(:length) { should == 2 }
 
-    it { should have_members_of_the_right_model }
+      it { should have_members_of_the_right_model }
+    end
   end
+else
 end
 

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

@@ -1,41 +1,40 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::PublicIp", :type => :tmrk_ecloud_model do
-  before do
-    @mock_ip = @mock_vdc[:public_ips].first
-    @mock_ip_uri = URI.parse("#{@base_url}/extensions/publicIp/#{@mock_ip[:id]}")
-  end
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::PublicIp", :type => :mock_tmrk_ecloud_model do
+    before do
+      @mock_ip = @mock_vdc[:public_ips].first
+    end
 
-  subject { @vcloud }
+    subject { @vcloud }
 
-  describe :class do
-    subject { Fog::Vcloud::Terremark::Ecloud::PublicIp }
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::PublicIp }
 
-    it { should have_identity :href }
-    it { should have_only_these_attributes [:name, :type, :id, :href] }
-  end
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:name, :id, :href] }
+    end
 
-  context "with no uri" do
+    context "with no uri" do
 
-    subject { Fog::Vcloud::Terremark::Ecloud::PublicIp.new() }
+      subject { Fog::Vcloud::Terremark::Ecloud::PublicIp.new() }
 
-    its(:href)     { should be_nil }
-    its(:identity) { should be_nil }
-    its(:name)     { should be_nil }
-    its(:type)     { should be_nil }
-  end
+      it { should have_all_attributes_be_nil }
+    end
+
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].public_ips[0].reload; @vcloud.vdcs[0].public_ips[0] }
 
-  context "as a collection member" do
-    subject { @vcloud.vdcs[0].public_ips[0] }
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIp }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIp }
+      its(:href)                  { should == @mock_ip[:href] }
+      its(:identity)              { should == @mock_ip[:href] }
+      its(:name)                  { should == @mock_ip[:name] }
+      its(:id)                    { should == @mock_ip[:id] }
 
-    its(:href)                  { should == @mock_ip_uri }
-    its(:identity)              { should == @mock_ip_uri }
-    its(:name)                  { should == @mock_ip[:name] }
-    its(:id)                    { should == @mock_ip[:id] }
+      its(:internet_services)     { should have(2).services }
 
-    its(:internet_services)     { should have(2).services }
- 
+    end
   end
+else
 end

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

@@ -1,26 +1,27 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::PublicIps", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::PublicIps", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
 
-  it { should respond_to :public_ips }
+    it { should respond_to :public_ips }
 
-  describe :class do
-    subject { @vcloud.public_ips.class }
-    its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::PublicIp }
-    its(:get_request) { should == :get_public_ip }
-    its(:all_request) { should be_an_instance_of Proc }
-    its(:vcloud_type) { should == "application/vnd.tmrk.ecloud.publicIp+xml" }
-  end
+    describe :class do
+      subject { @vcloud.public_ips.class }
+      its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::PublicIp }
+    end
 
-  describe :public_ips do
-    subject { @vcloud.vdcs[0].public_ips }
+    describe :public_ips do
+      subject { @vcloud.vdcs[0].public_ips }
+      it { should_not respond_to :create }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIps }
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIps }
 
-    its(:length) { should == 3 }
+      its(:length) { should == 3 }
 
-    it { should have_members_of_the_right_model }
+      it { should have_members_of_the_right_model }
+    end
   end
+else
 end
 

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

@@ -1,47 +1,63 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::Vdc", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Vdc", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
 
-  it { should respond_to :get_vdc }
+    it { should respond_to :get_vdc }
 
-  describe :class do
-    subject { Fog::Vcloud::Terremark::Ecloud::Vdc }
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::Vdc }
 
-    it { should have_identity :href }
-    it { should have_only_these_attributes [:href, :name, :other_links, :resource_entity_links, :network_links, :cpu_capacity, 
-                                            :storage_capacity, :memory_capacity, :vcloud_type, :xmlns, :description,
-                                            :deployed_vm_quota, :instantiated_vm_quota] }
-  end
+      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, :deployed_vm_quota, :instantiated_vm_quota] }
+    end
 
-  context "with no uri" do
+    context "with no uri" do
 
-    subject { Fog::Vcloud::Terremark::Ecloud::Vdc.new() }
+      subject { Fog::Vcloud::Terremark::Ecloud::Vdc.new() }
 
-    its(:href) { should be_nil }
-    its(:identity) { should be_nil }
-  end
+      it { should have_all_attributes_be_nil }
+    end
+
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].reload; @vcloud.vdcs[0] }
+
+      its(:href)                  { should == @mock_vdc[:href] }
+      its(:identity)              { should == @mock_vdc[:href] }
+      its(:name)                  { should == @mock_vdc[:name] }
+      its(:public_ips)            { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIps }
+      its(:other_links)           { should have(4).items }
+      its(:resource_entities)     { should have(3).items }
+      its(:available_networks)    { should have(2).items }
+
+      its(:compute_capacity)      { should == {:Memory =>
+                                                {:Allocated => @mock_vdc[:memory][:allocated], :Units => "bytes * 2^20"}, 
+                                               :DeployedVmsQuota =>
+                                                {:Limit => "-1", :Used => "-1"},
+                                               :InstantiatedVmsQuota =>
+                                                {:Limit => "-1", :Used => "-1"}, 
+                                               :Cpu =>
+                                                {:Allocated => @mock_vdc[:cpu][:allocated], :Units => "hz * 10^6"}} }
+
+      its(:storage_capacity)      { should == {:Allocated => @mock_vdc[:storage][:allocated], :Used => @mock_vdc[:storage][:used], :Units => "bytes * 10^9"} }
+
+      its(:deployed_vm_quota)     { should == nil }
+      its(:instantiated_vm_quota) { should == nil }
+
+      its(:public_ips)            { should have(3).public_ips }
+      its(:internet_services)     { should have(4).services }
+      its(:networks)              { should have(2).networks }
+      its(:servers)               { should have(3).servers }
+
+      #FIXME: need to mock tasks related requests first
+      #its(:tasks)                 { should have(0).tasks }
+
+      #FIXME: need to mock catalog related requests first
+      #its(:catalog)               { should have(0).entries }
 
-  context "as a collection member" do
-    subject { @vcloud.vdcs[0] }
-
-    its(:href)                  { should == URI.parse(@mock_vdc[:href]) }
-    its(:identity)              { should == URI.parse(@mock_vdc[:href]) }
-    its(:name)                  { should == @mock_vdc[:name] }
-    its(:public_ips)            { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIps }
-    its(:other_links)           { should have(4).items }
-    its(:resource_entity_links) { should have(3).items }
-    its(:network_links)         { should have(2).items }
- 
-    its(:cpu_capacity)          { should == Struct::VcloudXCapacity.new('hz * 10^6',@mock_vdc[:cpu][:allocated]) }
-    its(:memory_capacity)       { should == Struct::VcloudXCapacity.new('bytes * 2^20',@mock_vdc[:memory][:allocated]) }
-    its(:storage_capacity)      { should == Struct::VcloudXCapacity.new('bytes * 10^9',@mock_vdc[:storage][:allocated], @mock_vdc[:storage][:used]) }
-
-    its(:deployed_vm_quota)     { should == Struct::VcloudXCapacity.new(nil,nil,-1,-1) }
-    its(:instantiated_vm_quota) { should == Struct::VcloudXCapacity.new(nil,nil,-1,-1) }
-
-    its(:public_ips)            { should have(3).public_ips }
-    its(:internet_services)     { should have(4).services }
- 
+    end
   end
+else
 end

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

@@ -1,25 +1,28 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::Vdcs", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Vdcs", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
 
-  it { should respond_to :vdcs }
+    it { should respond_to :vdcs }
 
-  describe :class do
-    subject { @vcloud.vdcs.class }
-    its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Vdc }
-    its(:get_request) { should == :get_vdc }
-    its(:all_request) { should be_an_instance_of Proc }
-    its(:vcloud_type) { should == "application/vnd.vmware.vcloud.vdc+xml" }
-  end
+    describe :class do
+      subject { @vcloud.vdcs.class }
+      its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Vdc }
+    end
+
+    describe :vdcs do
+      subject { @vcloud.vdcs }
+      it { should_not respond_to :create }
 
-  describe :vdcs do
-    subject { @vcloud.vdcs }
+      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Vdcs }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Vdcs }
+      its(:length) { should == 2 }
 
-    its(:length) { should == 2 }
+      it { should have_members_of_the_right_model }
 
-    it { should have_members_of_the_right_model }
+      its(:organization_uri) { should == @mock_organization[:info][:href] }
+    end
   end
+else
 end