tecnh-fog 0.2.23.vpc

data/spec/slicehost/models/flavors_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../shared_examples/flavors_examples'
+
+describe 'Fog::AWS::Slicehost::Flavors' do
+
+  it_should_behave_like "Flavors"
+
+  subject { @flavor = @flavors.all.first }
+
+  before(:each) do
+    @flavors = Slicehost[:slices].flavors
+  end
+
+end

data/spec/slicehost/models/server_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../shared_examples/server_examples'
+
+describe 'Fog::Slicehost::Server' do
+
+  it_should_behave_like "Server"
+
+  # flavor 1 = 256, image 3 = gentoo 2008.0
+  subject { @server = @servers.new(:flavor_id => 1, :image_id => 3, :name => Time.now.to_i.to_s) }
+
+  before(:each) do
+    @servers = Slicehost[:slices].servers
+  end
+
+  after(:each) do
+    if @server && !@server.new_record?
+      @server.wait_for { ready? }
+      @server.destroy.should be_true
+    end
+  end
+
+  describe "#initialize" do
+
+    it "should remap attributes from parser" do
+      server = @servers.new({
+        'addresses'       => 'addresses',
+        'backup-id'       => 'backup_id',
+        'bw-in'           => 'bw_in',
+        'bw-out'          => 'bw_out',
+        'flavor-id'       => 'flavor_id',
+        'image-id'        => 'image_id',
+        'name'            => 'name',
+        'root-password'   => 'password',
+        'progress'        => 'progress',
+        'status'          => 'status'
+      })
+      server.addresses.should == 'addresses'
+      server.backup_id.should == 'backup_id'
+      server.bw_in.should == 'bw_in'
+      server.bw_out.should == 'bw_out'
+      server.flavor_id.should == 'flavor_id'
+      server.image_id.should == 'image_id'
+      server.name.should == 'name'
+      server.password.should == 'password'
+      server.progress.should == 'progress'
+      server.status.should == 'status'
+    end
+
+  end
+
+end

data/spec/slicehost/models/servers_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../shared_examples/servers_examples'
+
+describe 'Fog::Slicehost::Servers' do
+
+  it_should_behave_like "Servers"
+
+  # flavor 1 = 256, image 3 = gentoo 2008.0
+  subject { @server = @servers.new(:flavor_id => 1, :image_id => 3, :name => Time.now.to_i.to_s) }
+
+  before(:each) do
+    @servers = Slicehost[:slices].servers
+  end
+
+  after(:each) do
+    if @server && !@server.new_record?
+      @server.wait_for { ready? }
+      @server.destroy.should be_true
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,121 @@
+require 'spec'
+require 'open-uri'
+
+current_directory = File.dirname(__FILE__)
+require "#{current_directory}/../lib/fog"
+require "#{current_directory}/../lib/fog/bin"
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+require "#{current_directory}/../lib/fog/vcloud/bin"
+
+module AWS
+  class << self
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        credentials = Fog.credentials.reject do |k, v|
+          ![:aws_access_key_id, :aws_secret_access_key].include?(k)
+        end
+        hash[key] = case key
+        when :ec2
+          Fog::AWS::EC2.new(credentials)
+        when :eu_s3
+          Fog::AWS::S3.new(credentials.merge!(:host => 's3-external-3.amazonaws.com'))
+        when :sdb
+          Fog::AWS::SimpleDB.new(credentials)
+        when :s3
+          Fog::AWS::S3.new(credentials)
+        end
+      end
+      @@connections[service]
+    end
+  end
+end
+
+module Rackspace
+  class << self
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        credentials = Fog.credentials.reject do |k, v|
+          ![:rackspace_api_key, :rackspace_username].include?(k)
+        end
+        hash[key] = case key
+        when :files
+          Fog::Rackspace::Files.new(credentials)
+        when :servers
+          Fog::Rackspace::Servers.new(credentials)
+        end
+      end
+      @@connections[service]
+    end
+  end
+end
+
+module Slicehost
+  class << self
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        credentials = Fog.credentials.reject do |k, v|
+          ![:slicehost_password].include?(k)
+        end
+        hash[key] = case key
+        when :slices
+          Fog::Slicehost.new(credentials)
+        end
+      end
+      @@connections[service]
+    end
+  end
+end
+
+module Bluebox
+  class << self
+    def [](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
+  end
+end
+
+
+def eventually(max_delay = 16, &block)
+  delays = [0]
+  delay_step = 1
+  total = 0
+  while true
+    delay = 1
+    delay_step.times do
+      delay *= 2
+    end
+    delays << delay
+    delay_step += 1
+    break if delay >= max_delay
+  end
+  delays.each do |delay|
+    begin
+      sleep(delay)
+      yield
+      break
+    rescue => error
+      raise error if delay >= max_delay
+    end
+  end
+end
+
+unless defined?(GENTOO_AMI)
+  GENTOO_AMI = 'ami-5ee70037'
+end
+
+def lorem_file
+  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
+end

data/spec/vcloud/bin_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Vcloud do
+  it { should be_initialized }
+
+  it { should have(3).services }
+
+  describe "#registered_services" do
+    subject { Vcloud.registered_services }
+
+    it { should == ":ecloud, :etest, :vcloud" }
+  end
+
+  describe "when indexing it like an array" do
+    describe "with a service that exists" do
+      before do
+        Fog::Vcloud.should_receive(:new).and_return(true)
+      end
+      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 File.dirname(__FILE__) + '/../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; @vcloud.vdcs[0] }
+
+      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], :Limit => @mock_vdc[:cpu][:allocated]}, 
+                                               :Memory =>
+                                                {:Units => "MB", :Allocated => @mock_vdc[:memory][:allocated], :Limit => @mock_vdc[:memory][:allocated]}} }
+      its(:storage_capacity)      { should be_an_instance_of Hash }
+      its(:storage_capacity)      { should == {:Limit => @mock_vdc[:storage][:allocated], :Units=>"MB", :Allocated => @mock_vdc[:storage][:allocated]} }
+
+      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 File.join(File.dirname(__FILE__), '..', '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, "" }
+          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 File.dirname(__FILE__) + '/../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[:info][:href] }
+          it { should have_key_with_value :name, @mock_organization[:info][: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[:href] + "/catalog",
+                                                    :name => vdc[:name] + " Catalog",
+                                                    :rel => "down" },
+                                                  { :type => "application/vnd.vmware.vcloud.tasksList+xml",
+                                                    :href => vdc[:href] + "/tasksList",
+                                                    :name => vdc[:name] + " Tasks List",
+                                                    :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 File.join(File.dirname(__FILE__), '..', '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], :Limit => @mock_vdc[:memory][:allocated] },
+                                             :Cpu => { :Units => "Mhz", :Allocated => @mock_vdc[:cpu][:allocated], :Limit => @mock_vdc[:cpu][:allocated] } } }
+
+          its(:StorageCapacity) { should == {:Units => "MB", :Allocated => @mock_vdc[:storage][:allocated], :Limit => @mock_vdc[:storage][:allocated] } }
+
+          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
+
+