phpfog-fog 0.4.1

data/spec/vcloud/bin_spec.rb

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,52 @@
+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
+else
+end

data/spec/vcloud/models/vdcs_spec.rb

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

data/spec/vcloud/requests/get_network_spec.rb

@@ -0,0 +1,44 @@
+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_organization_spec.rb

@@ -0,0 +1,53 @@
+require 'vcloud/spec_helper'
+
+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.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,
+                                                    :rel => "down" },
+                                                  { :type => "application/vnd.vmware.vcloud.catalog+xml",
+                                                    :href => vdc.catalog.href,
+                                                    :name => vdc.catalog.name,
+                                                    :rel => "down" },
+                                                  { :type => "application/vnd.vmware.vcloud.tasksList+xml",
+                                                    :href => vdc.task_list.href,
+                                                    :name => vdc.task_list.name,
+                                                    :rel => "down" }]
+                                                  }.flatten }
+
+        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
+  end
+else
+end
+

data/spec/vcloud/requests/get_vdc_spec.rb

@@ -0,0 +1,63 @@
+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
+else
+end
+
+

data/spec/vcloud/requests/get_versions_spec.rb

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,24 @@
+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
+