fog 0.1.4 → 0.1.5

data/spec/vcloud/requests/get_organization_spec.rb

@@ -27,12 +27,12 @@ describe Fog::Vcloud, :type => :vcloud_request do
 
         its(:links) { should have(@mock_organization[:vdcs].length * 3).links }
         its(:name) { should == @mock_organization[:info][:name] }
-        its(:href) { should == @mock_organization[:info][:href] }
+        its(:href) { should == URI.parse(@mock_organization[:info][:href]) }
 
         let(:link) { subject.links[0] }
         specify { link.should be_an_instance_of Struct::VcloudLink }
         specify { link.rel.should == "down" }
-        specify { link.href.should == @mock_vdc[:href] }
+        specify { link.href.should == URI.parse(@mock_vdc[:href]) }
         specify { link.type.should == "application/vnd.vmware.vcloud.vdc+xml" }
         specify { link.name.should == @mock_vdc[:name] }
       end

data/spec/vcloud/requests/get_vdc_spec.rb

@@ -11,7 +11,7 @@ describe Fog::Vcloud, :type => :vcloud_request do
 
   describe :get_vdc, :type => :vcloud_request do
     context "with a valid vdc uri" do
-      before { @vdc = @vcloud.get_vdc(@mock_vdc[:href]) }
+      before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc[:href])) }
       subject { @vdc }
 
       it_should_behave_like "all requests"
@@ -30,13 +30,16 @@ describe Fog::Vcloud, :type => :vcloud_request do
         it_should_behave_like "it has a vcloud v0.8 xmlns"
 
         its(:links) { should have(7).links }
+        its(:resource_entities) { should have(3).links }
+        its(:networks) { should have(2).networks }
+
         its(:name) { should == @mock_vdc[:name] }
-        its(:href) { should == @mock_vdc[:href] }
+        its(:href) { should == URI.parse(@mock_vdc[:href]) }
 
         let(:link) { subject.links[0] }
         specify { link.should be_an_instance_of Struct::VcloudLink }
         specify { link.rel.should == "up" }
-        specify { link.href.should == @mock_organization[:info][:href] }
+        specify { link.href.should == URI.parse(@mock_organization[:info][:href]) }
         specify { link.type.should == "application/vnd.vmware.vcloud.org+xml" }
       end
     end

data/spec/vcloud/spec_helper.rb

@@ -80,9 +80,9 @@ shared_examples_for "all login requests" do
         before { @org = @orglist.organizations.first }
         subject { @org }
 
-        it { should be_an_instance_of Struct::VcloudOrgLink }
+        it { should be_an_instance_of Struct::VcloudLink }
 
-        its(:href) { should == @mock_organization[:info][:href] }
+        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" }
 
@@ -102,7 +102,7 @@ end
 shared_examples_for "a vdc catalog link" do
   it_should_behave_like "all rel=down vcloud links"
   it_should_behave_like "all vcloud catalog links"
-  its(:href) { should == @mock_vdc[:href] + "/catalog" }
+  its(:href) { should == URI.parse(@mock_vdc[:href] + "/catalog") }
 end
 
 shared_examples_for "a tmrk vdc" do
@@ -122,14 +122,14 @@ shared_examples_for "the mocked tmrk network links" do
   describe "[0]" do
     subject { @vdc.body.networks[0] }
     it_should_behave_like "a tmrk network link"
-    its(:href) { should == @mock_vdc[:networks][0][:href] }
+    its(:href) { should == URI.parse(@mock_vdc[:networks][0][:href]) }
     its(:name) { should == @mock_vdc[:networks][0][:name] }
   end
 
   describe "[1]" do
     subject { @vdc.body.networks[1] }
     it_should_behave_like "a tmrk network link"
-    its(:href) { should == @mock_vdc[:networks][1][:href] }
+    its(:href) { should == URI.parse(@mock_vdc[:networks][1][:href]) }
     its(:name) { should == @mock_vdc[:networks][1][:name] }
   end
 end
@@ -141,27 +141,29 @@ shared_examples_for "the mocked tmrk resource entity links" do
     subject { @vdc.body.resource_entities[0] }
     it_should_behave_like "a vapp type"
     it_should_behave_like "all vcloud links w/o a rel"
-    its(:href) { should == @mock_vdc[:vms][0][:href] }
+    its(:href) { should == URI.parse(@mock_vdc[:vms][0][:href]) }
     its(:name) { should == @mock_vdc[:vms][0][:name] }
   end
   describe "[1]" do
     subject { @vdc.body.resource_entities[1] }
     it_should_behave_like "a vapp type"
     it_should_behave_like "all vcloud links w/o a rel"
-    its(:href) { should == @mock_vdc[:vms][1][:href] }
+    its(:href) { should == URI.parse(@mock_vdc[:vms][1][:href]) }
     its(:name) { should == @mock_vdc[:vms][1][:name] }
   end
   describe "[2]" do
     subject { @vdc.body.resource_entities[2] }
     it_should_behave_like "a vapp type"
     it_should_behave_like "all vcloud links w/o a rel"
-    its(:href) { should == @mock_vdc[:vms][2][:href] }
+    its(:href) { should == URI.parse(@mock_vdc[:vms][2][:href]) }
     its(:name) { should == @mock_vdc[:vms][2][:name] }
   end
 end
 
 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|
@@ -171,14 +173,48 @@ Spec::Runner.configure do |config|
     @mock_organization = @mock_data[:organizations][0]
     @mock_vdc = @mock_organization[:vdcs][0]
   end
+  config.before(:each, :type => :vcloud_model) do
+    @vcloud = Fog::Vcloud.new
+  end
   config.before(:each, :type => :vcloud_request) do
     @vcloud = Fog::Vcloud.new
   end
   config.before(:each, :type => :tmrk_ecloud_request) do
     @vcloud = Fog::Vcloud.new(:module => "Fog::Vcloud::Terremark::Ecloud")
   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")
   end
 end
 
+Spec::Matchers.define :have_only_these_attributes do |expected|
+  match do |actual|
+    attributes = actual.instance_variable_get('@attributes')
+    attributes.all? { |attribute| expected.include?(attribute) } && ( expected.length == attributes.length )
+  end
+
+  failure_message_for_should do |actual|
+    msg = "Expected: [#{expected.map{|e| ":#{e}"}.join(", ")}]\n"
+    msg += "Got: [#{actual.instance_variable_get('@attributes').map{|a| ":#{a}"}.join(", ")}]"
+    msg
+  end
+end
+
+Spec::Matchers.define :have_identity do |expected|
+  match do |actual|
+    actual.instance_variable_get('@identity').should == expected
+  end
+
+  failure_message_for_should do |actual|
+    "Expected: '#{expected}', but got: '#{actual.instance_variable_get('@identity')}'"
+  end
+end
+
+Spec::Matchers.define :have_members_of_the_right_model do
+  match do |actual|
+    actual.all? { |member| member.is_a?(actual.model) }
+  end
+end

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

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+describe "Fog::Vcloud::Terremark::Ecloud::Vdc", :type => :tmrk_ecloud_model do
+  subject { @vcloud }
+
+  it { should respond_to :get_vdc }
+
+  describe :class do
+    subject { Fog::Vcloud::Terremark::Ecloud::Vdc }
+
+    it { should have_identity :href }
+    it { should have_only_these_attributes [:href, :name, :other_links, :resource_entity_links, :network_links, :cpu_capacity, 
+                                            :storage_capacity, :memory_capacity, :vcloud_type, :xmlns, :description,
+                                            :deployed_vm_quota, :instantiated_vm_quota] }
+  end
+
+  context "with no uri" do
+
+    subject { Fog::Vcloud::Terremark::Ecloud::Vdc.new() }
+
+    its(:href) { should be_nil }
+    its(:identity) { should be_nil }
+  end
+
+  context "as a collection member" do
+    subject { @vcloud.vdcs[0] }
+
+    its(:href)                  { should == URI.parse(@mock_vdc[:href]) }
+    its(:identity)              { should == URI.parse(@mock_vdc[:href]) }
+    its(:name)                  { should == @mock_vdc[:name] }
+    its(:other_links)           { should have(4).items }
+    its(:resource_entity_links) { should have(3).items }
+    its(:network_links)         { should have(2).items }
+ 
+    its(:cpu_capacity)          { should == Struct::VcloudXCapacity.new('hz * 10^6',@mock_vdc[:cpu][:allocated]) }
+    its(:memory_capacity)       { should == Struct::VcloudXCapacity.new('bytes * 2^20',@mock_vdc[:memory][:allocated]) }
+    its(:storage_capacity)      { should == Struct::VcloudXCapacity.new('bytes * 10^9',@mock_vdc[:storage][:allocated], @mock_vdc[:storage][:used]) }
+
+    its(:deployed_vm_quota)     { should == Struct::VcloudXCapacity.new(nil,nil,-1,-1) }
+    its(:instantiated_vm_quota) { should == Struct::VcloudXCapacity.new(nil,nil,-1,-1) }
+ 
+  end
+end

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

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__),'..','..','..','spec_helper')
+
+describe "Fog::Vcloud::Terremark::Ecloud::Vdcs", :type => :tmrk_ecloud_model do
+  subject { @vcloud }
+
+  it { should respond_to :vdcs }
+
+  describe :class do
+    subject { @vcloud.vdcs.class }
+    its(:model)       { should == Fog::Vcloud::Terremark::Ecloud::Vdc }
+    its(:get_request) { should == :get_vdc }
+    its(:all_request) { should be_an_instance_of Proc }
+    its(:vcloud_type) { should == "application/vnd.vmware.vcloud.vdc+xml" }
+  end
+
+  describe :vdcs do
+    subject { @vcloud.vdcs }
+
+    it { should be_an_instance_of Fog::Vcloud::Terremark::Ecloud::Vdcs }
+
+    its(:length) { should == 2 }
+
+    it { should have_members_of_the_right_model }
+  end
+end

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

@@ -7,7 +7,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
 
   describe "#get_vdc" do
     context "with a valid vdc uri" do
-      before { @vdc = @vcloud.get_vdc(@mock_vdc[:href]) }
+      before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc[:href])) }
       subject { @vdc }
 
       it_should_behave_like "all requests"
@@ -33,7 +33,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
         it { should respond_to :instantiated_vm_quota }
 
         its(:name) { should == @mock_vdc[:name] }
-        its(:href) { should == @mock_vdc[:href] }
+        its(:href) { should == URI.parse(@mock_vdc[:href]) }
         its(:description) { should == '' }
 
         describe "#links" do
@@ -51,7 +51,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
             it_should_behave_like "all rel=down vcloud links"
             it_should_behave_like "all tmrk ecloud publicIpList links"
 
-            specify { subject.href.should == @mock_vdc[:href].sub('/vdc','/extensions/vdc') + "/publicIps" }
+            specify { subject.href.should == URI.parse(@mock_vdc[:href].sub('/vdc','/extensions/vdc') + "/publicIps") }
           end
 
           describe "[2]" do
@@ -60,7 +60,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
             it_should_behave_like "all rel=down vcloud links"
             it_should_behave_like "all tmrk ecloud internetServicesList links"
 
-            specify { subject.href.should == @mock_vdc[:href] + "/internetServices" }
+            specify { subject.href.should == URI.parse(@mock_vdc[:href] + "/internetServices") }
           end
 
           describe "[3]" do
@@ -69,7 +69,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
             it_should_behave_like "all rel=down vcloud links"
             it_should_behave_like "all tmrk ecloud firewallAclList links"
 
-            specify { subject.href.should == @mock_vdc[:href].sub('/vdc','/extensions/vdc') + "/firewallAcls" }
+            specify { subject.href.should == URI.parse(@mock_vdc[:href].sub('/vdc','/extensions/vdc') + "/firewallAcls") }
           end
         end
 
@@ -96,7 +96,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
 
         describe "#memory_capacity" do
           subject { @vdc.body.memory_capacity }
-          it { should be_an_instance_of Struct::TmrkEcloudXCapacity }
+          it { should be_an_instance_of Struct::VcloudXCapacity }
           its(:units) { should == "bytes * 2^20" }
           its(:allocated) { should == @mock_vdc[:memory][:allocated] }
           its(:used) { should == nil }
@@ -105,7 +105,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
 
         describe "#deployed_vm_quota" do
           subject { @vdc.body.deployed_vm_quota }
-          it { should be_an_instance_of Struct::TmrkEcloudXCapacity }
+          it { should be_an_instance_of Struct::VcloudXCapacity }
           its(:limit) { should == -1 }
           its(:used) { should == -1 }
           its(:units) { should == nil }
@@ -113,7 +113,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :tmrk_ec
         end
         describe "#instantiated_vm_quota" do
           subject { @vdc.body.instantiated_vm_quota }
-          it { should be_an_instance_of Struct::TmrkEcloudXCapacity }
+          it { should be_an_instance_of Struct::VcloudXCapacity }
           its(:limit) { should == -1 }
           its(:used) { should == -1 }
           its(:units) { should == nil }

data/spec/vcloud/terremark/vcloud/requests/get_vdc_spec.rb

@@ -7,7 +7,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Vcloud module", :type => :tmrk_vc
 
   describe :get_vdc do
     context "with a valid vdc uri" do
-      before { @vdc = @vcloud.get_vdc(@mock_vdc[:href]) }
+      before { @vdc = @vcloud.get_vdc(URI.parse(@mock_vdc[:href])) }
       subject { @vdc }
 
       it_should_behave_like "all requests"
@@ -27,7 +27,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Vcloud module", :type => :tmrk_vc
         it_should_behave_like "a tmrk vdc"
 
         its(:name) { should == @mock_vdc[:name] }
-        its(:href) { should == @mock_vdc[:href] }
+        its(:href) { should == URI.parse(@mock_vdc[:href]) }
 
         describe "#links" do
           subject { @vdc.body.links }
@@ -43,7 +43,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Vcloud module", :type => :tmrk_vc
 
             it_should_behave_like "all rel=down vcloud links"
             it_should_behave_like "all vcloud application/xml types"
-            specify { subject.href.should == @mock_vdc[:href] + "/publicIps" }
+            specify { subject.href.should == URI.parse(@mock_vdc[:href] + "/publicIps") }
           end
 
           describe "#link[2]" do
@@ -51,7 +51,7 @@ describe "Fog::Vcloud, initialized w/ the TMRK Vcloud module", :type => :tmrk_vc
 
             it_should_behave_like "all rel=down vcloud links"
             it_should_behave_like "all vcloud application/xml types"
-            specify { subject.href.should == @mock_vdc[:href] + "/internetServices" }
+            specify { subject.href.should == URI.parse(@mock_vdc[:href] + "/internetServices") }
           end
         end
         describe :networks do

data/tests/aws/helper.rb

@@ -1,11 +1,3 @@
-# Boolean hax
-module Fog
-  module Boolean
-  end
-end
-FalseClass.send(:include, Fog::Boolean)
-TrueClass.send(:include, Fog::Boolean)
-
 module AWS
 
   class << self

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

@@ -47,11 +47,11 @@ Shindo.tests('AWS::EC2 | address requests', ['aws']) do
 
     @address = AWS[:ec2].addresses.create
 
-    tests("#describe_addresses('127.0.0.1')").raises(Fog::AWS::EC2::Error) do
+    tests("#describe_addresses('127.0.0.1')").raises(Fog::AWS::EC2::NotFound) do
       AWS[:ec2].describe_addresses('127.0.0.1')
     end
 
-    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::EC2::Error) do
+    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::EC2::NotFound) do
       AWS[:ec2].associate_address('i-00000000', @address.identity)
     end
 
@@ -59,7 +59,7 @@ Shindo.tests('AWS::EC2 | address requests', ['aws']) do
       AWS[:ec2].associate_address(@server.identity, '127.0.0.1')
     end
 
-    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::AWS::EC2::Error) do
+    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::AWS::EC2::NotFound) do
       AWS[:ec2].associate_address('i-00000000', '127.0.0.1')
     end
 

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

@@ -23,8 +23,8 @@ Shindo.tests('AWS::EC2 | availability zone requests', ['aws']) do
 
   tests('failure') do
 
-    tests("#describe_availability_zones('not-a-zone')").raises(Fog::AWS::EC2::Error) do
-      AWS[:ec2].describe_availability_zones('not-a-zone')
+    tests("#describe_availability_zones('us-east-1e')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].describe_availability_zones('us-east-1e')
     end
 
   end

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

@@ -0,0 +1,122 @@
+Shindo.tests('AWS::EC2 | instance requests', ['aws']) do
+
+  @instance_format = {
+    # 'architecture'    => String,
+    'amiLaunchIndex'      => Integer,
+    'blockDeviceMapping'  => [],
+    'dnsName'             => NilClass,
+    'imageId'             => String,
+    'instanceId'          => String,
+    'instanceState'       => {'code' => Integer, 'name' => String},
+    'instanceType'        => String,
+    # 'ipAddress'           => String,
+    'kernelId'            => String,
+    # 'keyName'             => String,
+    'launchTime'          => Time,
+    'monitoring'          => {'state' => Fog::Boolean},
+    'placement'           => {'availabilityZone' => String},
+    'privateDnsName'      => NilClass,
+    # 'privateIpAddress'    => String,
+    'productCodes'        => [],
+    'ramdiskId'           => String,
+    'reason'              => NilClass,
+    # 'rootDeviceName'      => String,
+    'rootDeviceType'      => String
+  }
+
+  @run_instances_format = {
+    'groupSet'        => [String],
+    'instancesSet'    => [@instance_format],
+    'ownerId'         => String,
+    'requestId'       => String,
+    'reservationId'   => String
+  }
+
+  @describe_instances_format = {
+    'reservationSet'  => [{
+      'groupSet'      => [String],
+      'instancesSet'  => [@instance_format.merge(
+        'architecture'      => String,
+        'dnsName'           => String,
+        'ipAddress'         => String,
+        'privateDnsName'    => String,
+        'privateIpAddress'  => String
+      )],
+      'ownerId'       => String,
+      'reservationId' => String
+    }],
+    'requestId'       => String
+  }
+
+  @get_console_output_format = {
+    'instanceId'  => String,
+    'output'      => NilClass,
+    'requestId'   => String,
+    'timestamp'   => Time
+  }
+
+  @terminate_instances_format = {
+    'instancesSet'  => [{
+      'currentState' => {'code' => Integer, 'name' => String},
+      'instanceId'    => String,
+      'previousState' => {'code' => Integer, 'name' => String},
+    }],
+    'requestId'     => String
+  }
+
+  tests('success') do
+
+    @instance_id = nil
+
+    tests("#run_instances('#{GENTOO_AMI}', 1, 1)").formats(@run_instances_format) do
+      data = AWS[:ec2].run_instances(GENTOO_AMI, 1, 1).body
+      @instance_id = data['instancesSet'].first['instanceId']
+      data
+    end
+
+    AWS[:ec2].servers.get(@instance_id).wait_for { ready? }
+
+    # The format changes depending on state of instance, so this would be brittle
+    # tests("#describe_instances").formats(@describe_instances_format) do
+    #   AWS[:ec2].describe_instances.body
+    # end
+
+    tests("#describe_instances('#{@instance_id}')").formats(@describe_instances_format) do
+      AWS[:ec2].describe_instances(@instance_id).body
+    end
+
+    tests("#get_console_output('#{@instance_id}')").formats(@get_console_output_format) do
+      AWS[:ec2].get_console_output(@instance_id).body
+    end
+
+    tests("#reboot_instances('#{@instance_id}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].reboot_instances(@instance_id).body
+    end
+
+    tests("#terminate_instances('#{@instance_id}')").formats(@terminate_instances_format) do
+      AWS[:ec2].terminate_instances(@instance_id).body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#describe_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_instances('i-00000000')
+    end
+
+    tests("#get_console_output('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].get_console_output('i-00000000')
+    end
+
+    tests("#reboot_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].reboot_instances('i-00000000')
+    end
+
+    tests("#terminate_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].terminate_instances('i-00000000')
+    end
+
+  end
+
+end