fog 0.1.8 → 0.1.9

data/spec/vcloud/requests/get_network_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Fog::Vcloud, :type => :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 requests"
+
+      its(:headers) { should include "Content-Type" }
+      its(:body) { should be_an_instance_of Struct::VcloudNetwork }
+
+      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
+
+        describe "FenceMode Feature" do
+          subject { @network.body.features.detect { |feature| feature.is_a?(Struct::VcloudNetworkFenceMode) } }
+          its(:mode) { should == "isolated" }
+        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"
+    end
+  end
+end

data/spec/vcloud/spec_helper.rb

@@ -176,6 +176,7 @@ Spec::Runner.configure do |config|
     @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

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

@@ -38,6 +38,8 @@ describe "Fog::Vcloud::Terremark::Ecloud::InternetService", :type => :tmrk_eclou
   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) }
 
     it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::InternetService }
 
@@ -54,5 +56,18 @@ describe "Fog::Vcloud::Terremark::Ecloud::InternetService", :type => :tmrk_eclou
     its(:timeout)               { should == 2 }
     its(:url_send_string)       { should == nil }
     its(:http_header)           { should == nil }
+
+    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 }
   end
 end

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

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+describe "Fog::Vcloud::Terremark::Ecloud::Ip", :type => :tmrk_ecloud_model do
+  subject { @vcloud }
+
+  describe :class do
+    subject { Fog::Vcloud::Terremark::Ecloud::Ip }
+
+    it { should have_identity :name }
+    it { should have_only_these_attributes [:name, :status, :server] }
+  end
+
+  context "with no uri" do
+
+    subject { Fog::Vcloud::Terremark::Ecloud::Ip.new() }
+
+    its(:name)   { should be_nil }
+    its(:status) { should be_nil }
+    its(:server) { should be_nil }
+  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] }
+
+    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 }
+
+  end
+end
+

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

@@ -0,0 +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
+
+  describe :ips do
+    subject { @vcloud.vdcs[0].networks[0].ips }
+
+    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Ips }
+
+    its(:length) { should == 252 }
+
+    it { should have_members_of_the_right_model }
+  end
+end
+
+

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

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+describe "Fog::Vcloud::Terremark::Ecloud::Network", :type => :tmrk_ecloud_model do
+  subject { @vcloud }
+
+  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"
+
+    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" }
+
+    it { should have(1).features }
+
+    describe :features do
+      let(:feature) { subject.features[0] }
+      specify { feature.should be_an_instance_of Struct::VcloudNetworkFenceMode }
+      specify { feature.mode.should == "isolated" }
+    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
+
+    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
+end
+

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

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+describe "Fog::Vcloud::Terremark::Ecloud::Networks", :type => :tmrk_ecloud_model do
+  subject { @vcloud }
+
+  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 :networks do
+    subject { @vcloud.vdcs[0].networks }
+
+    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Networks }
+
+    its(:length) { should == 2 }
+
+    it { should have_members_of_the_right_model }
+  end
+end
+

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

@@ -8,8 +8,6 @@ describe "Fog::Vcloud::Terremark::Ecloud::PublicIp", :type => :tmrk_ecloud_model
 
   subject { @vcloud }
 
-  it { should respond_to :get_public_ip }
-
   describe :class do
     subject { Fog::Vcloud::Terremark::Ecloud::PublicIp }
 

data/spec/vcloud/terremark/ecloud/requests/configure_internet_service_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
+  subject { @vcloud }
+
+  it { should respond_to :configure_internet_service }
+
+  describe "#configure_internet_service" do
+    before do
+      @public_ip = @vcloud.vdcs[0].public_ips[0]
+      @original_service = @vcloud.get_internet_services(@public_ip.href).body.links.first
+      @service_data = {}
+      @original_service.each_pair { |sym, data| @service_data[sym] = data }
+      @ip_data = { :id => @public_ip.id, :name => @public_ip.name, :href => @public_ip.href.to_s }
+    end
+
+    context "with a valid Internet Service uri and valid data" do
+
+      subject { @vcloud.configure_internet_service(@original_service.href, @service_data, @ip_data) }
+
+      it_should_behave_like "all requests"
+
+      context "with some changed data" do
+        before do
+          @service_data[:description] = "TEST BOOM"
+        end
+        it "should change data" do
+          @original_service.description.should == "Web Servers"
+          result = subject
+          result.body.description.should == "TEST BOOM"
+          @vcloud.get_internet_services(@public_ip.href).body.links.first.description.should == "TEST BOOM"
+        end
+      end
+
+    end
+
+    context "with an internet_services_uri that doesn't exist" do
+      subject { lambda { @vcloud.configure_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @service_data, @ip_data ) } }
+
+      it_should_behave_like "a request for a resource that doesn't exist"
+    end
+  end
+end
+

data/spec/vcloud/terremark/ecloud/requests/get_network_ips_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
+  subject { @vcloud }
+
+  it { should respond_to :get_network_ips }
+
+  describe "#get_network_ips" do
+    context "with a valid VDC network ips_uri" do
+      before { @ips = @vcloud.get_network_ips(URI.parse(@mock_network[:href] + "/ips")) }
+      subject { @ips }
+
+      it_should_behave_like "all requests"
+
+      its(:headers) { should include "Content-Type" }
+      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.ipAddressesList+xml" }
+
+      its(:body) { should be_an_instance_of Struct::TmrkEcloudNetworkIps }
+
+      describe "#body" do
+        describe "#addresses" do
+          subject { @ips.body.addresses }
+
+          it { should have(252).addresses }
+
+          describe "one we know is assigned" do
+            let(:address) { subject[0] }
+
+            specify { address.status.should == "Assigned" }
+            specify { address.server.should == "Broom 1" }
+            specify { address.name.should == "1.2.3.3" }
+
+          end
+
+          describe "one we know is not assigned" do
+            let(:address) { subject[100] }
+
+            specify { address.status.should == "Available" }
+            specify { address.server.should == nil }
+            specify { address.name.should == "1.2.3.103" }
+
+          end
+
+        end
+      end
+    end
+
+    context "with a network ips uri that doesn't exist" do
+      subject { lambda { @vcloud.get_network_ips(URI.parse('https://www.fakey.c/piv8vc99')) } }
+
+      it_should_behave_like "a request for a resource that doesn't exist"
+    end
+  end
+end

data/spec/vcloud/terremark/ecloud/requests/get_network_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Fog::Vcloud, :type => :tmrk_ecloud_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 requests"
+
+      its(:headers) { should include "Content-Type" }
+      its(:body) { should be_an_instance_of Struct::TmrkEcloudNetwork }
+
+      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(:ips_link)      { should be_an_instance_of Struct::VcloudLink }
+        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] }
+
+        describe :configuration do
+          subject { @network.body.configuration }
+
+          its(:gateway) { should == "1.2.3.1" }
+          its(:netmask) { should == "255.255.255.0" }
+        end
+
+        describe :ips_link do
+          subject { @network.body.ips_link }
+          its(:href) { should == URI.parse(@mock_network[:href] + "/ips") }
+          its(:rel)  { should == "down" }
+          its(:type) { should == "application/xml" }
+          its(:name) { should == "IP Addresses" }
+        end
+
+        describe "FenceMode Feature" do
+          subject { @network.body.features.detect { |feature| feature.is_a?(Struct::VcloudNetworkFenceMode) } }
+          its(:mode) { should == "isolated" }
+        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"
+    end
+  end
+end
+

data/tests/aws/requests/ec2/volume_tests.rb

@@ -45,6 +45,8 @@ Shindo.tests('AWS::EC2 | volume requests', ['aws']) do
       data
     end
 
+    AWS[:ec2].volumes.get(@volume_id).wait_for { ready? }
+
     tests('#describe_volumes').formats(@volumes_format) do
       AWS[:ec2].describe_volumes.body
     end
@@ -53,8 +55,6 @@ Shindo.tests('AWS::EC2 | volume requests', ['aws']) do
       AWS[:ec2].describe_volumes.body
     end
 
-    AWS[:ec2].volumes.get(@volume_id).wait_for { ready? }
-
     tests("#attach_volume(#{@server.identity}, #{@volume_id}, '/dev/sdh')").formats(@volume_attachment_format) do
       AWS[:ec2].attach_volume(@server.identity, @volume_id, '/dev/sdh').body
     end

data/tests/helper.rb

@@ -51,6 +51,8 @@ module Shindo
               type = value.first
               if type.is_a?(Hash)
                 valid &&= formats_kernel({:element => element}, {:element => type}, false)
+              elsif type.nil?
+                p "#{key} => #{value}"
               else
                 valid &&= element.is_a?(type)
               end