grempe-amazon-ec2 0.2.9

data/test/test_EC2_keypairs.rb

@@ -0,0 +1,123 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 keypairs " do
+
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @create_keypair_response_body = <<-RESPONSE
+      <CreateKeyPairResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <keyName>example-key-name</keyName>
+      <keyFingerprint>1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f</keyFingerprint>
+      <keyMaterial>-----BEGIN RSA PRIVATE KEY-----
+      MIIEoQIBAAKCAQBuLFg5ujHrtm1jnutSuoO8Xe56LlT+HM8v/xkaa39EstM3/aFxTHgElQiJLChp
+      HungXQ29VTc8rc1bW0lkdi23OH5eqkMHGhvEwqa0HWASUMll4o3o/IX+0f2UcPoKCOVUR+jx71Sg
+      5AU52EQfanIn3ZQ8lFW7Edp5a3q4DhjGlUKToHVbicL5E+g45zfB95wIyywWZfeW/UUF3LpGZyq/
+      ebIUlq1qTbHkLbCC2r7RTn8vpQWp47BGVYGtGSBMpTRP5hnbzzuqj3itkiLHjU39S2sJCJ0TrJx5
+      i8BygR4s3mHKBj8l+ePQxG1kGbF6R4yg6sECmXn17MRQVXODNHZbAgMBAAECggEAY1tsiUsIwDl5
+      91CXirkYGuVfLyLflXenxfI50mDFms/mumTqloHO7tr0oriHDR5K7wMcY/YY5YkcXNo7mvUVD1pM
+      ZNUJs7rw9gZRTrf7LylaJ58kOcyajw8TsC4e4LPbFaHwS1d6K8rXh64o6WgW4SrsB6ICmr1kGQI7
+      3wcfgt5ecIu4TZf0OE9IHjn+2eRlsrjBdeORi7KiUNC/pAG23I6MdDOFEQRcCSigCj+4/mciFUSA
+      SWS4dMbrpb9FNSIcf9dcLxVM7/6KxgJNfZc9XWzUw77Jg8x92Zd0fVhHOux5IZC+UvSKWB4dyfcI
+      tE8C3p9bbU9VGyY5vLCAiIb4qQKBgQDLiO24GXrIkswF32YtBBMuVgLGCwU9h9HlO9mKAc2m8Cm1
+      jUE5IpzRjTedc9I2qiIMUTwtgnw42auSCzbUeYMURPtDqyQ7p6AjMujp9EPemcSVOK9vXYL0Ptco
+      xW9MC0dtV6iPkCN7gOqiZXPRKaFbWADp16p8UAIvS/a5XXk5jwKBgQCKkpHi2EISh1uRkhxljyWC
+      iDCiK6JBRsMvpLbc0v5dKwP5alo1fmdR5PJaV2qvZSj5CYNpMAy1/EDNTY5OSIJU+0KFmQbyhsbm
+      rdLNLDL4+TcnT7c62/aH01ohYaf/VCbRhtLlBfqGoQc7+sAc8vmKkesnF7CqCEKDyF/dhrxYdQKB
+      gC0iZzzNAapayz1+JcVTwwEid6j9JqNXbBc+Z2YwMi+T0Fv/P/hwkX/ypeOXnIUcw0Ih/YtGBVAC
+      DQbsz7LcY1HqXiHKYNWNvXgwwO+oiChjxvEkSdsTTIfnK4VSCvU9BxDbQHjdiNDJbL6oar92UN7V
+      rBYvChJZF7LvUH4YmVpHAoGAbZ2X7XvoeEO+uZ58/BGKOIGHByHBDiXtzMhdJr15HTYjxK7OgTZm
+      gK+8zp4L9IbvLGDMJO8vft32XPEWuvI8twCzFH+CsWLQADZMZKSsBasOZ/h1FwhdMgCMcY+Qlzd4
+      JZKjTSu3i7vhvx6RzdSedXEMNTZWN4qlIx3kR5aHcukCgYA9T+Zrvm1F0seQPbLknn7EqhXIjBaT
+      P8TTvW/6bdPi23ExzxZn7KOdrfclYRph1LHMpAONv/x2xALIf91UB+v5ohy1oDoasL0gij1houRe
+      2ERKKdwz0ZL9SWq6VTdhr/5G994CK72fy5WhyERbDjUIdHaK3M849JJuf8cSrvSb4g==
+      -----END RSA PRIVATE KEY-----</keyMaterial>
+      </CreateKeyPairResponse>
+    RESPONSE
+
+    @describe_keypairs_response_body = <<-RESPONSE
+    <DescribeKeyPairsResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <keySet>
+        <item>
+          <keyName>example-key-name</keyName>
+          <keyFingerprint>1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f</keyFingerprint>
+        </item>
+      </keySet>
+    </DescribeKeyPairsResponse>
+    RESPONSE
+
+    @delete_keypair_body = <<-RESPONSE
+    <DeleteKeyPair xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </DeleteKeyPair>
+    RESPONSE
+
+  end
+
+
+  specify "should be able to be created" do
+    @ec2.stubs(:make_request).with('CreateKeyPair', {"KeyName"=>"example-key-name"}).
+      returns stub(:body => @create_keypair_response_body, :is_a? => true)
+
+    @ec2.create_keypair( :key_name => "example-key-name" ).should.be.an.instance_of EC2::Response
+
+    response = @ec2.create_keypair( :key_name => "example-key-name" )
+    response.keyName.should.equal "example-key-name"
+    response.keyFingerprint.should.equal "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f"
+    response.keyMaterial.should.not.equal ""
+    response.keyMaterial.should.not.be.nil
+  end
+
+
+  specify "method create_keypair should reject bad arguments" do
+    @ec2.stubs(:make_request).with('CreateKeyPair', {"KeyName"=>"example-key-name"}).
+      returns stub(:body => @create_keypair_response_body, :is_a? => true)
+
+    lambda { @ec2.create_keypair( :key_name => "example-key-name" ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.create_keypair() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.create_keypair( :key_name => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.create_keypair( :key_name => "" ) }.should.raise(EC2::ArgumentError)
+  end
+
+
+  specify "should be able to be described with describe_keypairs" do
+    @ec2.stubs(:make_request).with('DescribeKeyPairs', {"KeyName.1"=>"example-key-name"}).
+      returns stub(:body => @describe_keypairs_response_body, :is_a? => true)
+    @ec2.describe_keypairs( :key_name => "example-key-name" ).should.be.an.instance_of EC2::Response
+    response = @ec2.describe_keypairs( :key_name => "example-key-name" )
+    response.keySet.item[0].keyName.should.equal "example-key-name"
+    response.keySet.item[0].keyFingerprint.should.equal "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f"
+  end
+
+
+  specify "should be able to be deleted with delete_keypairs" do
+    @ec2.stubs(:make_request).with('DeleteKeyPair', {"KeyName"=>"example-key-name"}).
+      returns stub(:body => @delete_keypair_body, :is_a? => true)
+    @ec2.delete_keypair( :key_name => "example-key-name" ).should.be.an.instance_of EC2::Response
+    response = @ec2.delete_keypair( :key_name => "example-key-name" )
+    response.return.should.equal "true"
+  end
+
+
+  specify "method delete_keypair should reject bad argument" do
+    @ec2.stubs(:make_request).with('DeleteKeyPair', {"KeyName"=>"example-key-name"}).
+      returns stub(:body => @delete_keypair_body, :is_a? => true)
+
+    lambda { @ec2.delete_keypair( :key_name => "example-key-name" ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.delete_keypair() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.delete_keypair( :key_name => nil ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.delete_keypair( :key_name => "" ) }.should.raise(EC2::ArgumentError)
+  end
+
+
+end

data/test/test_EC2_products.rb

@@ -0,0 +1,48 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "An EC2 instance " do
+
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @confirm_product_instance_response_body = <<-RESPONSE
+    <ConfirmProductInstanceResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <result>true</result>
+      <ownerId>254933287430</ownerId>
+    </ConfirmProductInstanceResponse>
+    RESPONSE
+
+  end
+
+
+  specify "should indicate whether a product code is attached to an instance" do
+    @ec2.stubs(:make_request).with('ConfirmProductInstance', {"ProductCode"=>"774F4FF8", "InstanceId"=>"i-10a64379"}).
+       returns stub(:body => @confirm_product_instance_response_body, :is_a? => true)
+
+    @ec2.confirm_product_instance( :product_code => "774F4FF8", :instance_id => "i-10a64379" ).should.be.an.instance_of EC2::Response
+    response = @ec2.confirm_product_instance( :product_code => "774F4FF8", :instance_id => "i-10a64379" )
+    response.ownerId.should.equal "254933287430"
+    response.result.should.equal "true"
+  end
+
+
+  specify "method get_console_output should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.confirm_product_instance() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.confirm_product_instance(:product_code => "774F4FF8", :instance_id => nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.confirm_product_instance(:product_code => "774F4FF8", :instance_id => "") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.confirm_product_instance(:product_code => nil, :instance_id => "i-10a64379") }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.confirm_product_instance(:product_code => "", :instance_id => "i-10a64379") }.should.raise(EC2::ArgumentError)
+  end
+
+
+end

data/test/test_EC2_responses.rb

@@ -0,0 +1,102 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The Response classes " do
+
+
+  setup do
+    @http_xml = <<-RESPONSE
+    <RebootInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </RebootInstancesResponse>
+    RESPONSE
+
+    @response = EC2::Response.parse(:xml => @http_xml)
+
+    # test out adding arbitrary new values to the OpenStruct
+    @response.name = "foo"
+    @response.number = '123'
+  end
+
+
+  specify "should properly run the to_string(short) method for the short version" do
+    # sample response looks like: "#<EC2::Response:0x100A45F2E ...>".  Our response should look
+    # exactly the same, except it should have different hex digits in the middle (after 0x)
+    # that are nine chars long.
+    @response.to_string(true).should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} ...>/
+  end
+
+
+  specify "should properly run the to_string(false) method for the long version" do
+    @response.to_string(false).should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} name=\"foo\" number=\"123\" parent=nil return=\"true\"/
+  end
+
+
+  specify "should properly run the to_string(false) method for the long version when called with no params" do
+    @response.to_string.should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} name=\"foo\" number=\"123\" parent=nil return=\"true\"/
+  end
+
+
+  specify "should provide the same results from to_s as from to_string(false) " do
+    @response.to_s.should =~ /^#<EC2::Response:0x[0-9A-F]{1,9} name=\"foo\" number=\"123\" parent=nil return=\"true\"/
+  end
+
+
+  specify "should be a kind of type OpenStruct" do
+    @response.kind_of?(OpenStruct).should.equal true
+    @response.kind_of?(Enumerable).should.equal true
+  end
+
+
+  specify "should return its members" do
+    @response.members.length.should.equal 6
+    test_array = ["return", "xmlns", "number", "name", "parent", "xml"].sort
+    @response.members.sort.should.equal test_array
+  end
+
+
+  specify "should properly respond to its 'each' method" do
+    answer = @response.each do |f| f ; end
+    answer.name.should.equal "foo"
+    answer.number.should.equal '123'
+  end
+
+
+  specify "should respond to the '[]' method" do
+    @response[:name].should.equal "foo"
+  end
+
+
+  specify "should respond correctly to the '[]=' method and set a variable" do
+    @response[:name].should.equal "foo"
+    @response[:name]="bar"
+    @response[:name].should.equal "bar"
+  end
+
+
+  specify "should respond correctly to the 'each_pair' method" do
+    @response.each_pair {|k,v|
+      case k
+      when "name"
+        v.should.equal "foo"
+      when "number"
+        v.should.equal '123'
+      end
+    }
+  end
+
+  specify "should return the original amazon XML response in the 'xml' attribute of the response object." do
+    @response.xml.should.equal @http_xml
+  end
+
+
+end

data/test/test_EC2_security_groups.rb

@@ -0,0 +1,205 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:grempe@rubyforge.org)
+# Copyright:: Copyright (c) 2007-2008 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "EC2 security groups " do
+
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @create_security_group_response_body = <<-RESPONSE
+    <CreateSecurityGroupResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </CreateSecurityGroupResponse>
+    RESPONSE
+
+    @delete_security_group_response_body = <<-RESPONSE
+    <DeleteSecurityGroupResponse xmlns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </DeleteSecurityGroupResponse>
+    RESPONSE
+
+    @describe_security_groups_response_body = <<-RESPONSE
+    <DescribeSecurityGroupsResponse xm-lns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <securityGroupInfo>
+        <item>
+          <ownerId>UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM</ownerId>
+          <groupName>WebServers</groupName>
+          <groupDescription>Web</groupDescription>
+          <ipPermissions>
+            <item>
+              <ipProtocol>tcp</ipProtocol>
+              <fromPort>80</fromPort>
+              <toPort>80</toPort>
+              <groups/>
+              <ipRanges>
+                <item>
+                  <cidrIp>0.0.0.0/0</cidrIp>
+                </item>
+              </ipRanges>
+            </item>
+          </ipPermissions>
+        </item>
+        <item>
+          <ownerId>UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM</ownerId>
+          <groupName>RangedPortsBySource</groupName>
+          <groupDescription>A</groupDescription>
+          <ipPermissions>
+            <item>
+              <ipProtocol>tcp</ipProtocol>
+              <fromPort>6000</fromPort>
+              <toPort>7000</toPort>
+              <groups/>
+              <ipRanges/>
+            </item>
+          </ipPermissions>
+        </item>
+      </securityGroupInfo>
+    </DescribeSecurityGroupsResponse>
+    RESPONSE
+
+    @authorize_security_group_ingress_response_body = <<-RESPONSE
+    <AuthorizeSecurityGroupIngressResponse xm-lns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </AuthorizeSecurityGroupIngressResponse>
+    RESPONSE
+
+    @revoke_security_group_ingress_response_body = <<-RESPONSE
+    <RevokeSecurityGroupIngressResponse xm-lns="http://ec2.amazonaws.com/doc/2007-03-01">
+      <return>true</return>
+    </RevokeSecurityGroupIngressResponse>
+    RESPONSE
+
+  end
+
+
+  specify "should be able to be created" do
+    @ec2.stubs(:make_request).with('CreateSecurityGroup', {"GroupName"=>"WebServers", "GroupDescription"=>"Web"}).
+      returns stub(:body => @create_security_group_response_body, :is_a? => true)
+    @ec2.create_security_group( :group_name => "WebServers", :group_description => "Web" ).should.be.an.instance_of EC2::Response
+  end
+
+
+  specify "method create_security_group should reject bad arguments" do
+    @ec2.stubs(:make_request).with('CreateSecurityGroup', {"GroupName"=>"WebServers", "GroupDescription"=>"Web"}).
+      returns stub(:body => @create_security_group_response_body, :is_a? => true)
+
+    lambda { @ec2.create_security_group( :group_name => "WebServers", :group_description => "Web" ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.create_security_group() }.should.raise(EC2::ArgumentError)
+
+    # :group_name can't be nil or empty
+    lambda { @ec2.create_security_group( :group_name => "", :group_description => "Web" ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.create_security_group( :group_name => nil, :group_description => "Web" ) }.should.raise(EC2::ArgumentError)
+
+    # :group_description can't be nil or empty
+    lambda { @ec2.create_security_group( :group_name => "WebServers", :group_description => "" ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.create_security_group( :group_name => "WebServers", :group_description => nil ) }.should.raise(EC2::ArgumentError)
+  end
+
+
+  specify "should be able to be deleted" do
+    @ec2.stubs(:make_request).with('DeleteSecurityGroup', {"GroupName"=>"WebServers"}).
+      returns stub(:body => @delete_security_group_response_body, :is_a? => true)
+    @ec2.delete_security_group( :group_name => "WebServers" ).should.be.an.instance_of EC2::Response
+  end
+
+
+  specify "method delete_security_group should reject bad arguments" do
+    @ec2.stubs(:make_request).with('DeleteSecurityGroup', {"GroupName"=>"WebServers"}).
+      returns stub(:body => @delete_security_group_response_body, :is_a? => true)
+
+    lambda { @ec2.delete_security_group( :group_name => "WebServers" ) }.should.not.raise(EC2::ArgumentError)
+    lambda { @ec2.delete_security_group() }.should.raise(EC2::ArgumentError)
+
+    # :group_name can't be nil or empty
+    lambda { @ec2.delete_security_group( :group_name => "" ) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.delete_security_group( :group_name => nil ) }.should.raise(EC2::ArgumentError)
+  end
+
+
+  specify "should be able to be described with describe_security_groups" do
+    @ec2.stubs(:make_request).with('DescribeSecurityGroups', { "GroupName.1" => "WebServers", "GroupName.2" => "RangedPortsBySource" }).
+      returns stub(:body => @describe_security_groups_response_body, :is_a? => true)
+    @ec2.describe_security_groups( :group_name => ["WebServers", "RangedPortsBySource"] ).should.be.an.instance_of EC2::Response
+
+    response = @ec2.describe_security_groups( :group_name => ["WebServers", "RangedPortsBySource"] )
+
+    response.securityGroupInfo.item[0].ownerId.should.equal "UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM"
+    response.securityGroupInfo.item[0].groupName.should.equal "WebServers"
+    response.securityGroupInfo.item[0].groupDescription.should.equal "Web"
+    response.securityGroupInfo.item[0].ipPermissions.item[0].ipProtocol.should.equal "tcp"
+    response.securityGroupInfo.item[0].ipPermissions.item[0].fromPort.should.equal "80"
+    response.securityGroupInfo.item[0].ipPermissions.item[0].toPort.should.equal "80"
+    response.securityGroupInfo.item[0].ipPermissions.item[0].groups.should.be.nil
+    response.securityGroupInfo.item[0].ipPermissions.item[0].ipRanges.item[0].cidrIp.should.equal "0.0.0.0/0"
+
+    response.securityGroupInfo.item[1].ownerId.should.equal "UYY3TLBUXIEON5NQVUUX6OMPWBZIQNFM"
+    response.securityGroupInfo.item[1].groupName.should.equal "RangedPortsBySource"
+    response.securityGroupInfo.item[1].groupDescription.should.equal "A"
+    response.securityGroupInfo.item[1].ipPermissions.item[0].ipProtocol.should.equal "tcp"
+    response.securityGroupInfo.item[1].ipPermissions.item[0].fromPort.should.equal "6000"
+    response.securityGroupInfo.item[1].ipPermissions.item[0].toPort.should.equal "7000"
+    response.securityGroupInfo.item[1].ipPermissions.item[0].groups.should.be.nil
+    response.securityGroupInfo.item[1].ipPermissions.item[0].ipRanges.should.be.nil
+  end
+
+
+  specify "method describe_security_groups should reject bad arguments" do
+    @ec2.stubs(:make_request).with('DescribeSecurityGroups', {"GroupName.1"=>"WebServers"}).
+      returns stub(:body => @describe_security_groups_response_body, :is_a? => true)
+
+      lambda { @ec2.describe_security_groups( :group_name => "WebServers" ) }.should.not.raise(EC2::ArgumentError)
+
+  end
+
+
+  specify "permissions should be able to be added to a security group with authorize_security_group_ingress." do
+    @ec2.stubs(:make_request).with('AuthorizeSecurityGroupIngress', { "GroupName"=>"WebServers",
+                                                                      "IpProtocol"=>"tcp",
+                                                                      "FromPort"=>"8000",
+                                                                      "ToPort"=>"80",
+                                                                      "CidrIp"=>"0.0.0.0/24",
+                                                                      "SourceSecurityGroupName"=>"Source SG Name",
+                                                                      "SourceSecurityGroupOwnerId"=>"123"}).
+      returns stub(:body => @authorize_security_group_ingress_response_body, :is_a? => true)
+
+    @ec2.authorize_security_group_ingress( :group_name => "WebServers",
+                                           :ip_protocol => "tcp",
+                                           :from_port => "8000",
+                                           :to_port => "80",
+                                           :cidr_ip => "0.0.0.0/24",
+                                           :source_security_group_name => "Source SG Name",
+                                           :source_security_group_owner_id => "123"
+                                           ).should.be.an.instance_of EC2::Response
+  end
+
+
+  specify "permissions should be able to be revoked from a security group with revoke_security_group_ingress." do
+    @ec2.stubs(:make_request).with('RevokeSecurityGroupIngress', { "GroupName"=>"WebServers",
+                                                                   "IpProtocol"=>"tcp",
+                                                                   "FromPort"=>"8000",
+                                                                   "ToPort"=>"80",
+                                                                   "CidrIp"=>"0.0.0.0/24",
+                                                                   "SourceSecurityGroupName"=>"Source SG Name",
+                                                                   "SourceSecurityGroupOwnerId"=>"123"}).
+      returns stub(:body => @revoke_security_group_ingress_response_body, :is_a? => true)
+
+    @ec2.revoke_security_group_ingress( :group_name => "WebServers",
+                                        :ip_protocol => "tcp",
+                                        :from_port => "8000",
+                                        :to_port => "80",
+                                        :cidr_ip => "0.0.0.0/24",
+                                        :source_security_group_name => "Source SG Name",
+                                        :source_security_group_owner_id => "123"
+                                        ).should.be.an.instance_of EC2::Response
+  end
+
+end