fog 0.1.0 → 0.1.1

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

@@ -0,0 +1,22 @@
+Shindo.tests('AWS::EC2 | region requests', ['aws']) do
+
+  tests('success') do
+
+    tests("#describe_regions").formats(AWS::EC2::Formats::REGIONS) do
+      AWS[:ec2].describe_regions.body
+    end
+
+    tests("#describe_regions('us-east-1')").formats(AWS::EC2::Formats::REGIONS) do
+      AWS[:ec2].describe_regions('us-east-1').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#describe_regions('not-a-region')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].describe_regions('not-a-region')
+    end
+  end
+
+end

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

@@ -0,0 +1,112 @@
+Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
+
+  @owner_id = AWS[:ec2].describe_security_groups('default').body['securityGroupInfo'].first['ownerId']
+
+  tests('success') do
+
+    tests("#create_security_group('fog_security_group', 'tests group')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].create_security_group('fog_security_group', 'tests group').body
+    end
+
+    tests("#authorize_security_group_ingress({'FromPort' => 80, 'GroupName' => 'fog_security_group', 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'fog_security_group',
+        'IpProtocol' => 'tcp',
+        'ToPort' => 80,
+      }).body
+    end
+
+    tests("#authorize_security_group_ingress({'GroupName' => 'fog_security_group', 'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'GroupName'                   => 'fog_security_group',
+        'SourceSecurityGroupName'     => 'fog_security_group',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      }).body
+    end
+
+    tests("#describe_security_groups").formats(AWS::EC2::Formats::SECURITY_GROUPS) do
+      AWS[:ec2].describe_security_groups.body
+    end
+
+    tests("#describe_security_groups('fog_security_group')").formats(AWS::EC2::Formats::SECURITY_GROUPS) do
+      AWS[:ec2].describe_security_groups('fog_security_group').body
+    end
+
+    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'fog_security_group', 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'fog_security_group',
+        'IpProtocol' => 'tcp',
+        'ToPort' => 80,
+      }).body
+    end
+
+    tests("#revoke_security_group_ingress({'GroupName' => 'fog_security_group', 'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'GroupName'                   => 'fog_security_group',
+        'SourceSecurityGroupName'     => 'fog_security_group',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      }).body
+    end
+
+    tests("#delete_security_group('fog_security_group')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].delete_security_group('fog_security_group').body
+    end
+
+  end
+  tests('failure') do
+
+    @security_group = AWS[:ec2].security_groups.create(:description => 'tests group', :name => 'fog_security_group')
+
+    tests("duplicate #create_security_group(#{@security_group.name}, #{@security_group.description})").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].create_security_group(@security_group.name, @security_group.description)
+    end
+
+    tests("#authorize_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'not_a_group_name',
+        'IpProtocol' => 'tcp',
+        'ToPort' => 80,
+      })
+    end
+
+    tests("#authorize_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'GroupName'                   => 'not_a_group_name',
+        'SourceSecurityGroupName'     => 'not_a_group_name',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      })
+    end
+
+    tests("#describe_security_group('not_a_group_name)").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].describe_security_groups('not_a_group_name')
+    end
+
+    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'not_a_group_name',
+        'IpProtocol' => 'tcp',
+        'ToPort' => 80,
+      })
+    end
+
+    tests("#revoke_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'GroupName'                   => 'not_a_group_name',
+        'SourceSecurityGroupName'     => 'not_a_group_name',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      })
+    end
+
+    tests("#delete_security_group('not_a_group_name')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].delete_security_group('not_a_group_name')
+    end
+
+    @security_group.destroy
+
+  end
+
+end

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

@@ -6,41 +6,34 @@ Shindo.tests('AWS::EC2 | snapshot requests', ['aws']) do
 
     @snapshot_id = nil
 
-    test("#create_snapshot(#{@volume.identity})") do
-      @data = AWS[:ec2].create_snapshot(@volume.identity).body
-      @snapshot_id = @data['snapshotId']
-      has_format(@data, AWS::EC2::Formats::SNAPSHOT.merge('progress' => NilClass, 'requestId' => String))
+    tests("#create_snapshot(#{@volume.identity})").formats(AWS::EC2::Formats::SNAPSHOT.merge('progress' => NilClass, 'requestId' => String)) do
+      data = AWS[:ec2].create_snapshot(@volume.identity).body
+      @snapshot_id = data['snapshotId']
+      data
     end
 
-    test("#describe_snapshots") do
+    tests("#describe_snapshots").formats(AWS::EC2::Formats::SNAPSHOTS) do
       AWS[:ec2].snapshots.get(@snapshot_id).wait_for { ready? }
-      @data = AWS[:ec2].describe_snapshots.body
-      has_format(@data, AWS::EC2::Formats::SNAPSHOTS)
+      AWS[:ec2].describe_snapshots.body
     end
 
-    test("#describe_snapshots('#{@snapshot_id}')") do
-      @data = AWS[:ec2].describe_snapshots(@snapshot_id).body
-      has_format(@data, AWS::EC2::Formats::SNAPSHOTS)
+    tests("#describe_snapshots('#{@snapshot_id}')").formats(AWS::EC2::Formats::SNAPSHOTS) do
+      AWS[:ec2].describe_snapshots(@snapshot_id).body
     end
 
-    test("#delete_snapshots(#{@snapshot_id})") do
-      @data = AWS[:ec2].delete_snapshot(@snapshot_id).body
-      has_format(@data, AWS::EC2::Formats::BASIC)
+    tests("#delete_snapshots(#{@snapshot_id})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].delete_snapshot(@snapshot_id).body
     end
 
   end
   tests ('failure') do
 
-    test("#describe_snapshot('snap-00000000') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].describe_snapshots('snap-00000000')
-      end
+    tests("#describe_snapshot('snap-00000000')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].describe_snapshots('snap-00000000')
     end
 
-    test("#delete_snapshot('snap-00000000') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].delete_snapshot('snap-00000000')
-      end
+    tests("#delete_snapshot('snap-00000000')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].delete_snapshot('snap-00000000')
     end
 
   end

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

@@ -7,37 +7,33 @@ Shindo.tests('AWS::EC2 | volume requests', ['aws']) do
 
     @volume_id = nil
 
-    test('#create_volume') do
-      @data = AWS[:ec2].create_volume(@server.availability_zone, 1).body
-      @volume_id = @data['volumeId']
-      has_format(@data, AWS::EC2::Formats::VOLUME)
+    tests('#create_volume').formats(AWS::EC2::Formats::VOLUME) do
+      data = AWS[:ec2].create_volume(@server.availability_zone, 1).body
+      @volume_id = data['volumeId']
+      data
     end
 
-    test('#describe_volumes') do
-      @data = AWS[:ec2].describe_volumes.body
-      has_format(@data, AWS::EC2::Formats::VOLUMES)
+    tests('#describe_volumes').formats(AWS::EC2::Formats::VOLUMES) do
+      AWS[:ec2].describe_volumes.body
     end
 
-    test("#describe_volumes(#{@volume_id})") do
-      @data = AWS[:ec2].describe_volumes.body
-      has_format(@data, AWS::EC2::Formats::VOLUMES)
+    tests("#describe_volumes(#{@volume_id})").formats(AWS::EC2::Formats::VOLUMES) do
+      AWS[:ec2].describe_volumes.body
     end
 
-    test("#attach_volume(#{@server.identity}, #{@volume_id}, '/dev/sdh')") do
-      @data = AWS[:ec2].attach_volume(@server.identity, @volume_id, '/dev/sdh').body
-      has_format(@data, AWS::EC2::Formats::VOLUME_ATTACHMENT)
+    tests("#attach_volume(#{@server.identity}, #{@volume_id}, '/dev/sdh')").formats(AWS::EC2::Formats::VOLUME_ATTACHMENT) do
+      AWS[:ec2].volumes.get(@volume_id).wait_for { ready? }
+      AWS[:ec2].attach_volume(@server.identity, @volume_id, '/dev/sdh').body
     end
 
-    test("#detach_volume('#{@volume_id}')") do
-      AWS[:ec2].volumes.get(@volume_id).wait_for { state == 'attached' }
-      @data = AWS[:ec2].detach_volume(@volume_id).body
-      has_format(@data, AWS::EC2::Formats::VOLUME_ATTACHMENT)
+    tests("#detach_volume('#{@volume_id}')").formats(AWS::EC2::Formats::VOLUME_ATTACHMENT) do
+      AWS[:ec2].volumes.get(@volume_id).wait_for { state == 'in-use' }
+      AWS[:ec2].detach_volume(@volume_id).body
     end
 
-    test("#delete_volume('#{@volume_id}')") do
+    tests("#delete_volume('#{@volume_id}')").formats(AWS::EC2::Formats::BASIC) do
       AWS[:ec2].volumes.get(@volume_id).wait_for { ready? }
-      @data = AWS[:ec2].delete_volume(@volume_id).body
-      has_format(@data, AWS::EC2::Formats::BASIC)
+      AWS[:ec2].delete_volume(@volume_id).body
     end
 
   end
@@ -45,34 +41,24 @@ Shindo.tests('AWS::EC2 | volume requests', ['aws']) do
 
     @volume = AWS[:ec2].volumes.create(:availability_zone => @server.availability_zone, :size => 1)
 
-    test("#describe_volume('vol-00000000') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].describe_volumes('vol-00000000')
-      end
+    tests("#describe_volume('vol-00000000')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].describe_volumes('vol-00000000')
     end
 
-    test("#attach_volume('i-00000000', '#{@volume.identity}', '/dev/sdh') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].attach_volume('i-00000000', @volume.identity, '/dev/sdh')
-      end
+    tests("#attach_volume('i-00000000', '#{@volume.identity}', '/dev/sdh')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].attach_volume('i-00000000', @volume.identity, '/dev/sdh')
     end
 
-    test("#attach_volume('#{@server.identity}', 'vol-00000000', '/dev/sdh') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].attach_volume(@server.identity, 'vol-00000000', '/dev/sdh')
-      end
+    tests("#attach_volume('#{@server.identity}', 'vol-00000000', '/dev/sdh')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].attach_volume(@server.identity, 'vol-00000000', '/dev/sdh')
     end
 
-    test("#detach_volume('vol-00000000') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].detach_volume('vol-00000000')
-      end
+    tests("#detach_volume('vol-00000000')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].detach_volume('vol-00000000')
     end
 
-    test("#delete_volume('vol-00000000') raises BadRequest error") do
-      has_error(Excon::Errors::BadRequest) do
-        AWS[:ec2].delete_volume('vol-00000000')
-      end
+    tests("#delete_volume('vol-00000000')").raises(Excon::Errors::BadRequest) do
+      AWS[:ec2].delete_volume('vol-00000000')
     end
 
     @volume.destroy

data/tests/helper.rb

@@ -5,45 +5,60 @@ if ENV["FOG_MOCK"] == "true"
   Fog.mock!
 end
 
-def has_error(error, &block)
-  begin
-    yield
-    @formatador.display_line("[red]did not raise #{error}[/]")
-    false
-  rescue error
-    true
-  end
-end
+module Shindo
+  class Tests
 
-def has_format(original_data, original_format)
-  valid = true
-  data = original_data.dup
-  format = original_format.dup
-  for key, value in format
-    valid &&= data.has_key?(key)
-    datum = data.delete(key)
-    format.delete(key)
-    case value
-    when Array
-      valid &&= datum.is_a?(Array)
-      for element in datum
-        type = value.first
-        if type.is_a?(Hash)
-          valid &&= has_format({:element => element}, {:element => type})
+    def formats(format, &block)
+      test('has proper format') do
+        formats_kernel(instance_eval(&block), format)
+      end
+    end
+
+    def succeeds(&block)
+      test('succeeds') do
+        begin
+          instance_eval(&block)
+          true
+        rescue Exception, Interrupt
+          false
+        end
+      end
+    end
+
+    private
+
+    def formats_kernel(original_data, original_format, original = true)
+      valid = true
+      data = original_data.dup
+      format = original_format.dup
+      for key, value in format
+        valid &&= data.has_key?(key)
+        datum = data.delete(key)
+        format.delete(key)
+        case value
+        when Array
+          valid &&= datum.is_a?(Array)
+          for element in datum
+            type = value.first
+            if type.is_a?(Hash)
+              valid &&= formats_kernel({:element => element}, {:element => type}, false)
+            else
+              valid &&= element.is_a?(type)
+            end
+          end
+        when Hash
+          valid &&= datum.is_a?(Hash)
+          valid &&= formats_kernel(datum, value, false)
         else
-          valid &&= element.is_a?(type)
+          valid &&= datum.is_a?(value)
         end
       end
-    when Hash
-      valid &&= datum.is_a?(Hash)
-      valid &&= has_format(datum, value)
-    else
-      valid &&= datum.is_a?(value)
+      valid &&= data.empty? && format.empty?
+      if !valid && original
+        @message = "#{original_data.inspect} does not match #{original_format.inspect}"
+      end
+      valid
     end
+
   end
-  valid &&= data.empty? && format.empty?
-  unless valid
-    @formatador.display_line("[red]#{original_data.inspect} does not match #{original_format.inspect}[/]")
-  end
-  valid
 end

data/tests/rackspace/helper.rb

@@ -35,8 +35,10 @@ module Rackspace
       }
 
       IMAGE = {
+        'created'   => String,
         'id'        => Integer,
         'name'      => String,
+        'progress'  => Integer,
         'serverId'  => Integer,
         'status'    => String,
         'updated'   => String

data/tests/rackspace/requests/servers/create_image_tests.rb

@@ -1,22 +1,20 @@
 Shindo.tests('Rackspace::Servers#create_image', 'rackspace') do
   tests('success') do
 
-    before do
-      @server_id = Rackspace[:servers].create_server(1, 3, 'fogcreateimage').body['server']['id']
-      Fog.wait_for { Rackspace[:servers].get_server_details(@server_id).body['server']['status'] == 'ACTIVE' }
-      @data = Rackspace[:servers].create_image(@server_id).body['image']
-      @image_id = @data['id']
-    end
+    @server = Rackspace[:servers].servers.create(:flavor_id => 1, :image_id => 19, :name => 'foggetserverdetails')
+    @server.wait_for { ready? }
+    @image_id = nil
 
-    after do
-      Rackspace[:servers].delete_server(@server_id)
-      Fog.wait_for { Rackspace[:servers].get_image_details(@image_id).body['image']['status'] == 'ACTIVE' }
-      Rackspace[:servers].delete_image(@image_id)
+    tests("#create_image(#{@server.id})").formats(Rackspace::Servers::Formats::IMAGE.reject {|key,value| key == 'progress'}) do
+      data = Rackspace[:servers].create_image(@server.id).body['image']
+      @image_id = data['id']
+      data
     end
 
-    test('has proper output format') do
-      has_format(@data, Rackspace::Servers::Formats::IMAGE)
-    end
+    @image = Rackspace[:servers].images.get(@image_id)
+    @image.wait_for { ready? }
+    @image.destroy
+    @server.destroy
 
   end
 end

data/tests/rackspace/requests/servers/create_server_tests.rb

@@ -1,20 +1,18 @@
 Shindo.tests('Rackspace::Servers#create_server', 'rackspace') do
   tests('success') do
 
-    before do
-      # 1 => 256MB, 3 => Gentoo
-      @data = Rackspace[:servers].create_server(1, 3).body['server']
-      @server_id = @data['id']
-    end
+    @server_id = nil
 
-    after do
-      Fog.wait_for { Rackspace[:servers].get_server_details(@server_id).body['server']['status'] == 'ACTIVE' }
-      Rackspace[:servers].delete_server(@server_id)
+    tests('#create_server(1, 19)').formats(Rackspace::Servers::Formats::SERVER.merge('adminPass' => String)) do
+      # 1 => 256MB, 19 => Gentoo
+      data = Rackspace[:servers].create_server(1, 19).body['server']
+      @server_id = data['id']
+      data
     end
 
-    test('has proper output format') do
-      has_format(@data, Rackspace::Servers::Formats::SERVER.merge('adminPass' => String))
-    end
+    @server = Rackspace[:servers].servers.get(@server_id)
+    @server.wait_for { ready? }
+    @server.destroy
 
   end
 end