fog 0.2.0 → 0.2.1

data/spec/vcloud/spec_helper.rb

@@ -1,6 +1,21 @@
 require 'spec'
 require 'pp'
 
+module Spec
+  module Example
+    module Subject
+      module ExampleGroupMethods
+        def its(attribute, &block)
+          describe(attribute) do
+            define_method(:subject) { s = super(); s.is_a?(Hash) ? s[attribute] : s.send(attribute) }
+            it(&block)
+          end
+        end
+      end
+    end
+  end
+end
+
 #Initialize this to a known seed
 srand 1234
 
@@ -8,15 +23,21 @@ current_directory = File.dirname(__FILE__)
 require "#{current_directory}/../../lib/fog"
 require "#{current_directory}/../../lib/fog/bin"
 
-Fog.mock!
+Fog.mock! if ENV['FOG_MOCK']
 
 require "#{current_directory}/../../lib/fog/vcloud/bin"
 
-shared_examples_for "all requests" do
+shared_examples_for "all responses" do
   it { should respond_to :body }
   it { should respond_to :headers }
   it { should have_at_least(1).body }
   it { should have_at_least(0).headers }
+  its(:body) { should be_an_instance_of Hash }
+  its(:headers) { should be_an_instance_of Hash }
+end
+
+shared_examples_for "it has a Content-Type header" do
+  its(:headers) { should include "Content-Type" }
 end
 
 shared_examples_for "all rel=down vcloud links" do
@@ -65,31 +86,21 @@ shared_examples_for "all login requests" do
     before { @login = @vcloud.login }
     subject { @login }
 
-    it_should_behave_like "all requests"
+    it_should_behave_like "all responses"
 
     its(:headers) { should include "Set-Cookie" }
-    its(:headers) { should include "Content-Type" }
-    its(:body) { should be_an_instance_of Struct::VcloudOrgList }
-
-    describe "#body" do
-      before { @orglist = @login.body }
-      subject { @orglist }
-
-      its(:xmlns) { should == "http://www.vmware.com/vcloud/v0.8" }
 
-      it { should have(1).organizations }
+    it { should have_headers_denoting_a_content_type_of "application/vnd.vmware.vcloud.orgslist+xml" }
 
-      describe "#first" do
-        before { @org = @orglist.organizations.first }
-        subject { @org }
-
-        it { should be_an_instance_of Struct::VcloudLink }
+    describe "#body" do
+      subject { @login.body }
 
-        its(:href) { should == URI.parse(@mock_organization[:info][:href]) }
-        its(:name) { should == @mock_organization[:info][:name] }
-        its(:type) { should == "application/vnd.vmware.vcloud.org+xml" }
+      it { should have(4).organizations }
 
-      end
+      it_should_behave_like "it has the standard vcloud v0.8 xmlns attributes"   # 3 keys
+      its(:Org) { should == { :type => "application/vnd.vmware.vcloud.org+xml",
+                              :href => @mock_organization[:info][:href],
+                              :name => @mock_organization[:info][:name]} }
     end
   end
 end
@@ -98,6 +109,24 @@ shared_examples_for "it has a vcloud v0.8 xmlns" do
   its(:xmlns) { should == 'http://www.vmware.com/vcloud/v0.8' }
 end
 
+shared_examples_for "it has the proper xmlns_xsi" do
+  its(:xmlns_xsi) { should == "http://www.w3.org/2001/XMLSchema-instance" }
+end
+
+shared_examples_for "it has the proper xmlns_xsd" do
+  its(:xmlns_xsd) { should == "http://www.w3.org/2001/XMLSchema" }
+end
+
+shared_examples_for "it has the standard xmlns attributes" do
+  it_should_behave_like "it has the proper xmlns_xsi"
+  it_should_behave_like "it has the proper xmlns_xsd"
+end
+
+shared_examples_for "it has the standard vcloud v0.8 xmlns attributes" do
+  it_should_behave_like "it has a vcloud v0.8 xmlns"
+  it_should_behave_like "it has the standard xmlns attributes"
+end
+
 shared_examples_for "a request for a resource that doesn't exist" do
   it { should raise_error Excon::Errors::Unauthorized }
 end
@@ -108,12 +137,6 @@ shared_examples_for "a vdc catalog link" do
   its(:href) { should == URI.parse(@mock_vdc[:href] + "/catalog") }
 end
 
-shared_examples_for "a tmrk vdc" do
-  it { should respond_to :links }
-  it { should respond_to :networks }
-  it { should respond_to :resource_entities }
-end
-
 shared_examples_for "a tmrk network link" do
   it_should_behave_like "all vcloud links w/o a rel"
   it_should_behave_like "all vcloud network types"
@@ -163,46 +186,64 @@ shared_examples_for "the mocked tmrk resource entity links" do
   end
 end
 
+Spec::Example::ExampleGroupFactory.register(:mock_vcloud_request, Class.new(Spec::Example::ExampleGroup))
+Spec::Example::ExampleGroupFactory.register(:mock_vcloud_model, Class.new(Spec::Example::ExampleGroup))
+Spec::Example::ExampleGroupFactory.register(:mock_tmrk_ecloud_request, Class.new(Spec::Example::ExampleGroup))
+Spec::Example::ExampleGroupFactory.register(:mock_tmrk_ecloud_model, Class.new(Spec::Example::ExampleGroup))
 Spec::Example::ExampleGroupFactory.register(:vcloud_request, Class.new(Spec::Example::ExampleGroup))
-Spec::Example::ExampleGroupFactory.register(:vcloud_model, Class.new(Spec::Example::ExampleGroup))
 Spec::Example::ExampleGroupFactory.register(:tmrk_ecloud_request, Class.new(Spec::Example::ExampleGroup))
-Spec::Example::ExampleGroupFactory.register(:tmrk_ecloud_model, Class.new(Spec::Example::ExampleGroup))
 Spec::Example::ExampleGroupFactory.register(:tmrk_vcloud_request, Class.new(Spec::Example::ExampleGroup))
 
 Spec::Runner.configure do |config|
-  config.before(:all) do
-    @mock_data = Fog::Vcloud::Mock.data
+  config.after(:all) do
+    Fog::Vcloud::Mock.data_reset
+  end
+  config.before(:each, :type => :mock_vcloud_model) do
+    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
+  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.after(:all) do
-    Fog::Vcloud::Mock.data_reset
+  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(:each, :type => :vcloud_model) do
-    @vcloud = Fog::Vcloud.new
+  config.before(:each, :type => :mock_vcloud_request) do
+    @vcloud = Fog::Vcloud.new(:username => "", :password => "bar", :versions_uri => "http://fakey.com/api/versions")
   end
-  config.before(:each, :type => :vcloud_request) do
-    @vcloud = Fog::Vcloud.new
+  config.before(:each, :type => :mock_tmrk_ecloud_request) do
+    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
   end
-  config.before(:all, :type => :tmrk_ecloud_request) do
+  config.before(:all, :type => :mock_tmrk_ecloud_request) do
     @base_url = Fog::Vcloud::Terremark::Ecloud::Mock.base_url
     @mock_data = Fog::Vcloud::Terremark::Ecloud::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(:each, :type => :tmrk_ecloud_request) do
-    @vcloud = Fog::Vcloud.new(:module => "Fog::Vcloud::Terremark::Ecloud")
+  config.after(:all, :type => :mock_tmrk_ecloud_request) do
+    Fog::Vcloud::Terremark::Ecloud::Mock.data_reset
   end
-  config.before(:all, :type => :tmrk_ecloud_model) do
+  config.before(:all, :type => :mock_tmrk_ecloud_model) do
     @base_url = Fog::Vcloud::Terremark::Ecloud::Mock.base_url
     @mock_data = Fog::Vcloud::Terremark::Ecloud::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(:each, :type => :tmrk_ecloud_model) do
-    @vcloud = Fog::Vcloud.new(:module => "Fog::Vcloud::Terremark::Ecloud")
-  end
-  config.before(:each, :type => :tmrk_vcloud_request) do
-    @vcloud = Fog::Vcloud.new(:module => "Fog::Vcloud::Terremark::Vcloud")
+  config.before(:each, :type => :mock_tmrk_ecloud_model) do
+    @vcloud = Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "http://fakey.com/api/versions", :module => "Fog::Vcloud::Terremark::Ecloud")
   end
 end
 
@@ -234,3 +275,53 @@ Spec::Matchers.define :have_members_of_the_right_model do
     actual.all? { |member| member.is_a?(actual.model) }
   end
 end
+
+Spec::Matchers.define :have_key_with_value do |expected_key, expected_value|
+  match do |actual|
+    actual.has_key?(expected_key) && actual[expected_key] == expected_value
+  end
+end
+
+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
+end
+
+Spec::Matchers.define :have_headers_denoting_a_content_type_of do |expected|
+  match do |actual|
+    actual.headers["Content-Type"] == expected
+  end
+end
+
+Spec::Matchers.define :have_keys_with_values do |expected|
+  match do |actual|
+    actual.each_pair.all? do |key, value|
+      expected.keys.include?(key) && expected[key] == value
+    end
+  end
+end
+
+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]
+  end
+end
+
+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]
+  end
+end
+
+Spec::Matchers.define :have_all_attributes_be_nil do
+  match do |actual|
+    actual.class.attributes.all? { |attribute| actual.send(attribute.to_sym) == nil }
+  end
+end

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

@@ -1,73 +1,68 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::InternetService", :type => :tmrk_ecloud_model do
-  before do
-    @mock_ip = @mock_vdc[:public_ips].first
-    @mock_service = @mock_ip[:services].first
-    @mock_service_uri = URI.parse("#{@base_url}/extensions/internetService/#{@mock_service[:id]}")
-  end
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::InternetService", :type => :mock_tmrk_ecloud_model do
+    before do
+      @mock_ip = @mock_vdc[:public_ips].first
+      @mock_service = @mock_ip[:services].first
+      @mock_service_uri = "#{@base_url}/extensions/internetService/#{@mock_service[:id]}"
+    end
 
-  subject { @vcloud.vdcs[0].public_ips[0].internet_services[0] }
+    subject { @vcloud.vdcs[0].public_ips[0].internet_services[0] }
 
-  describe :class do
-    subject { Fog::Vcloud::Terremark::Ecloud::InternetService }
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::InternetService }
 
-    it { should have_identity :href }
-    it { should have_only_these_attributes [:href, :name, :id, :type, :protocol, :port, :enabled, :description, :public_ip, :timeout, :url_send_string, :http_header] }
-  end
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:href, :name, :id, :protocol, :port, :enabled, :description, :public_ip, :timeout, :redirect_url, :monitor] }
+    end
 
-  context "with no uri" do
+    context "with no uri" do
 
-    subject { Fog::Vcloud::Terremark::Ecloud::InternetService.new() }
+      subject { Fog::Vcloud::Terremark::Ecloud::InternetService.new() }
+      it { should have_all_attributes_be_nil }
 
-    its(:href)            { should be_nil }
-    its(:identity)        { should be_nil }
-    its(:name)            { should be_nil }
-    its(:type)            { should be_nil }
-    its(:id)              { should be_nil }
-    its(:protocol)        { should be_nil }
-    its(:port)            { should be_nil }
-    its(:enabled)         { should be_nil }
-    its(:description)     { should be_nil }
-    its(:public_ip)       { should be_nil }
-    its(:timeout)         { should be_nil }
-    its(:url_send_string) { should be_nil }
-    its(:http_header)     { should be_nil }
-  end
+    end
 
-  context "as a collection member" do
-    subject { @vcloud.vdcs[0].public_ips[0].internet_services[0] }
-    let(:public_ip) { @vcloud.get_public_ip(@vcloud.vdcs[0].public_ips[0].internet_services[0].public_ip.href).body }
-    let(:composed_public_ip_data) { @vcloud.vdcs[0].public_ips[0].internet_services[0].send(:_compose_ip_data) }
-    let(:composed_service_data) { @vcloud.vdcs[0].public_ips[0].internet_services[0].send(:_compose_service_data) }
+    context "as a collection member" do
+      subject { @vcloud.vdcs[0].public_ips[0].internet_services[0].reload; @vcloud.vdcs[0].public_ips[0].internet_services[0] }
+
+      let(:public_ip) {
+        pip = @vcloud.get_public_ip(@vcloud.vdcs[0].public_ips[0].internet_services[0].public_ip[:Href]).body
+        pip.delete_if{ |k,v| [:xmlns, :xmlns_i].include?(k)}
+        pip
+      }
+      let(:composed_public_ip_data) { @vcloud.vdcs[0].public_ips[0].internet_services[0].send(:_compose_ip_data) }
+      let(:composed_service_data) { @vcloud.vdcs[0].public_ips[0].internet_services[0].send(:_compose_service_data) }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::InternetService }
+      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(:type)                  { should == "application/vnd.tmrk.ecloud.internetService+xml" }
-    its(:protocol)              { should == "HTTP" }
-    its(:port)                  { should == 80 }
-    its(:enabled)               { should == true }
-    its(:description)           { should == "Web Servers" }
-    its(:public_ip)             { should == public_ip }
-    its(:timeout)               { should == 2 }
-    its(:url_send_string)       { should == nil }
-    its(:http_header)           { should == nil }
+      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 == "HTTP" }
+      its(:port)                  { should == "80" }
+      its(:enabled)               { should == "true" }
+      its(:description)           { should == "Web Servers" }
+      its(:public_ip)             { should == public_ip }
+      its(:timeout)               { should == "2" }
+      its(:redirect_url)          { should == "" }
+      its(:monitor)               { should == "" }
 
-    specify { composed_public_ip_data[:href].should == public_ip.href.to_s }
-    specify { composed_public_ip_data[:name].should == public_ip.name }
-    specify { composed_public_ip_data[:id].should == public_ip.id }
+      specify { composed_public_ip_data[:href].should == public_ip[:Href].to_s }
+      specify { composed_public_ip_data[:name].should == public_ip[:Name] }
+      specify { composed_public_ip_data[:id].should == public_ip[:Id] }
 
-    specify { composed_service_data[:href].should == subject.href.to_s }
-    specify { composed_service_data[:name].should == subject.name }
-    specify { composed_service_data[:id].should == subject.id.to_s }
-    specify { composed_service_data[:protocol].should == subject.protocol }
-    specify { composed_service_data[:port].should == subject.port.to_s }
-    specify { composed_service_data[:enabled].should == subject.enabled.to_s }
-    specify { composed_service_data[:description].should == subject.description }
-    specify { composed_service_data[:timeout].should == subject.timeout.to_s }
+      specify { composed_service_data[:href].should == subject.href.to_s }
+      specify { composed_service_data[:name].should == subject.name }
+      specify { composed_service_data[:id].should == subject.id.to_s }
+      specify { composed_service_data[:protocol].should == subject.protocol }
+      specify { composed_service_data[:port].should == subject.port.to_s }
+      specify { composed_service_data[:enabled].should == subject.enabled.to_s }
+      specify { composed_service_data[:description].should == subject.description }
+      specify { composed_service_data[:timeout].should == subject.timeout.to_s }
+    end
   end
+else
 end

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

@@ -1,29 +1,29 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::InternetServices", :type => :tmrk_ecloud_model do
-  context "as an attribute of a VDC" do
-    subject { @vcloud.vdcs[0] }
-
-    it { should respond_to :internet_services }
-
-    describe :class do
-      subject { @vcloud.vdcs[0].internet_services.class }
-      its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::InternetService }
-      its(:get_request) { should == nil }
-      its(:all_request) { should be_an_instance_of Proc }
-      its(:vcloud_type) { should == "application/vnd.tmrk.ecloud.internetService+xml" }
-    end
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::InternetServices", :type => :mock_tmrk_ecloud_model do
+    context "as an attribute of a VDC" do
+      subject { @vcloud.vdcs[0] }
+
+      it { should respond_to :internet_services }
+
+      describe :class do
+        subject { @vcloud.vdcs[0].internet_services.class }
+        its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::InternetService }
+      end
 
-    describe :internet_services do
-      subject { @vcloud.vdcs[0].internet_services }
+      describe :internet_services do
+        subject { @vcloud.vdcs[0].internet_services }
 
-      it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::InternetServices }
+        it { should respond_to :create }
 
-      its(:length) { should == 4 }
+        it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::InternetServices }
 
-      it { should have_members_of_the_right_model }
+        its(:length) { should == 4 }
+
+        it { should have_members_of_the_right_model }
+      end
     end
   end
+else
 end
-
-

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

@@ -1,35 +1,36 @@
 require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
 
-describe "Fog::Vcloud::Terremark::Ecloud::Ip", :type => :tmrk_ecloud_model do
-  subject { @vcloud }
+if Fog.mocking?
+  describe "Fog::Vcloud::Terremark::Ecloud::Ip", :type => :mock_tmrk_ecloud_model do
+    subject { @vcloud }
 
-  describe :class do
-    subject { Fog::Vcloud::Terremark::Ecloud::Ip }
+    describe :class do
+      subject { Fog::Vcloud::Terremark::Ecloud::Ip }
 
-    it { should have_identity :name }
-    it { should have_only_these_attributes [:name, :status, :server] }
-  end
+      it { should have_identity :href }
+      it { should have_only_these_attributes [:href, :name, :status, :server, :rnat, :id] }
+    end
 
-  context "with no uri" do
+    context "with no uri" do
 
-    subject { Fog::Vcloud::Terremark::Ecloud::Ip.new() }
+      subject { Fog::Vcloud::Terremark::Ecloud::Ip.new() }
+      it { should have_all_attributes_be_nil }
 
-    its(:name)   { should be_nil }
-    its(:status) { should be_nil }
-    its(:server) { should be_nil }
-  end
+    end
 
-  context "as a collection member" do
-    subject        { @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] }
+    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] }
 
-    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Ip }
+      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 == IPAddr.new(@mock_network[:name]).to_range.to_a[3].to_s }
+      its(:status) { should == status }
+      its(:server) { should == server }
 
+    end
   end
+else
 end