fog-aws 1.4.1 → 3.27.0

data/tests/requests/ecs/task_tests.rb

@@ -1,145 +0,0 @@
-require 'fog/json'
-
-Shindo.tests('AWS::ECS | task requests', ['aws', 'ecs']) do
-
-  Fog::AWS[:ecs].reset_data
-
-  tests('success') do
-
-    tests("#list_tasks").formats(AWS::ECS::Formats::LIST_TASKS) do
-      result = Fog::AWS[:ecs].list_tasks.body
-      list_instances_arns = result['ListTasksResult']['taskArns']
-      returns(true) { list_instances_arns.empty? }
-      result
-    end
-
-    tests("#run_task").formats(AWS::ECS::Formats::RUN_TASK) do
-      task_def_params = Fog::JSON.decode(IO.read(AWS::ECS::Samples::TASK_DEFINITION_1))
-      result1 = Fog::AWS[:ecs].register_task_definition(task_def_params).body
-      task_def = result1['RegisterTaskDefinitionResult']['taskDefinition']
-      task_def_arn = task_def['taskDefinitionArn']
-
-      result2 = Fog::AWS[:ecs].run_task('taskDefinition' => task_def_arn).body
-      task = result2['RunTaskResult']['tasks'].first
-      returns(true) { task.has_key?('containerInstanceArn') }
-      returns(true) { task['containers'].size.eql?(2) }
-      returns(true) { task['desiredStatus'].eql?('RUNNING') }
-      returns(true) { task['taskDefinitionArn'].eql?(task_def_arn) }
-      result2
-    end
-
-    tests("#describe_tasks").formats(AWS::ECS::Formats::DESCRIBE_TASKS) do
-      result1 = Fog::AWS[:ecs].list_tasks.body
-      task_arn = result1['ListTasksResult']['taskArns'].first
-
-      result2 = Fog::AWS[:ecs].describe_tasks('tasks' => task_arn).body
-      task = result2['DescribeTasksResult']['tasks'].first
-      returns(true) { task['taskArn'].eql?(task_arn) }
-      returns(true) { task['containers'].size.eql?(2) }
-      returns(true) { task['desiredStatus'].eql?('RUNNING') }
-      result2
-    end
-
-    tests("#list_tasks").formats(AWS::ECS::Formats::LIST_TASKS) do
-      result = Fog::AWS[:ecs].list_tasks.body
-      list_instances_arns = result['ListTasksResult']['taskArns']
-      returns(false) { list_instances_arns.empty? }
-      result
-    end
-
-    tests("#stop_task").formats(AWS::ECS::Formats::STOP_TASK) do
-      result1 = Fog::AWS[:ecs].list_tasks.body
-      task_arn = result1['ListTasksResult']['taskArns'].first
-
-      result2 = Fog::AWS[:ecs].stop_task('task' => task_arn).body
-      task = result2['StopTaskResult']['task']
-      returns(true) { task['taskArn'].eql?(task_arn) }
-      returns(true) { task['containers'].size.eql?(2) }
-      returns(true) { task['desiredStatus'].eql?('STOPPED') }
-      result2
-    end
-
-    tests("#start_task").formats(AWS::ECS::Formats::START_TASK) do
-      owner_id = Fog::AWS::Mock.owner_id
-      container_instance_path = "container-instance/#{Fog::UUID.uuid}"
-      region = "us-east-1"
-      container_instance_arn = Fog::AWS::Mock.arn('ecs', owner_id, container_instance_path, region)
-
-      task_def_params = Fog::JSON.decode(IO.read(AWS::ECS::Samples::TASK_DEFINITION_1))
-      result1 = Fog::AWS[:ecs].register_task_definition(task_def_params).body
-      task_def = result1['RegisterTaskDefinitionResult']['taskDefinition']
-      task_def_arn = task_def['taskDefinitionArn']
-
-      result2 = Fog::AWS[:ecs].start_task(
-        'taskDefinition' => task_def_arn,
-        'containerInstances' => container_instance_arn
-      ).body
-      task = result2['StartTaskResult']['tasks'].first
-
-      returns(true) { task['containerInstanceArn'].eql?(container_instance_arn) }
-      returns(true) { task['containers'].size.eql?(2) }
-      returns(true) { task['desiredStatus'].eql?('RUNNING') }
-      returns(true) { task['taskDefinitionArn'].eql?(task_def_arn) }
-
-      result2
-    end
-
-    tests("#list_tasks").formats(AWS::ECS::Formats::LIST_TASKS) do
-      result = Fog::AWS[:ecs].list_tasks.body
-      list_instances_arns = result['ListTasksResult']['taskArns']
-      returns(false) { list_instances_arns.empty? }
-      result
-    end
-
-  end
-
-  tests('failures') do
-
-    tests("#describe_tasks nonexistent") do
-      task_arn = "arn:aws:ecs:us-west-2:938269302734:task/6893440f-2165-47aa-8cfa-b2f413a26f00"
-      result = Fog::AWS[:ecs].describe_tasks('tasks' => task_arn).body
-    end
-
-    tests('describe_tasks without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].describe_tasks.body
-    end
-
-    tests('#run_task without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].run_task.body
-    end
-
-    tests('#run_task nonexistent').raises(Fog::AWS::ECS::Error) do
-      task_def_arn = "arn:aws:ecs:us-west-2:539573770077:task-definition/foo-xanadu-app-static:33"
-      response = Fog::AWS[:ecs].run_task('taskDefinition' => task_def_arn).body
-    end
-
-    tests('#start_task without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].start_task.body
-    end
-
-    tests('#start_task with missing params').raises(Fog::AWS::ECS::Error) do
-      task_def_arn = "arn:aws:ecs:us-west-2:539573770077:task-definition/foo-xanadu-app-static:33"
-      response = Fog::AWS[:ecs].start_task('taskDefinition' => task_def_arn).body
-    end
-
-    tests('#start_task nonexistent').raises(Fog::AWS::ECS::Error) do
-      task_def_arn = "arn:aws:ecs:us-west-2:539573770077:task-definition/foo-xanadu-app-static:33"
-      container_instance_arn = "arn:aws:ecs:us-west-2:938269302734:container-instance/6893440f-2165-47aa-8cfa-b2f413a26f00"
-      response = Fog::AWS[:ecs].start_task(
-        'taskDefinition' => task_def_arn,
-        'containerInstances' => container_instance_arn
-      ).body
-    end
-
-    tests('#stop_task without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].stop_task.body
-    end
-
-    tests('#stop_task nonexistent params').raises(Fog::AWS::ECS::Error) do
-      task_arn = "arn:aws:ecs:us-west-2:938269302734:task/6893440f-2165-47aa-8cfa-b2f413a26f00"
-      response = Fog::AWS[:ecs].stop_task('task' => task_arn).body
-    end
-
-  end
-
-end

data/tests/requests/efs/file_system_tests.rb

@@ -1,152 +0,0 @@
-Shindo.tests('AWS::EFS | file systems', ['aws', 'efs']) do
-  suffix = rand(65535).to_s(16)
-
-  @creation_token = "fogtest#{suffix}"
-
-  tests('success') do
-    tests("#create_file_system('#{@creation_token}')").formats(AWS::EFS::Formats::FILE_SYSTEM_FORMAT) do
-      result = Fog::AWS[:efs].create_file_system(@creation_token).body
-      returns('creating') { result['LifeCycleState'] }
-      result
-    end
-
-    tests("#describe_file_systems").formats(AWS::EFS::Formats::DESCRIBE_FILE_SYSTEMS_RESULT) do
-      Fog::AWS[:efs].describe_file_systems.body
-    end
-
-    tests("#describe_file_systems(creation_token: #{@creation_token})").formats(AWS::EFS::Formats::DESCRIBE_FILE_SYSTEMS_RESULT) do
-      result = Fog::AWS[:efs].describe_file_systems(:creation_token => @creation_token).body
-      returns(@creation_token) { result["FileSystems"].first["CreationToken"] }
-      result
-    end
-
-    file_system_id = Fog::AWS[:efs].describe_file_systems(:creation_token => @creation_token).body["FileSystems"].first["FileSystemId"]
-    file_system = Fog::AWS[:efs].file_systems.get(file_system_id)
-
-    tests("#describe_file_systems(id: #{file_system_id})").formats(AWS::EFS::Formats::DESCRIBE_FILE_SYSTEMS_RESULT) do
-      Fog::AWS[:efs].describe_file_systems(:id => file_system_id).body
-    end
-
-    if Fog.mocking?
-      vpc    = Fog::Compute[:aws].vpcs.create(:cidr_block => "10.0.0.0/16")
-      subnet = Fog::Compute[:aws].subnets.create(
-        :vpc_id     => vpc.id,
-        :cidr_block => "10.0.1.0/24"
-      )
-      default_security_group = Fog::Compute[:aws].security_groups.detect { |sg| sg.description == 'default group' }
-    else
-      vpc = Fog::Compute[:aws].vpcs.first
-      subnet = vpc.subnets.first
-      default_security_group = Fog::Compute[:aws].security_groups.detect { |sg| sg.description == 'default VPC security group' }
-    end
-
-    security_group = Fog::Compute[:aws].security_groups.create(
-      :vpc_id      => vpc.id,
-      :name        => "fog#{suffix}",
-      :description => "fog#{suffix}"
-    )
-
-    raises(Fog::AWS::EFS::InvalidSubnet, "invalid subnet ID: foobar#{suffix}") do
-      Fog::AWS[:efs].create_mount_target(file_system_id, "foobar#{suffix}")
-    end
-
-    raises(Fog::AWS::EFS::NotFound, "invalid file system ID: foobar#{suffix}") do
-      Fog::AWS[:efs].create_mount_target("foobar#{suffix}", subnet.identity)
-    end
-
-    if Fog.mocking?
-      tests("#create_mount_target") do
-        Fog::AWS[:efs].data[:file_systems][file_system_id]["LifeCycleState"] = 'creating'
-        raises(Fog::AWS::EFS::IncorrectFileSystemLifeCycleState) do
-          Fog::AWS[:efs].create_mount_target(file_system_id, subnet.identity)
-        end
-
-        Fog::AWS[:efs].data[:file_systems][file_system_id]["LifeCycleState"] = 'available'
-      end
-    end
-
-    raises(Fog::AWS::EFS::NotFound, "invalid security group ID: foobar#{suffix}") do
-      Fog::AWS[:efs].create_mount_target(file_system_id, subnet.identity, 'SecurityGroups' => ["foobar#{suffix}"])
-    end
-
-    tests("#create_mount_target(#{file_system_id}, #{subnet.identity})").formats(AWS::EFS::Formats::MOUNT_TARGET_FORMAT) do
-      Fog::AWS[:efs].create_mount_target(file_system_id, subnet.identity).body
-    end
-
-    tests("#describe_mount_targets(file_system_id: #{file_system_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGETS_RESULT) do
-      Fog::AWS[:efs].describe_mount_targets(:file_system_id => file_system_id).body
-    end
-
-    mount_target_id = Fog::AWS[:efs].describe_mount_targets(:file_system_id => file_system_id).body["MountTargets"].first["MountTargetId"]
-
-    tests("#describe_mount_target_security_groups(#{mount_target_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGET_SECURITY_GROUPS_FORMAT) do
-      result = Fog::AWS[:efs].describe_mount_target_security_groups(mount_target_id).body
-      returns([default_security_group.group_id]) { result["SecurityGroups"] }
-      result
-    end
-
-    raises(Fog::AWS::EFS::Error, 'Must provide at least one security group.') do
-      Fog::AWS[:efs].modify_mount_target_security_groups(mount_target_id, [])
-    end
-
-    tests("#modify_mount_target_security_groups(#{mount_target_id}, [#{security_group.group_id}])") do
-      returns(204) do
-        Fog::AWS[:efs].modify_mount_target_security_groups(mount_target_id, [security_group.group_id]).status
-      end
-    end
-
-    Fog.wait_for { Fog::AWS[:efs].describe_mount_target_security_groups(mount_target_id).body["SecurityGroups"] != [default_security_group.group_id] }
-
-    tests("#describe_mount_target_security_groups(#{mount_target_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGET_SECURITY_GROUPS_FORMAT) do
-      result = Fog::AWS[:efs].describe_mount_target_security_groups(mount_target_id).body
-      returns([security_group.group_id]) { result["SecurityGroups"] }
-      result
-    end
-
-    tests("#describe_mount_targets(id: #{mount_target_id})").formats(AWS::EFS::Formats::DESCRIBE_MOUNT_TARGETS_RESULT) do
-      Fog::AWS[:efs].describe_mount_targets(:id => mount_target_id).body
-    end
-
-    raises(Fog::AWS::EFS::NotFound, 'Mount target does not exist.') do
-      Fog::AWS[:efs].describe_mount_targets(:id => "foobar")
-    end
-
-    raises(Fog::AWS::EFS::Error, 'file system ID or mount target ID must be specified') do
-      Fog::AWS[:efs].describe_mount_targets
-    end
-
-    raises(Fog::AWS::EFS::NotFound, "invalid mount target id: foobar#{suffix}") do
-      Fog::AWS[:efs].delete_mount_target("foobar#{suffix}")
-    end
-
-    tests("#delete_mount_target(id: #{mount_target_id})") do
-      returns(true) do
-        result = Fog::AWS[:efs].delete_mount_target(mount_target_id)
-        result.body.empty?
-      end
-    end
-
-    file_system.wait_for { number_of_mount_targets == 0 }
-
-    if Fog.mocking?
-      Fog::AWS[:efs].data[:file_systems][file_system_id]["NumberOfMountTargets"] = 1
-      raises(Fog::AWS::EFS::FileSystemInUse) do
-        Fog::AWS[:efs].delete_file_system(file_system_id)
-      end
-      Fog::AWS[:efs].data[:file_systems][file_system_id]["NumberOfMountTargets"] = 0
-    end
-
-    raises(Fog::AWS::EFS::NotFound, "invalid file system ID: foobar#{suffix}") do
-      Fog::AWS[:efs].delete_file_system("foobar#{suffix}")
-    end
-
-    tests("#delete_file_system") do
-      returns(true) do
-        result = Fog::AWS[:efs].delete_file_system(file_system_id)
-        result.body.empty?
-      end
-    end
-
-    security_group.destroy
-  end
-end

data/tests/requests/efs/helper.rb

@@ -1,42 +0,0 @@
-class AWS
-  module EFS
-    module Formats
-      FILE_SYSTEM_FORMAT = {
-        "CreationTime"         => Float,
-        "CreationToken"        => String,
-        "FileSystemId"         => String,
-        "LifeCycleState"       => String,
-        "Name"                 => Fog::Nullable::String,
-        "NumberOfMountTargets" => Integer,
-        "OwnerId"              => String,
-        "PerformanceMode"      => String,
-        "SizeInBytes"          => {
-          "Timestamp" => Fog::Nullable::Float,
-          "Value"     => Integer
-        }
-      }
-
-      MOUNT_TARGET_FORMAT = {
-        "FileSystemId"       => String,
-        "IpAddress"          => String,
-        "LifeCycleState"     => String,
-        "MountTargetId"      => String,
-        "NetworkInterfaceId" => String,
-        "OwnerId"            => String,
-        "SubnetId"           => String
-      }
-
-      DESCRIBE_FILE_SYSTEMS_RESULT = {
-        "FileSystems" => [FILE_SYSTEM_FORMAT]
-      }
-
-      DESCRIBE_MOUNT_TARGETS_RESULT = {
-        "MountTargets" => [MOUNT_TARGET_FORMAT]
-      }
-
-      DESCRIBE_MOUNT_TARGET_SECURITY_GROUPS_FORMAT = {
-        "SecurityGroups" => Array
-      }
-    end
-  end
-end

data/tests/requests/elasticache/cache_cluster_tests.rb

@@ -1,137 +0,0 @@
-Shindo.tests('AWS::Elasticache | cache cluster requests', ['aws', 'elasticache']) do
-
-  tests('success') do
-
-    # 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 = Fog::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 = Fog::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 = Fog::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
-
-    Fog::Formatador.display_line "Waiting for cluster #{CLUSTER_ID}..."
-    Fog::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 = Fog::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 = Fog::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 = Fog::AWS[:elasticache].clusters.get(CLUSTER_ID)
-      node_id = c.nodes.last['CacheNodeId']
-      Fog::Formatador.display_line "Rebooting node #{node_id}..."
-      body = Fog::AWS[:elasticache].reboot_cache_cluster(c.id, [ node_id ]).body
-      returns('rebooting cache cluster nodes') do
-        body['CacheCluster']['CacheClusterStatus']
-      end
-      body['CacheCluster']
-    end
-
-    Fog::Formatador.display_line "Waiting for cluster #{CLUSTER_ID}..."
-    Fog::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 = Fog::AWS[:elasticache].clusters.get(CLUSTER_ID)
-      node_id = c.nodes.last['CacheNodeId']
-      Fog::Formatador.display_line "Removing node #{node_id}..."
-      body = Fog::AWS[:elasticache].modify_cache_cluster(c.id,
-      {
-        :num_nodes          => NUM_NODES - 1,
-        :nodes_to_remove    => [node_id],
-        :apply_immediately  => true,
-      }).body
-      returns(node_id) {
-        body['CacheCluster']['PendingModifiedValues']['CacheNodeId']
-      }
-      body['CacheCluster']
-    end
-
-    Fog::Formatador.display_line "Waiting for cluster #{CLUSTER_ID}..."
-    Fog::AWS[:elasticache].clusters.get(CLUSTER_ID).wait_for {ready?}
-
-    tests(
-    '#delete_cache_clusters'
-    ).formats(AWS::Elasticache::Formats::CACHE_CLUSTER_RUNNING) do
-      body = Fog::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/tests/requests/elasticache/describe_events.rb

@@ -1,17 +0,0 @@
-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
-      Fog::AWS[:elasticache].describe_events().body['Events']
-    end
-  end
-
-  tests('failure') do
-    # TODO:
-  end
-end

data/tests/requests/elasticache/describe_reserved_cache_nodes.rb

@@ -1,17 +0,0 @@
-Shindo.tests('AWS::Elasticache | describe reserved cache nodes',
-  ['aws', 'elasticache']) do
-
-  tests('success') do
-    pending if Fog.mocking?
-
-    tests(
-    '#describe_reserved_cache_nodes'
-    ).formats(AWS::Elasticache::Formats::RESERVED_CACHE_NODES) do
-      Fog::AWS[:elasticache].describe_reserved_cache_nodes().body['ReservedCacheNodes']
-    end
-  end
-
-  tests('failure') do
-    # TODO:
-  end
-end

data/tests/requests/elasticache/helper.rb

@@ -1,103 +0,0 @@
-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_SUBNET_GROUP = {
-        'CacheSubnetGroupName' => String,
-        'CacheSubnetGroupDescription' => String,
-        'VpcId' => String,
-        'Subnets' => [String]
-      }
-
-      CREATE_CACHE_SUBNET_GROUP = BASIC.merge({
-         'CreateCacheSubnetGroupResult' => {
-           'CacheSubnetGroup' => CACHE_SUBNET_GROUP
-         }
-       })
-
-      DESCRIBE_CACHE_SUBNET_GROUPS = BASIC.merge({
-        'DescribeCacheSubnetGroupsResult' => {
-          'CacheSubnetGroups' => [CACHE_SUBNET_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]
-
-      RESERVED_CACHE_CLUSTER = {
-        'CacheNodeCount'                => Integer,
-        'CacheNodeType'                 => String,
-        'Duration'                      => Integer,
-        'FixedPrice'                    => Float,
-        'OfferingType'                  => String,
-        'ProductDescription'            => String,
-        'RecurringCharges'              => Array,
-        'ReservedCacheNodeId'           => String,
-        'ReservedCacheNodesOfferingId'  => String,
-        'StartTime'                     => DateTime,
-        'State'                         => String,
-        'UsagePrice'                    => Float
-      }
-      RESERVED_CACHE_CLUSTER_LIST = [RESERVED_CACHE_CLUSTER]
-
-    end
-  end
-end