brightbox-cli 0.14.1 → 0.15.0

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/compute/tag_tests.rb

@@ -13,14 +13,54 @@ Shindo.tests('Fog::Compute[:aws] | tag requests', ['aws']) do
   @volume.wait_for { ready? }
 
   tests('success') do
+    if Fog.mocking?
+      @other_account = Fog::Compute::AWS.new(:aws_access_key_id => 'other', :aws_secret_access_key => 'account')
+      @image_id = Fog::Compute[:aws].register_image('image', 'image', '/dev/sda1').body['imageId']
+    end
+
     tests("#create_tags('#{@volume.identity}', 'foo' => 'bar')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].create_tags(@volume.identity, 'foo' => 'bar').body
     end
 
+    if Fog.mocking?
+      tests("#create_tags('#{@image_id}', 'foo' => 'baz')").formats(AWS::Compute::Formats::BASIC) do
+        Fog::Compute[:aws].create_tags(@image_id, 'foo' => 'baz').body
+      end
+    end
+
     tests('#describe_tags').formats(@tags_format) do
       Fog::Compute[:aws].describe_tags.body
     end
 
+    expected_identities = Fog.mocking? ? [@volume.identity, @image_id] : [@volume.identity]
+    tests('#describe_tags').succeeds do
+      (expected_identities - Fog::Compute[:aws].describe_tags.body['tagSet'].map {|t| t['resourceId'] }).empty?
+    end
+
+    tests("#describe_tags('key' => 'foo', 'value' => 'bar')").returns([@volume.identity]) do
+      Fog::Compute[:aws].describe_tags('key' => 'foo', 'value' => 'bar').body['tagSet'].map {|t| t['resourceId'] }
+    end
+
+    if Fog.mocking?
+      tests("#describe_tags('key' => 'foo', 'value' => 'baz')").returns([@image_id]) do
+        Fog::Compute[:aws].describe_tags('key' => 'foo', 'value' => 'baz').body['tagSet'].map {|t| t['resourceId'] }
+      end
+
+      Fog::Compute[:aws].modify_image_attribute(@image_id, 'Add.UserId' => [@other_account.data[:owner_id]])
+
+      tests("other_account#describe_tags('key' => 'foo', 'value' => 'baz')").returns([]) do
+        @other_account.describe_tags('key' => 'foo', 'value' => 'baz').body['tagSet'].map {|t| t['resourceId'] }
+      end
+
+      tests("other_account#create_tags('#{@image_id}', 'foo' => 'quux')").formats(AWS::Compute::Formats::BASIC) do
+        @other_account.create_tags(@image_id, 'foo' => 'quux').body
+      end
+
+      tests("other_account#describe_tags('key' => 'foo', 'value' => 'quux')").returns([@image_id]) do
+        @other_account.describe_tags('key' => 'foo', 'value' => 'quux').body['tagSet'].map {|t| t['resourceId'] }
+      end
+    end
+
     tests("#delete_tags('#{@volume.identity}', 'foo' => 'bar')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].delete_tags(@volume.identity, 'foo' => 'bar').body
     end

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/elasticache/cache_cluster_tests.rb

@@ -0,0 +1,137 @@
+Shindo.tests('AWS::Elasticache | cache cluster requests', ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    # Randomize the cluster ID so tests can be fequently re-run
+    CLUSTER_ID = "fog-test-cluster-#{rand(999).to_s}" # 20 chars max!
+    NUM_NODES = 2   # Must be > 1, because one of the tests reomves a node!
+
+    tests(
+    '#create_cache_cluster'
+    ).formats(AWS::Elasticache::Formats::SINGLE_CACHE_CLUSTER) do
+      body = AWS[:elasticache].create_cache_cluster(CLUSTER_ID,
+        :num_nodes => NUM_NODES
+      ).body
+      cluster = body['CacheCluster']
+      returns(CLUSTER_ID) { cluster['CacheClusterId'] }
+      returns('creating') { cluster['CacheClusterStatus'] }
+      body
+    end
+
+    tests(
+    '#describe_cache_clusters without options'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_CACHE_CLUSTERS) do
+      body = AWS[:elasticache].describe_cache_clusters.body
+      returns(true, "has #{CLUSTER_ID}") do
+        body['CacheClusters'].any? do |cluster|
+          cluster['CacheClusterId'] == CLUSTER_ID
+        end
+      end
+      # The DESCRIBE_CACHE_CLUSTERS format must include only one cluster
+      # So remove all but the relevant cluster from the response body
+      test_cluster = body['CacheClusters'].delete_if do |cluster|
+        cluster['CacheClusterId'] != CLUSTER_ID
+      end
+      body
+    end
+
+    tests(
+    '#describe_cache_clusters with cluster ID'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_CACHE_CLUSTERS) do
+      body = AWS[:elasticache].describe_cache_clusters(CLUSTER_ID).body
+      returns(1, "size of 1") { body['CacheClusters'].size }
+      returns(CLUSTER_ID, "has #{CLUSTER_ID}") do
+        body['CacheClusters'].first['CacheClusterId']
+      end
+      body
+    end
+
+    Formatador.display_line "Waiting for cluster #{CLUSTER_ID}..."
+    AWS[:elasticache].clusters.get(CLUSTER_ID).wait_for {ready?}
+
+    tests(
+    '#describe_cache_clusters with node info'
+    ).formats(AWS::Elasticache::Formats::CACHE_CLUSTER_RUNNING) do
+      cluster = AWS[:elasticache].describe_cache_clusters(CLUSTER_ID,
+        :show_node_info => true
+      ).body['CacheClusters'].first
+      returns(NUM_NODES, "has #{NUM_NODES} nodes") do
+        cluster['CacheNodes'].count
+      end
+      cluster
+    end
+
+    tests(
+    '#modify_cache_cluster - change a non-pending cluster attribute'
+    ).formats(AWS::Elasticache::Formats::CACHE_CLUSTER_RUNNING) do
+      body = AWS[:elasticache].modify_cache_cluster(CLUSTER_ID,
+        :auto_minor_version_upgrade => false
+      ).body
+      # now check that parameter change is in place
+      returns('false')  { body['CacheCluster']['AutoMinorVersionUpgrade'] }
+      body['CacheCluster']
+    end
+
+    tests(
+    '#reboot_cache_cluster - reboot a node'
+    ).formats(AWS::Elasticache::Formats::CACHE_CLUSTER_RUNNING) do
+      c = AWS[:elasticache].clusters.get(CLUSTER_ID)
+      node_id = c.nodes.last['CacheNodeId']
+      Formatador.display_line "Rebooting node #{node_id}..."
+      body = AWS[:elasticache].reboot_cache_cluster(c.id, [ node_id ]).body
+      returns('rebooting cache cluster nodes') do
+        body['CacheCluster']['CacheClusterStatus']
+      end
+      body['CacheCluster']
+    end
+
+    Formatador.display_line "Waiting for cluster #{CLUSTER_ID}..."
+    AWS[:elasticache].clusters.get(CLUSTER_ID).wait_for {ready?}
+
+    tests(
+    '#modify_cache_cluster - remove a node'
+    ).formats(AWS::Elasticache::Formats::CACHE_CLUSTER_RUNNING) do
+      c = AWS[:elasticache].clusters.get(CLUSTER_ID)
+      node_id = c.nodes.last['CacheNodeId']
+      Formatador.display_line "Removing node #{node_id}..."
+      body = AWS[:elasticache].modify_cache_cluster(c.id,
+      {
+        :num_nodes          => NUM_NODES - 1,
+        :nodes_to_remove    => node_id,
+        :apply_immediately  => true,
+      }).body
+      c.reload
+      returns(NUM_NODES - 1) { c.pending_values['NumCacheNodes'] }
+      body['CacheCluster']
+    end
+
+    Formatador.display_line "Waiting for cluster #{CLUSTER_ID}..."
+    AWS[:elasticache].clusters.get(CLUSTER_ID).wait_for {ready?}
+
+    tests(
+    '#delete_cache_clusters'
+    ).formats(AWS::Elasticache::Formats::CACHE_CLUSTER_RUNNING) do
+      body = AWS[:elasticache].delete_cache_cluster(CLUSTER_ID).body
+      # make sure this particular cluster is in the returned list
+      returns(true, "has #{CLUSTER_ID}") do
+        body['CacheClusters'].any? do |cluster|
+          cluster['CacheClusterId'] == CLUSTER_ID
+        end
+      end
+      # now check that it reports itself as 'deleting'
+      cluster = body['CacheClusters'].find do |cluster|
+        cluster['CacheClusterId'] == CLUSTER_ID
+      end
+      returns('deleting')  { cluster['CacheClusterStatus'] }
+      cluster
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+    # Create a duplicate cluster ID
+    # List a missing cache cluster
+    # Delete a missing cache cluster
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/elasticache/describe_events.rb

@@ -0,0 +1,17 @@
+Shindo.tests('AWS::Elasticache | describe cache cluster events',
+  ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests(
+    '#describe_events'
+    ).formats(AWS::Elasticache::Formats::EVENT_LIST) do
+      AWS[:elasticache].describe_events().body['Events']
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/elasticache/helper.rb

@@ -0,0 +1,68 @@
+class AWS
+  module Elasticache
+    module Formats
+
+      BASIC = {
+        'ResponseMetadata' => {'RequestId' => String}
+      }
+
+      # Cache Security Groups
+      SECURITY_GROUP = {
+        'EC2SecurityGroups'       => Array,
+        'CacheSecurityGroupName'  => String,
+        'Description'             => String,
+        'OwnerId'                 => String,
+      }
+      SINGLE_SECURITY_GROUP = BASIC.merge('CacheSecurityGroup' => SECURITY_GROUP)
+      DESCRIBE_SECURITY_GROUPS = {'CacheSecurityGroups' => [SECURITY_GROUP]}
+
+      # Cache Parameter Groups
+      PARAMETER_GROUP = {
+        'CacheParameterGroupFamily' => String,
+        'CacheParameterGroupName'   => String,
+        'Description'               => String,
+      }
+      SINGLE_PARAMETER_GROUP = BASIC.merge('CacheParameterGroup' => PARAMETER_GROUP)
+      DESCRIBE_PARAMETER_GROUPS = BASIC.merge('CacheParameterGroups' => [PARAMETER_GROUP])
+      MODIFY_PARAMETER_GROUP = {'CacheParameterGroupName' => String }
+      PARAMETER_SET = {
+        'Parameters'                      => Array,
+        'CacheNodeTypeSpecificParameters' => Array,
+      }
+      ENGINE_DEFAULTS = PARAMETER_SET.merge('CacheParameterGroupFamily' => String)
+      # Cache Clusters - more parameters get added as the lifecycle progresses
+      CACHE_CLUSTER = {
+        'AutoMinorVersionUpgrade'     => String,  # actually TrueClass or FalseClass
+        'CacheSecurityGroups'         => Array,
+        'CacheClusterId'              => String,
+        'CacheClusterStatus'          => String,
+        'CacheNodeType'               => String,
+        'Engine'                      => String,
+        'EngineVersion'               => String,
+        'CacheParameterGroup'         => Hash,
+        'NumCacheNodes'               => Integer,
+        'PreferredMaintenanceWindow'  => String,
+        'CacheNodes'                  => Array,
+        'PendingModifiedValues'       => Hash,
+      }
+      CACHE_CLUSTER_RUNNING   = CACHE_CLUSTER.merge({
+        'CacheClusterCreateTime'      => DateTime,
+        'PreferredAvailabilityZone'   => String,
+      })
+      CACHE_CLUSTER_MODIFIED  = CACHE_CLUSTER_RUNNING.merge({
+        'NotificationConfiguration'   => Hash,
+        'PendingModifiedValues'       => Hash,
+      })
+      SINGLE_CACHE_CLUSTER    = BASIC.merge('CacheCluster' => CACHE_CLUSTER)
+      DESCRIBE_CACHE_CLUSTERS = BASIC.merge('CacheClusters' => [CACHE_CLUSTER])
+
+      EVENT = {
+        'Date'                        => DateTime,
+        'Message'                     => String,
+        'SourceIdentifier'            => String,
+        'SourceType'                  => String,
+      }
+      EVENT_LIST = [EVENT]
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/elasticache/parameter_group_tests.rb

@@ -0,0 +1,105 @@
+Shindo.tests('AWS::Elasticache | parameter group requests', ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    name = 'fog-test'
+    description = 'Fog Test Parameter Group'
+
+    tests(
+    '#describe_engine_default_parameters'
+    ).formats(AWS::Elasticache::Formats::ENGINE_DEFAULTS) do
+      response = AWS[:elasticache].describe_engine_default_parameters
+      engine_defaults = response.body['EngineDefaults']
+      returns('memcached1.4') { engine_defaults['CacheParameterGroupFamily'] }
+      engine_defaults
+    end
+
+    tests(
+    '#create_cache_parameter_group'
+    ).formats(AWS::Elasticache::Formats::SINGLE_PARAMETER_GROUP) do
+      body = AWS[:elasticache].create_cache_parameter_group(name, description).body
+      group = body['CacheParameterGroup']
+      returns(name)           { group['CacheParameterGroupName'] }
+      returns(description)    { group['Description'] }
+      returns('memcached1.4') { group['CacheParameterGroupFamily'] }
+      body
+    end
+
+    tests(
+    '#describe_cache_parameters'
+    ).formats(AWS::Elasticache::Formats::PARAMETER_SET) do
+      response = AWS[:elasticache].describe_cache_parameters(name)
+      parameter_set = response.body['DescribeCacheParametersResult']
+      parameter_set
+    end
+
+    tests(
+    '#describe_cache_parameter_groups without options'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_PARAMETER_GROUPS) do
+      body = AWS[:elasticache].describe_cache_parameter_groups.body
+      returns(true, "has #{name}") do
+        body['CacheParameterGroups'].any? do |group|
+          group['CacheParameterGroupName'] == name
+        end
+      end
+      body
+    end
+
+    tests(
+    '#reset_cache_parameter_group completely'
+    ).formats('CacheParameterGroupName' => String) do
+      result = AWS[:elasticache].reset_cache_parameter_group(
+        name
+      ).body['ResetCacheParameterGroupResult']
+      returns(name) {result['CacheParameterGroupName']}
+      result
+    end
+
+    tests(
+    '#modify_cache_parameter_group'
+    ).formats('CacheParameterGroupName' => String) do
+      result = AWS[:elasticache].modify_cache_parameter_group(
+        name, {"chunk_size" => 32}
+      ).body['ModifyCacheParameterGroupResult']
+      returns(name) {result['CacheParameterGroupName']}
+      result
+    end
+
+    # BUG: returns "MalformedInput - Unexpected complex element termination"
+    tests(
+    '#reset_cache_parameter_group with one parameter'
+    ).formats('CacheParameterGroupName' => String) do
+      pending
+      result = AWS[:elasticache].reset_cache_parameter_group(
+        name, ["chunk_size"]
+      ).body['ResetCacheParameterGroupResult']
+      returns(name) {result['CacheParameterGroupName']}
+      result
+    end
+
+    tests(
+    '#describe_cache_parameter_groups with name'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_PARAMETER_GROUPS) do
+      body = AWS[:elasticache].describe_cache_parameter_groups(name).body
+      returns(1, "size of 1") { body['CacheParameterGroups'].size }
+      returns(name, "has #{name}") do
+        body['CacheParameterGroups'].first['CacheParameterGroupName']
+      end
+      body
+    end
+
+    tests(
+    '#delete_cache_parameter_group'
+    ).formats(AWS::Elasticache::Formats::BASIC) do
+      body = AWS[:elasticache].delete_cache_parameter_group(name).body
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+    # Create a duplicate parameter group
+    # List a missing parameter group
+    # Delete a missing parameter group
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/elasticache/security_group_tests.rb

@@ -0,0 +1,107 @@
+Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    name = 'fog-test'
+    description = 'Fog Test Group'
+
+    tests(
+    '#create_cache_security_group'
+    ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+      body = AWS[:elasticache].create_cache_security_group(name, description).body
+      group = body['CacheSecurityGroup']
+      returns(name)        { group['CacheSecurityGroupName'] }
+      returns(description) { group['Description'] }
+      returns([], "no authorized security group") { group['EC2SecurityGroups'] }
+      body
+    end
+
+    tests(
+    '#describe_cache_security_groups without options'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_SECURITY_GROUPS) do
+      body = AWS[:elasticache].describe_cache_security_groups.body
+      returns(true, "has #{name}") do
+        body['CacheSecurityGroups'].any? do |group|
+          group['CacheSecurityGroupName'] == name
+        end
+      end
+      body
+    end
+
+    tests(
+    '#describe_cache_security_groups with name'
+    ).formats(AWS::Elasticache::Formats::DESCRIBE_SECURITY_GROUPS) do
+      body = AWS[:elasticache].describe_cache_security_groups(name).body
+      returns(1, "size of 1") { body['CacheSecurityGroups'].size }
+      returns(name, "has #{name}") do
+        body['CacheSecurityGroups'].first['CacheSecurityGroupName']
+      end
+      body
+    end
+
+    tests('authorization') do
+      ec2_group = Fog::Compute.new(:provider => 'AWS').security_groups.create(
+        :name => 'fog-test-elasticache', :description => 'Fog Test Elasticache'
+      )
+      # Reload to get the owner_id
+      ec2_group.reload
+
+      tests(
+      '#authorize_cache_security_group_ingress'
+      ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+        body = AWS[:elasticache].authorize_cache_security_group_ingress(
+          name, ec2_group.name, ec2_group.owner_id
+        ).body
+        group = body['CacheSecurityGroup']
+        expected_ec2_groups = [{
+          'Status' => 'authorizing', 'EC2SecurityGroupName' => ec2_group.name,
+          'EC2SecurityGroupOwnerId' => ec2_group.owner_id
+        }]
+        returns(expected_ec2_groups, 'has correct EC2 groups') do
+          group['EC2SecurityGroups']
+        end
+        body
+      end
+
+      # Wait for the state to be active
+      Fog.wait_for do
+        response = AWS[:elasticache].describe_cache_security_groups(name)
+        group = response.body['CacheSecurityGroups'].first
+        group['EC2SecurityGroups'].all? {|ec2| ec2['Status'] == 'authorized'}
+      end
+
+      tests(
+      '#revoke_cache_security_group_ingress'
+      ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+        body = AWS[:elasticache].revoke_cache_security_group_ingress(
+          name, ec2_group.name, ec2_group.owner_id
+        ).body
+        group = body['CacheSecurityGroup']
+        expected_ec2_groups = [{
+          'Status' => 'revoking', 'EC2SecurityGroupName' => ec2_group.name,
+          'EC2SecurityGroupOwnerId' => ec2_group.owner_id
+        }]
+        returns(expected_ec2_groups, 'has correct EC2 groups') do
+          group['EC2SecurityGroups']
+        end
+        body
+      end
+
+      ec2_group.destroy
+    end
+
+    tests(
+    '#delete_cache_security_group'
+    ).formats(AWS::Elasticache::Formats::BASIC) do
+      body = AWS[:elasticache].delete_cache_security_group(name).body
+    end
+  end
+
+  tests('failure') do
+    # TODO:
+    # Create a duplicate security group
+    # List a missing security group
+    # Delete a missing security group
+  end
+end

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/iam/server_certificate_tests.rb

@@ -1,17 +1,25 @@
 Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
   @key_name = 'fog-test'
+  @key_name_chained = 'fog-test-chained'
 
   @certificate_format = {
-  'Arn' => String,
-  'Path' => String,
-  'ServerCertificateId' => String,
-  'ServerCertificateName' => String,
-  'UploadDate' => Time
+    'Arn' => String,
+    'Path' => String,
+    'ServerCertificateId' => String,
+    'ServerCertificateName' => String,
+    'UploadDate' => Time
   }
   @upload_format = {
     'Certificate' => @certificate_format,
     'RequestId' => String
   }
+  @get_server_certificate_format = {
+    'Certificate' => @certificate_format,
+    'RequestId' => String
+  }
+  @list_format = {
+    'Certificates' => [@certificate_format]
+  }
 
   tests('#upload_server_certificate') do
     public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
@@ -19,44 +27,55 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
     private_key_mismatch = AWS::IAM::SERVER_CERT_PRIVATE_KEY_MISMATCHED
 
     tests('empty public key').raises(Fog::AWS::IAM::ValidationError) do
-      Fog::AWS[:iam].upload_server_certificate('', private_key, @key_name)
+      Fog::AWS::IAM.new.upload_server_certificate('', private_key, @key_name)
     end
 
     tests('empty private key').raises(Fog::AWS::IAM::ValidationError) do
-      Fog::AWS[:iam].upload_server_certificate(public_key, '', @key_name)
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, '', @key_name)
     end
 
     tests('invalid public key').raises(Fog::AWS::IAM::MalformedCertificate) do
-      Fog::AWS[:iam].upload_server_certificate('abcde', private_key, @key_name)
+      Fog::AWS::IAM.new.upload_server_certificate('abcde', private_key, @key_name)
     end
 
     tests('invalid private key').raises(Fog::AWS::IAM::MalformedCertificate) do
-      Fog::AWS[:iam].upload_server_certificate(public_key, 'abcde', @key_name)
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, 'abcde', @key_name)
     end
 
     tests('mismatched private key').raises(Fog::AWS::IAM::KeyPairMismatch) do
-      Fog::AWS[:iam].upload_server_certificate(public_key, private_key_mismatch, @key_name)
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_mismatch, @key_name)
     end
 
     tests('format').formats(@upload_format) do
-      Fog::AWS[:iam].upload_server_certificate(public_key, private_key, @key_name).body
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, @key_name).body
+    end
+
+    tests('format with chain').formats(@upload_format) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, @key_name_chained, { 'CertificateChain' => public_key }).body
     end
 
     tests('duplicate name').raises(Fog::AWS::IAM::EntityAlreadyExists) do
-      Fog::AWS[:iam].upload_server_certificate(public_key, private_key, @key_name)
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, @key_name)
     end
   end
 
-  tests('#get_server_certificate').formats(@upload_format) do
+  tests('#get_server_certificate').formats(@get_server_certificate_format) do
     tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
-      Fog::AWS[:iam].get_server_certificate("#{@key_name}fake")
+      Fog::AWS::IAM.new.get_server_certificate("#{@key_name}fake")
     end
-    Fog::AWS[:iam].get_server_certificate(@key_name).body
+    Fog::AWS::IAM.new.get_server_certificate(@key_name).body
   end
 
-  @list_format = { 'Certificates' => [@certificate_format] }
   tests('#list_server_certificates').formats(@list_format) do
-    result = Fog::AWS[:iam].list_server_certificates.body
+    result = Fog::AWS::IAM.new.list_server_certificates.body
+    tests('includes key name') do
+      returns(true) { result['Certificates'].any?{|c| c['ServerCertificateName'] == @key_name} }
+    end
+    result
+  end
+
+  tests("#list_server_certificates('path-prefix' => '/'").formats(@list_format) do
+    result = Fog::AWS::IAM.new.list_server_certificates('PathPrefix' => '/').body
     tests('includes key name') do
       returns(true) { result['Certificates'].any?{|c| c['ServerCertificateName'] == @key_name} }
     end
@@ -64,6 +83,8 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
   end
 
   tests('#delete_server_certificate').formats(AWS::IAM::Formats::BASIC) do
-    Fog::AWS[:iam].delete_server_certificate(@key_name).body
+    Fog::AWS::IAM.new.delete_server_certificate(@key_name).body
   end
+
+  Fog::AWS::IAM.new.delete_server_certificate(@key_name_chained)
 end