fog-aws 1.4.1 → 3.27.0

data/tests/requests/iam/server_certificate_tests.rb

@@ -1,130 +0,0 @@
-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
-  }
-  @upload_format = {
-    'Certificate' => @certificate_format,
-    'RequestId' => String
-  }
-  @update_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
-    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
-    private_key_pkcs8 = AWS::IAM::SERVER_CERT_PRIVATE_KEY_PKCS8
-    private_key_mismatch = AWS::IAM::SERVER_CERT_PRIVATE_KEY_MISMATCHED
-
-    tests('empty public key').raises(Fog::AWS::IAM::ValidationError) do
-      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.new.upload_server_certificate(public_key, '', @key_name)
-    end
-
-    tests('invalid public key').raises(Fog::AWS::IAM::MalformedCertificate) do
-      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.new.upload_server_certificate(public_key, 'abcde', @key_name)
-    end
-
-    tests('non-RSA private key').raises(Fog::AWS::IAM::MalformedCertificate) do
-      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_pkcs8, @key_name)
-    end
-
-    tests('mismatched private key').raises(Fog::AWS::IAM::KeyPairMismatch) do
-      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_mismatch, @key_name)
-    end
-
-    tests('format').formats(@upload_format) do
-      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.new.upload_server_certificate(public_key, private_key, @key_name)
-    end
-  end
-
-  tests('#update_server_certificate') do
-    public_key  = AWS::IAM::SERVER_CERT
-    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
-    key_name    = "update-key"
-
-    Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, key_name)
-
-    tests('duplicate name').raises(Fog::AWS::IAM::EntityAlreadyExists) do
-      other_key_name = "other-key-name"
-      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, other_key_name)
-
-      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
-    end
-
-    tests('unknown name').raises(Fog::AWS::IAM::NotFound) do
-      Fog::AWS::IAM.new.update_server_certificate("unknown-key-name", {'NewServerCertificateName' => "other-keyname"})
-    end
-
-    tests('format').formats(@update_format) do
-      Fog::AWS::IAM.new.update_server_certificate(key_name).body
-    end
-
-    tests('updates name') do
-      other_key_name = "successful-update-key-name"
-      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
-      returns(true) { Fog::AWS::IAM.new.get_server_certificate(other_key_name).body['Certificate']['ServerCertificateName'] == other_key_name }
-    end
-  end
-
-  tests('#get_server_certificate').formats(@get_server_certificate_format) do
-    tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
-      Fog::AWS::IAM.new.get_server_certificate("#{@key_name}fake")
-    end
-    Fog::AWS::IAM.new.get_server_certificate(@key_name).body
-  end
-
-  tests('#list_server_certificates').formats(@list_format) do
-    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
-    result
-  end
-
-  tests('#delete_server_certificate').formats(AWS::IAM::Formats::BASIC) do
-    tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
-      Fog::AWS::IAM.new.delete_server_certificate("#{@key_name}fake")
-    end
-    Fog::AWS::IAM.new.delete_server_certificate(@key_name).body
-  end
-
-  Fog::AWS::IAM.new.delete_server_certificate(@key_name_chained)
-end

data/tests/requests/iam/user_policy_tests.rb

@@ -1,45 +0,0 @@
-Shindo.tests('AWS::IAM | user policy requests', ['aws']) do
-
-  Fog::AWS[:iam].create_user('fog_user_policy_tests')
-
-  tests('success') do
-
-    @policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
-
-    tests("#put_user_policy('fog_user_policy_tests', 'fog_policy', #{@policy.inspect})").formats(AWS::IAM::Formats::BASIC) do
-      Fog::AWS[:iam].put_user_policy('fog_user_policy_tests', 'fog_policy', @policy).body
-    end
-
-    @user_policies_format = {
-      'IsTruncated' => Fog::Boolean,
-      'PolicyNames' => [String],
-      'RequestId'   => String
-    }
-
-    tests("#list_user_policies('fog_user_policy_tests')").formats(@user_policies_format) do
-      Fog::AWS[:iam].list_user_policies('fog_user_policy_tests').body
-    end
-
-    @user_policy_format = {
-      'UserName' => String,
-      'PolicyName' => String,
-      'PolicyDocument' => Hash,
-    }
-
-    tests("#get_user_policy('fog_user_policy_tests', 'fog_policy'").formats(@user_policy_format) do
-      Fog::AWS[:iam].get_user_policy('fog_policy', 'fog_user_policy_tests').body['Policy']
-    end
-
-    tests("#delete_user_policy('fog_user_policy_tests', 'fog_policy')").formats(AWS::IAM::Formats::BASIC) do
-      Fog::AWS[:iam].delete_user_policy('fog_user_policy_tests', 'fog_policy').body
-    end
-
-  end
-
-  tests('failure') do
-    test('failing conditions')
-  end
-
-  Fog::AWS[:iam].delete_user('fog_user_policy_tests')
-
-end

data/tests/requests/iam/user_tests.rb

@@ -1,78 +0,0 @@
-Shindo.tests('AWS::IAM | user requests', ['aws']) do
-  service = Fog::AWS[:iam]
-
-  begin
-    service.delete_group('fog_user_tests')
-  rescue Fog::AWS::IAM::NotFound
-  end
-
-  begin
-    service.delete_user('fog_user').body
-  rescue Fog::AWS::IAM::NotFound
-  end
-
-  username = 'fog_user'
-
-  service.create_group('fog_user_tests')
-
-  tests("#create_user('#{username}')").data_matches_schema(AWS::IAM::Formats::CREATE_USER) do
-    service.create_user(username).body
-  end
-
-  tests("#list_users").data_matches_schema(AWS::IAM::Formats::LIST_USER) do
-    service.list_users.body
-  end
-
-  tests("#get_user('#{username}')").data_matches_schema(AWS::IAM::Formats::GET_USER) do
-    service.get_user(username).body
-  end
-
-  tests("#get_user").data_matches_schema(AWS::IAM::Formats::GET_CURRENT_USER) do
-    body = Fog::AWS[:iam].get_user.body
-    if Fog.mocking?
-      tests("correct root arn").returns(true) {
-        body["User"]["Arn"].end_with?(":root")
-      }
-    end
-
-    body
-  end
-
-  tests("#create_login_profile") do
-    service.create_login_profile(username, SecureRandom.base64(10))
-  end
-
-  tests("#get_login_profile") do
-    service.get_login_profile(username)
-  end
-
-  tests("#update_login_profile") do
-    # avoids Fog::AWS::IAM::Error: EntityTemporarilyUnmodifiable => Login Profile for User instance cannot be modified while login profile is being created.
-    if Fog.mocking?
-      service.update_login_profile(username, SecureRandom.base64(10))
-    end
-  end
-
-  tests("#delete_login_profile") do
-    service.delete_login_profile(username)
-  end
-
-  tests("#add_user_to_group('fog_user_tests', '#{username}')").data_matches_schema(AWS::IAM::Formats::BASIC) do
-    service.add_user_to_group('fog_user_tests', username).body
-  end
-
-  tests("#list_groups_for_user('#{username}')").data_matches_schema(AWS::IAM::Formats::GROUPS) do
-    service.list_groups_for_user(username).body
-  end
-
-  tests("#remove_user_from_group('fog_user_tests', '#{username}')").data_matches_schema(AWS::IAM::Formats::BASIC) do
-    service.remove_user_from_group('fog_user_tests', username).body
-  end
-
-  tests("#delete_user('#{username}')").data_matches_schema(AWS::IAM::Formats::BASIC) do
-    service.delete_user(username).body
-  end
-
-  service.delete_group('fog_user_tests')
-
-end

data/tests/requests/iam/versioned_managed_policy_tests.rb

@@ -1,114 +0,0 @@
-Shindo.tests('AWS::IAM | versioned managed policy requests', ['aws']) do
-
-  pending if Fog.mocking?
-
-  tests('success') do
-    @policy = {'Version' => '2012-10-17', "Statement" => [{"Effect" => "Deny", "Action" => "*", "Resource" => "*"}]}
-    @policy_v2 = {'Version' => '2012-10-17', "Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
-
-    @policy_format = {
-      'Arn'        => String,
-      'AttachmentCount' => Integer,
-      'Description' => String,
-      'DefaultVersionId' => String,
-      'IsAttachable' => Fog::Boolean,
-      'Path'       => String,
-      'PolicyId'     => String,
-      'PolicyName'   => String,
-      'CreateDate' => Time,
-      'UpdateDate' => Time
-    }
-
-    create_policy_format = {
-      'RequestId' => String,
-      'Policy' => @policy_format
-    }
-
-    list_policies_format = {
-      'RequestId' => String,
-      'Policies' => [@policy_format],
-      'Marker' => String,
-      'IsTruncated' => Fog::Boolean      
-    }
-
-    versioned_policy_format = {
-        'CreateDate' => Time,
-        'Document' => Hash,
-        'IsDefaultVersion' => Fog::Boolean,
-        'Description' => String
-    }
-
-    create_versioned_policy_format = {
-      'RequestId' => String,
-      'PolicyVersion' => [versioned_policy_format]
-    }
-
-    policy_verions_format = {
-        'CreateDate' => Time,
-        'IsDefaultVersion' => Fog::Boolean,
-        'VersionId' => String
-    }
-
-    list_policy_versions_format = {
-      'RequestId' => String,
-      'Versions' => [policy_verions_format],
-      'Marker' => String,
-      'IsTruncated' => Fog::Boolean      
-    }
-
-    tests("#create_policy('fog_policy')").formats(create_policy_format) do
-      body = Fog::AWS[:iam].create_policy('fog_policy', @policy, '/fog/').body
-      puts body.inspect
-      @policy_arn = body['Policy']['Arn']
-      body
-    end
-
-    tests("#list_policies('fog_policy')").formats(list_policies_format) do
-      body = Fog::AWS[:iam].list_policies('PathPrefix' => '/fog/').body
-      tests('length 1').returns(1) do
-        body['Policies'].length
-      end
-      body
-    end
-
-    tests("#create_versioned_policy('fog_policy')").formats(create_versioned_policy_format) do
-      body = Fog::AWS[:iam].create_versioned_policy(@policy_arn, @policy_v2, true).body
-      puts body.inspect
-      @policy_version_document = body['PolicyVersion']['Document']
-      body
-    end
-
-    tests("#list_policy_versions('fog_policy')").formats(list_policy_versions_format) do
-      body = Fog::AWS[:iam].list_policy_versions(@policy_arn).body
-      tests('length 2').returns(2) do
-        body['Versions'].length
-      end
-      body
-    end
-
-    tests("#set_default_policy_version('fog_policy')").formats(AWS::IAM::Formats::BASIC) do
-      body = Fog::AWS[:iam].set_default_policy_version(@policy_arn, 'v1').body
-      tests('length 2').returns(2) do
-        body['Versions'].length
-      end
-      body
-    end
-
-    tests("#delete_versioned_policy('fog_policy')").formats(AWS::IAM::Formats::BASIC) do
-      body = Fog::AWS[:iam].delete_policy(@policy_arn, 'v2').body
-      puts body.inspect
-      @policy_version_document = body['PolicyVersion']['Document']
-      body
-    end
-
-    tests("#delete_policy('fog_policy')").formats(AWS::IAM::Formats::BASIC) do
-      Fog::AWS[:iam].delete_policy(@policy_arn).body
-    end
-   
-  end
-
-  tests('failure') do
-    test('failing conditions')
-  end
-
-end

data/tests/requests/kinesis/helper.rb

@@ -1,111 +0,0 @@
-class AWS
-  module Kinesis
-
-    def wait_for(&block)
-      Fog.wait_for do
-        block.call.tap do
-          print '.'
-        end
-      end
-    end
-
-    def wait_for_status(stream_name, status)
-      wait_for do
-        Fog::AWS[:kinesis].describe_stream("StreamName" => stream_name).body["StreamDescription"]["StreamStatus"] == status
-      end
-    end
-
-    def delete_if_exists(stream_name)
-      if Fog::AWS[:kinesis].list_streams.body["StreamNames"].include?(stream_name)
-        wait_for_status(stream_name, "ACTIVE")
-        Fog::AWS[:kinesis].delete_stream("StreamName" => @stream_id)
-        wait_for do
-          begin
-            Fog::AWS[:kinesis].describe_stream("StreamName" => stream_name)
-            false
-          rescue Fog::AWS::Kinesis::ResourceNotFound
-            true
-          end
-        end
-      end
-    end
-
-    module Formats # optional keys are commented out
-
-      LIST_STREAMS_FORMAT = {
-        "HasMoreStreams" => Fog::Boolean,
-        "StreamNames" => [
-          String
-        ]
-      }
-
-      DESCRIBE_STREAM_FORMAT = {
-        "StreamDescription" => {
-          "HasMoreShards" => Fog::Boolean,
-          "Shards" => [
-            {
-              #"AdjacentParentShardId" => String,
-              "HashKeyRange" => {
-                "EndingHashKey" => String,
-                "StartingHashKey" => String
-              },
-              #"ParentShardId" => String,
-              "SequenceNumberRange" => {
-                # "EndingSequenceNumber" => String,
-                "StartingSequenceNumber" => String
-              },
-              "ShardId" => String
-            }
-          ],
-          "StreamARN" => String,
-          "StreamName" => String,
-          "StreamStatus" => String
-        }
-      }
-
-      GET_SHARD_ITERATOR_FORMAT = {
-        "ShardIterator" => String
-      }
-
-      PUT_RECORDS_FORMAT = {
-        "FailedRecordCount" => Integer,
-        "Records" => [
-          {
-            # "ErrorCode" => String,
-            # "ErrorMessage" => String,
-            "SequenceNumber" => String,
-            "ShardId" => String
-          }
-        ]
-      }
-
-      PUT_RECORD_FORMAT = {
-        "SequenceNumber" => String,
-        "ShardId" => String
-      }
-
-      GET_RECORDS_FORMAT = {
-        "MillisBehindLatest" => Integer,
-        "NextShardIterator" => String,
-        "Records" => [
-          {
-            "Data" => String,
-            "PartitionKey" => String,
-            "SequenceNumber" => String
-          }
-        ]
-      }
-
-      LIST_TAGS_FOR_STREAM_FORMAT = {
-        "HasMoreTags" => Fog::Boolean,
-        "Tags" => [
-          {
-            "Key" => String,
-            "Value" => String
-          }
-        ]
-      }
-
-    end
-  end
-end

data/tests/requests/kinesis/stream_tests.rb

@@ -1,169 +0,0 @@
-include AWS::Kinesis
-
-Shindo.tests('AWS::Kinesis | stream requests', ['aws', 'kinesis']) do
-  Fog::AWS[:kinesis].reset_data if Fog.mocking?
-
-  @stream_id = 'fog-test-stream'
-
-  delete_if_exists(@stream_id) # ensure we start from a clean slate
-
-  tests("#create_stream").returns("") do
-    Fog::AWS[:kinesis].create_stream("StreamName" => @stream_id).body.tap do
-      wait_for_status(@stream_id, "ACTIVE")
-    end
-  end
-
-  tests("#list_streams").formats(Formats::LIST_STREAMS_FORMAT, false) do
-    Fog::AWS[:kinesis].list_streams.body.tap do
-      returns(true) {
-        Fog::AWS[:kinesis].list_streams.body["StreamNames"].include?(@stream_id)
-      }
-    end
-  end
-
-  tests("#describe_stream") do
-    tests("success").formats(AWS::Kinesis::Formats::DESCRIBE_STREAM_FORMAT) do
-      Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body
-    end
-
-    tests("ResourceNotFound").raises(Fog::AWS::Kinesis::ResourceNotFound) do
-      Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id + "-foo").body
-    end
-  end
-
-  tests("#put_records") do
-    records = [
-      {
-        "Data" => Base64.encode64("foo").chomp!,
-        "PartitionKey" => "1"
-      },
-      {
-        "Data" => Base64.encode64("bar").chomp!,
-        "PartitionKey" => "1"
-      }
-    ]
-
-    tests("success").formats(AWS::Kinesis::Formats::PUT_RECORDS_FORMAT, false) do
-      Fog::AWS[:kinesis].put_records("StreamName" => @stream_id, "Records" => records).body
-    end
-
-    tests("ResourceNotFound").raises(Fog::AWS::Kinesis::ResourceNotFound) do
-      Fog::AWS[:kinesis].put_records("StreamName" => @stream_id + "-foo", "Records" => records).body
-    end
-
-  end
-
-  tests("#put_record").formats(AWS::Kinesis::Formats::PUT_RECORD_FORMAT) do
-    Fog::AWS[:kinesis].put_record("StreamName" => @stream_id, "Data" => Base64.encode64("baz").chomp!, "PartitionKey" => "1").body
-  end
-
-  tests("#get_shard_iterator").formats(AWS::Kinesis::Formats::GET_SHARD_ITERATOR_FORMAT) do
-    first_shard_id = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"].first["ShardId"]
-    Fog::AWS[:kinesis].get_shard_iterator("StreamName" => @stream_id, "ShardId" => first_shard_id, "ShardIteratorType" => "TRIM_HORIZON").body
-  end
-
-  tests("#get_records").formats(AWS::Kinesis::Formats::GET_RECORDS_FORMAT) do
-    first_shard_id = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"].first["ShardId"]
-    shard_iterator = Fog::AWS[:kinesis].get_shard_iterator("StreamName" => @stream_id, "ShardId" => first_shard_id, "ShardIteratorType" => "TRIM_HORIZON").body["ShardIterator"]
-    Fog::AWS[:kinesis].get_records("ShardIterator" => shard_iterator, "Limit" => 1).body
-  end
-
-  tests("#get_records").returns(["foo", "bar"]) do
-    first_shard_id = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"].first["ShardId"]
-    shard_iterator = Fog::AWS[:kinesis].get_shard_iterator("StreamName" => @stream_id, "ShardId" => first_shard_id, "ShardIteratorType" => "TRIM_HORIZON").body["ShardIterator"]
-
-    data = []
-    2.times do
-      response = Fog::AWS[:kinesis].get_records("ShardIterator" => shard_iterator, "Limit" => 1).body
-      response["Records"].each do |record|
-        data << Base64.decode64(record["Data"])
-      end
-      shard_iterator = response["NextShardIterator"]
-    end
-    data
-  end
-
-  tests("#split_shard").returns("") do
-    shard = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"].first
-    shard_id = shard["ShardId"]
-    ending_hash_key = shard["HashKeyRange"]["EndingHashKey"]
-    new_starting_hash_key = (ending_hash_key.to_i / 2).to_s
-
-    result = Fog::AWS[:kinesis].split_shard("StreamName" => @stream_id, "ShardToSplit" => shard_id, "NewStartingHashKey" => new_starting_hash_key).body
-
-    wait_for_status(@stream_id, "ACTIVE")
-    shards = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"]
-    parent_shard = shards.detect{ |shard| shard["ShardId"] == shard_id }
-    child_shards = shards.select{ |shard| shard["ParentShardId"] == shard_id }.sort_by{ |shard| shard["ShardId"] }
-
-    returns(3) { shards.size }
-    returns(2) { child_shards.size }
-    # parent is closed
-    returns(false) { parent_shard["SequenceNumberRange"]["EndingSequenceNumber"].nil? }
-
-    # ensure new ranges are what we expect (mostly for testing the mock)
-    returns([
-              {
-                "StartingHashKey" => "0",
-                "EndingHashKey" => (new_starting_hash_key.to_i - 1).to_s
-              },
-              {
-                "StartingHashKey" => new_starting_hash_key,
-                "EndingHashKey" => ending_hash_key
-              }
-            ]) { child_shards.map{ |shard| shard["HashKeyRange"] } }
-
-    result
-  end
-
-  tests("#merge_shards").returns("") do
-    shards = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"]
-    child_shard_ids = shards.reject{ |shard| shard["SequenceNumberRange"].has_key?("EndingSequenceNumber") }.map{ |shard| shard["ShardId"] }.sort
-    result = Fog::AWS[:kinesis].merge_shards("StreamName" => @stream_id, "ShardToMerge" => child_shard_ids[0], "AdjacentShardToMerge" => child_shard_ids[1]).body
-
-    wait_for_status(@stream_id, "ACTIVE")
-    shards = Fog::AWS[:kinesis].describe_stream("StreamName" => @stream_id).body["StreamDescription"]["Shards"]
-    parent_shards = shards.select{ |shard| child_shard_ids.include?(shard["ShardId"]) }
-    child_shard = shards.detect{ |shard|
-      shard["ParentShardId"] == child_shard_ids[0] &&
-      shard["AdjacentParentShardId"] == child_shard_ids[1]
-    }
-
-    returns(2) { parent_shards.size }
-    returns(false) { child_shard.nil? }
-    returns({
-              "EndingHashKey" => "340282366920938463463374607431768211455",
-              "StartingHashKey" => "0"
-            }) {
-      child_shard["HashKeyRange"]
-    }
-
-    result
-  end
-
-  tests("#add_tags_to_stream").returns("") do
-    Fog::AWS[:kinesis].add_tags_to_stream("StreamName" => @stream_id, "Tags" => {"a" => "1", "b" => "2"}).body
-  end
-
-  tests("#list_tags_for_stream").formats(AWS::Kinesis::Formats::LIST_TAGS_FOR_STREAM_FORMAT) do
-    Fog::AWS[:kinesis].list_tags_for_stream("StreamName" => @stream_id).body.tap do |body|
-      returns({"a" => "1", "b" => "2"}) {
-        body["Tags"].inject({}){ |m, tag| m.merge(tag["Key"] => tag["Value"]) }
-      }
-    end
-  end
-
-  tests("#remove_tags_from_stream").returns("") do
-    Fog::AWS[:kinesis].remove_tags_from_stream("StreamName" => @stream_id, "TagKeys" => %w[b]).body.tap do
-      returns({"a" => "1"}) {
-        body = Fog::AWS[:kinesis].list_tags_for_stream("StreamName" => @stream_id).body
-        body["Tags"].inject({}){ |m, tag| m.merge(tag["Key"] => tag["Value"]) }
-      }
-    end
-  end
-
-  tests("#delete_stream").returns("") do
-    Fog::AWS[:kinesis].delete_stream("StreamName" => @stream_id).body
-  end
-
-end

data/tests/requests/kms/helper.rb

@@ -1,27 +0,0 @@
-class AWS
-  module KMS
-    module Formats
-      BASIC = {
-        'ResponseMetadata' => { 'RequestId' => String }
-      }
-
-      DESCRIBE_KEY = {
-        "KeyMetadata" => {
-          "KeyUsage"     => String,
-          "AWSAccountId" => String,
-          "KeyId"        => String,
-          "Description"  => Fog::Nullable::String,
-          "CreationDate" => Time,
-          "Arn"          => String,
-          "Enabled"      => Fog::Boolean
-        }
-      }
-
-      LIST_KEYS = {
-        "Keys"      => [{ "KeyId" => String, "KeyArn" => String }],
-        "Truncated" => Fog::Boolean,
-        "Marker"    => Fog::Nullable::String
-      }
-    end
-  end
-end