fog 0.1.5 → 0.1.6

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

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

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

@@ -0,0 +1,43 @@
+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
+
+  subject { @vcloud }
+
+  it { should respond_to :get_public_ip }
+
+  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
+
+  context "with no uri" do
+
+    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
+
+  context "as a collection member" do
+    subject { @vcloud.vdcs[0].public_ips[0] }
+
+    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::PublicIp }
+
+    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 }
+ 
+  end
+end

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

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

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

@@ -28,6 +28,7 @@ describe "Fog::Vcloud::Terremark::Ecloud::Vdc", :type => :tmrk_ecloud_model do
     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 }
@@ -38,6 +39,9 @@ describe "Fog::Vcloud::Terremark::Ecloud::Vdc", :type => :tmrk_ecloud_model do
 
     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

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
+  subject { @vcloud }
+
+  it { should respond_to :add_internet_service }
+
+  describe "#add_internet_service" do
+    before do
+      @public_ip = @vcloud.vdcs[0].public_ips[0]
+      @new_service_data = { :name => "Test Service",
+                            :protocol => "HTTP",
+                            :port => "80",
+                            :enabled => "true",
+                            :description => "this is a test" }
+    end
+
+    context "with a valid Public IP uri" do
+      it "has the right number of Internet Services before" do
+        before_services = @vcloud.get_internet_services(@public_ip.href)
+        before_services.body.links.should have(2).links
+      end
+
+      subject { @vcloud.add_internet_service(@public_ip.href.to_s + "/internetServices", @new_service_data ) }
+
+      it "has the right number of Internet Services after" do
+        subject
+        @vcloud.get_internet_services(@public_ip.href).body.links.should have(3).links
+      end
+
+      it_should_behave_like "all requests"
+
+      let(:body) { subject.body }
+
+      its(:body) { should be_an_instance_of Struct::TmrkEcloudInternetService }
+      specify { body.href.to_s.should == Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href( { :id => 372 } ) }
+      specify { body.name.should == "Test Service" }
+      specify { body.protocol.should == "HTTP" }
+      specify { body.enabled.should == true }
+      specify { body.description.should == "this is a test" }
+
+      let(:public_ip) { subject.body.public_ip }
+      specify { public_ip.should be_an_instance_of Struct::TmrkEcloudPublicIp }
+      specify { public_ip.name.should == @public_ip.name }
+      specify { public_ip.id.should == @public_ip.id }
+      specify { public_ip.type.should == "application/vnd.tmrk.ecloud.publicIp+xml" }
+
+    end
+
+    context "with a public_ips_uri that doesn't exist" do
+      subject { lambda { @vcloud.add_internet_service(URI.parse('https://www.fakey.c/piv8vc99'), @new_service_data ) } }
+
+      it_should_behave_like "a request for a resource that doesn't exist"
+    end
+  end
+end
+

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
+  subject { @vcloud }
+
+  it { should respond_to :delete_internet_service }
+
+  describe "#delete_internet_service" do
+    before do
+      @public_ip = @vcloud.vdcs[0].public_ips[0]
+      @before_services = @vcloud.get_internet_services(@public_ip.href)
+    end
+
+    context "with a valid internet service uri" do
+      subject { @vcloud.delete_internet_service(@before_services.body.links[0].href) }
+
+      specify { @before_services.body.links.should have(2).links }
+
+      it "has the right number of Internet Services after" do
+        subject
+        after_services = @vcloud.get_internet_services(@public_ip.href)
+        after_services.body.links.should have(1).link
+      end
+
+    end
+
+    context "with a public_ips_uri that doesn't exist" do
+      subject { lambda { @vcloud.delete_internet_service(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_internet_services_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
+  subject { @vcloud }
+
+  it { should respond_to :get_internet_services }
+
+  describe "#get_internet_services" do
+    context "with a valid VDC internet_services_uri" do
+      before { @services = @vcloud.get_internet_services(URI.parse(@mock_vdc[:href] + "/internetServices")) }
+      subject { @services }
+
+      it_should_behave_like "all requests"
+
+      its(:headers) { should include "Content-Type" }
+      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.internetServicesList+xml" }
+
+      its(:body) { should be_an_instance_of Struct::TmrkEcloudList }
+
+      describe "#body" do
+        describe "#links" do
+          subject { @services.body.links }
+
+          it { should have(4).services }
+
+          [0,1,2,3].each do |idx|
+            let(:service) { subject[idx] }
+            let(:mock_service) { @mock_vdc[:public_ips].map { |ip| ip[:services] }.flatten[idx] }
+            let(:mock_ip) { @mock_vdc[:public_ips].detect { |ip| ip[:services].detect { |ipservice| ipservice[:id] == service.id } } }
+            specify { service.should be_an_instance_of Struct::TmrkEcloudInternetService }
+            specify { service.name.should == mock_service[:name] }
+            specify { service.id.should == mock_service[:id] }
+            specify { service.href.should == URI.parse(Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(mock_service)) }
+            specify { service.type.should == "application/vnd.tmrk.ecloud.internetService+xml" }
+            specify { service.public_ip.should be_an_instance_of Struct::TmrkEcloudPublicIp }
+            specify { service.public_ip.name.should == mock_ip[:name] }
+            specify { service.public_ip.id.should == mock_ip[:id] }
+            specify { service.public_ip.type.should == "application/vnd.tmrk.ecloud.publicIp+xml" }
+            specify { service.port.should == mock_service[:port] }
+            specify { service.protocol.should == mock_service[:protocol] }
+            specify { service.enabled.should == mock_service[:enabled] }
+            specify { service.timeout.should == mock_service[:timeout] }
+            specify { service.description.should == mock_service[:description] }
+            specify { service.url_send_string.should == nil }
+            specify { service.http_header.should == nil }
+          end
+        end
+      end
+    end
+
+    context "with a public_ips_uri that doesn't exist" do
+      subject { lambda { @vcloud.get_internet_services(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_public_ip_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ecloud_request do
+  subject { @vcloud }
+
+  it { should respond_to :get_public_ip }
+
+  describe "#get_public_ip" do
+    context "with a valid public_ip_uri" do
+      before do
+        @mock_ip = @mock_vdc[:public_ips].first
+        @public_ip = @vcloud.get_public_ip(URI.parse("#{@base_url}/extensions/publicIp/#{@mock_ip[:id]}"))
+      end
+
+      subject { @public_ip }
+
+      it_should_behave_like "all requests"
+
+      its(:headers) { should include "Content-Type" }
+      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.publicIp+xml" }
+
+      its(:body) { should be_an_instance_of Struct::TmrkEcloudPublicIp }
+
+      describe "#body" do
+        subject { @public_ip.body }
+
+        its(:name) { should == @mock_ip[:name] }
+        its(:href) { should == URI.parse("#{@base_url}/extensions/publicIp/#{@mock_ip[:id]}") }
+        its(:id)   { should == @mock_ip[:id] }
+
+      end
+    end
+
+    context "with a public_ips_uri that doesn't exist" do
+      subject { lambda { @vcloud.get_public_ip(URI.parse('https://www.fakey.c/piv89')) } }
+
+      it_should_behave_like "a request for a resource that doesn't exist"
+    end
+  end
+end

data/spec/vcloud/terremark/ecloud/requests/get_public_ips_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 :get_public_ips }
+
+  describe "#get_public_ips" do
+    context "with a valid public_ips_uri" do
+      before { @public_ips = @vcloud.get_public_ips(URI.parse(@mock_vdc[:href] + "/publicIps")) }
+      subject { @public_ips }
+
+      it_should_behave_like "all requests"
+
+      its(:headers) { should include "Content-Type" }
+      specify { subject.headers['Content-Type'].should == "application/vnd.tmrk.ecloud.publicIpsList+xml" }
+
+      its(:body) { should be_an_instance_of Struct::TmrkEcloudList }
+
+      describe "#body" do
+        describe "#links" do
+          subject { @public_ips.body.links }
+
+          it { should have(3).ips }
+
+          [0,1,2].each do |idx|
+            let(:ip) { subject[idx] }
+            let(:mock_ip) { @mock_vdc[:public_ips][idx] }
+            specify { ip.should be_an_instance_of Struct::TmrkEcloudPublicIp }
+            specify { ip.name.should == mock_ip[:name] }
+            specify { ip.id.should == mock_ip[:id] }
+            specify { ip.href.should == URI.parse("#{@base_url}/extensions/publicIp/#{mock_ip[:id]}") }
+          end
+        end
+      end
+    end
+
+    context "with a public_ips_uri that doesn't exist" do
+      subject { lambda { @vcloud.get_public_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/tests/bluebox/helper.rb

@@ -0,0 +1,26 @@
+module Bluebox
+
+  def self.[](service)
+    @@connections ||= Hash.new do |hash, key|
+      credentials = Fog.credentials.reject do |k,v|
+        ![:bluebox_api_key, :bluebox_customer_id].include?(k)
+      end
+      hash[key] = case key
+      when :blocks
+        Fog::Bluebox.new(credentials)
+      end
+    end
+    @@connections[service]
+  end
+
+  module Formats
+
+    PRODUCT = {
+      'cost'        => Float,
+      'description' => String,
+      'id'          => String
+    }
+
+  end
+
+end

data/tests/bluebox/requests/block_tests.rb

@@ -0,0 +1,68 @@
+Shindo.tests('Bluebox | block requests', ['bluebox']) do
+
+  @block_format = {
+    'cpu'       => Float,
+    'hostname'  => String,
+    'id'        => String,
+    'ips'       => [{'address' => String}],
+    'memory'    => Integer,
+    'product'   => Bluebox::Formats::PRODUCT,
+    'status'    => String,
+    'storage'   => Integer,
+    'template'  => String,
+    
+  }
+
+  tests('success') do
+
+    @product_id   = '94fd37a7-2606-47f7-84d5-9000deda52ae' # 1 GB
+    @template_id  = 'a00baa8f-b5d0-4815-8238-b471c4c4bf72' # Ubuntu 9.10 64bit
+    @password     = 'chunkybacon'
+
+    @block_id = nil
+
+    tests("create_block('#{@product_id}', '#{@template_id}', 'password' => '#{@password}')").formats(@block_format) do
+      data = Bluebox[:blocks].create_block(@product_id, @template_id, 'password' => @password).body
+      @block_id = data['id']
+      data
+    end
+
+    Bluebox[:blocks].servers.get(@block_id).wait_for { ready? }
+
+    tests("get_block('#{@block_id}')").formats(@block_format) do
+      Bluebox[:blocks].get_block(@block_id).body
+    end
+
+    tests("get_blocks").formats([@block_format.reject {|key,value| ['product', 'template'].include?(key)}]) do
+      Bluebox[:blocks].get_blocks.body
+    end
+
+    tests("reboot_block('#{@block_id}')").formats({'status' => String, 'text' => String}) do
+      Bluebox[:blocks].reboot_block(@block_id).body
+    end
+
+    Bluebox[:blocks].servers.get(@block_id).wait_for { ready? }
+
+    tests("destroy_block('#{@block_id})'").formats({'text' => String}) do
+      Bluebox[:blocks].destroy_block(@block_id).body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("get_block('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].get_block('00000000-0000-0000-0000-000000000000')
+    end
+
+    tests("reboot_block('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].reboot_block('00000000-0000-0000-0000-000000000000')
+    end
+
+    tests("destroy_block('00000000-0000-0000-0000-000000000000')").raises(Fog::Bluebox::NotFound) do
+      Bluebox[:blocks].destroy_block('00000000-0000-0000-0000-000000000000')
+    end
+
+  end
+
+end