fog-aws 0.11.0 → 3.18.0

data/tests/requests/ecs/service_tests.rb

@@ -1,132 +0,0 @@
-Shindo.tests('AWS::ECS | service requests', ['aws', 'ecs']) do
-
-  Fog::AWS[:ecs].reset_data
-
-  cluster = 'arn:aws:ecs:us-east-1:994922842243:cluster/default'
-  desired_count = 1
-  role = 'arn:aws:iam::806753142346:role/ecsServiceRole'
-  service_name = 'sample-webapp'
-  task_definition = 'console-sample-app-static:18'
-  load_balancers = [{
-    'containerName'    => 'simple-app',
-    'containerPort'    => 80,
-    'loadBalancerName' => 'ecsunittests-EcsElastic-OI09IAP3PVIP'
-  }]
-
-  tests('success') do
-
-    tests("#list_services").formats(AWS::ECS::Formats::LIST_SERVICES) do
-      result = Fog::AWS[:ecs].list_services('cluster' => cluster).body
-      list_services_arns = result['ListServicesResult']['serviceArns']
-      returns(true) { list_services_arns.empty? }
-      result
-    end
-
-    tests("#create_service").formats(AWS::ECS::Formats::CREATE_SERVICE) do
-      params = {
-        'cluster'        => cluster,
-        'desiredCount'   => desired_count,
-        'loadBalancers'  => load_balancers,
-        'role'           => role,
-        'serviceName'    => service_name,
-        'taskDefinition' => task_definition
-      }
-      result = Fog::AWS[:ecs].create_service(params).body
-      service = result['CreateServiceResult']['service']
-      returns('sample-webapp') { service['serviceName'] }
-      returns(false) { service['serviceArn'].match(/^arn:aws:ecs:.+:.+:service\/.+$/).nil? }
-      result
-    end
-
-    tests("#list_services again").formats(AWS::ECS::Formats::LIST_SERVICES) do
-      result = Fog::AWS[:ecs].list_services('cluster' => cluster).body
-      list_services_arns = result['ListServicesResult']['serviceArns']
-      returns(false) { list_services_arns.empty? }
-      returns(true)  { !list_services_arns.first.match(/#{service_name}/).nil? }
-      result
-    end
-
-    tests("#describe_services").formats(AWS::ECS::Formats::DESCRIBE_SERVICES) do
-      result1 = Fog::AWS[:ecs].list_services('cluster' => cluster).body
-      service_arn = result1['ListServicesResult']['serviceArns'].first
-      result2 = Fog::AWS[:ecs].describe_services(
-        'services' => service_arn,
-        'cluster' => cluster
-      ).body
-      returns(true) { result2['DescribeServicesResult']['services'].size.eql?(1) }
-      service = result2['DescribeServicesResult']['services'].first
-      returns(true)  { service['serviceName'].eql?(service_name) }
-      returns(true)  { service['status'].eql?('ACTIVE') }
-      returns(false) { service['deployments'].empty? }
-      returns(true)  { service['desiredCount'].eql?(desired_count) }
-      result2
-    end
-
-    tests("#update_service").formats(AWS::ECS::Formats::UPDATE_SERVICE) do
-      new_task_def = 'arn:aws:ecs:us-east-1:994922842243:task-definitions/foobar-app:32'
-      result1 = Fog::AWS[:ecs].list_services('cluster' => cluster).body
-      service_arn = result1['ListServicesResult']['serviceArns'].first
-
-      result2 = Fog::AWS[:ecs].update_service(
-        'service' => service_arn,
-        'cluster' => cluster,
-        'taskDefinition' => new_task_def
-      ).body
-      service = result2['UpdateServiceResult']['service']
-      returns(true) { service['serviceName'].eql?(service_name) }
-      returns(true) { service['taskDefinition'].eql?(new_task_def) }
-      result2
-    end
-
-
-    tests("#delete_service").formats(AWS::ECS::Formats::DELETE_SERVICE) do
-      result1 = Fog::AWS[:ecs].list_services('cluster' => cluster).body
-      service_arn = result1['ListServicesResult']['serviceArns'].first
-
-      result2 = Fog::AWS[:ecs].delete_service(
-        'service' => service_arn,
-        'cluster' => cluster
-      ).body
-      service = result2['DeleteServiceResult']['service']
-      returns(true) { service['serviceName'].eql?(service_name) }
-      result2
-    end
-
-    tests("#list_services yet again").formats(AWS::ECS::Formats::LIST_SERVICES) do
-      result = Fog::AWS[:ecs].list_services('cluster' => cluster).body
-      list_services_arns = result['ListServicesResult']['serviceArns']
-      returns(true) { list_services_arns.empty? }
-      result
-    end
-
-  end
-
-  tests('failures') do
-
-    tests('#describe_services without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].describe_services.body
-    end
-
-    tests('#create_service without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].create_service.body
-    end
-
-    tests('#update_service without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].update_service.body
-    end
-
-    tests('#update_service nonexistent').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].update_service('service' => 'whatever2329').body
-    end
-
-    tests('#delete_service without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].delete_service.body
-    end
-
-    tests('#delete_service nonexistent').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].delete_service('service' => 'foobar787383').body
-    end
-
-  end
-
-end

data/tests/requests/ecs/task_definitions_tests.rb

@@ -1,97 +0,0 @@
-require 'fog/json'
-
-Shindo.tests('AWS::ECS | task definitions requests', ['aws', 'ecs']) do
-
-  Fog::AWS[:ecs].reset_data
-
-  tests('success') do
-
-    tests("#list_task_definitions").formats(AWS::ECS::Formats::LIST_TASK_DEFINITIONS) do
-      result = Fog::AWS[:ecs].list_task_definitions.body
-      list_task_def_arns = result['ListTaskDefinitionsResult']['taskDefinitionArns']
-      returns(true) { list_task_def_arns.empty? }
-      result
-    end
-
-    tests("#register_task_definition").formats(AWS::ECS::Formats::REGISTER_TASK_DEFINITION) do
-      task_def_params = Fog::JSON.decode(IO.read(AWS::ECS::Samples::TASK_DEFINITION_1))
-      result = Fog::AWS[:ecs].register_task_definition(task_def_params).body
-      task_def = result['RegisterTaskDefinitionResult']['taskDefinition']
-      returns('console-sample-app-static') { task_def['family'] }
-      returns(true) { task_def['revision'] > 0 }
-      returns(false) { task_def['taskDefinitionArn'].match(/^arn:aws:ecs:.+:.+:task-definition\/.+:\d+$/).nil? }
-      result
-    end
-
-    tests("#list_task_definition_families").formats(AWS::ECS::Formats::LIST_TASK_DEFINITION_FAMILIES) do
-      result = Fog::AWS[:ecs].list_task_definition_families.body
-      families = result['ListTaskDefinitionFamiliesResult']['families']
-      returns(false) { families.empty? }
-      returns(true)  { families.include?('console-sample-app-static') }
-      result
-    end
-
-    tests("#list_task_definitions again").formats(AWS::ECS::Formats::LIST_TASK_DEFINITIONS) do
-      result = Fog::AWS[:ecs].list_task_definitions.body
-      list_task_def_arns = result['ListTaskDefinitionsResult']['taskDefinitionArns']
-      returns(true) { list_task_def_arns.size.eql?(1) }
-      result
-    end
-
-    tests("#describe_task_definition").formats(AWS::ECS::Formats::DESCRIBE_TASK_DEFINITION) do
-      result1 = Fog::AWS[:ecs].list_task_definitions.body
-      task_def_arn = result1['ListTaskDefinitionsResult']['taskDefinitionArns'].first
-      result2 = Fog::AWS[:ecs].describe_task_definition('taskDefinition' => task_def_arn).body
-      task_def = result2['DescribeTaskDefinitionResult']['taskDefinition']
-      returns(true) { task_def['taskDefinitionArn'].eql?(task_def_arn) }
-      returns(true) { task_def['containerDefinitions'].size > 0 }
-      result2
-    end
-
-    tests("#deregister_task_definition").formats(AWS::ECS::Formats::DEREGISTER_TASK_DEFINITION) do
-      result1 = Fog::AWS[:ecs].list_task_definitions.body
-      task_def_arn = result1['ListTaskDefinitionsResult']['taskDefinitionArns'].first
-      result2 = Fog::AWS[:ecs].deregister_task_definition('taskDefinition' => task_def_arn).body
-      task_def = result2['DeregisterTaskDefinitionResult']['taskDefinition']
-      returns(true) { task_def['taskDefinitionArn'].eql?(task_def_arn) }
-      result2
-    end
-
-    tests("#list_task_definitions yet again").formats(AWS::ECS::Formats::LIST_TASK_DEFINITIONS) do
-      result = Fog::AWS[:ecs].list_task_definitions.body
-      list_task_def_arns = result['ListTaskDefinitionsResult']['taskDefinitionArns']
-      returns(true) { list_task_def_arns.empty? }
-      result
-    end
-
-    tests("#list_task_definition_families again").formats(AWS::ECS::Formats::LIST_TASK_DEFINITION_FAMILIES) do
-      result = Fog::AWS[:ecs].list_task_definition_families.body
-      families = result['ListTaskDefinitionFamiliesResult']['families']
-      returns(true)  { families.empty? }
-      returns(false) { families.include?('console-sample-app-static') }
-      result
-    end
-
-  end
-
-  tests('failures') do
-
-    tests('#describe_task_definition without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].describe_task_definition.body
-    end
-
-    tests('#describe_task_definition nonexistent').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].describe_task_definition('taskDefinition' => 'foobar').body
-    end
-
-    tests('#deregister_task_definition without params').raises(Fog::AWS::ECS::Error) do
-      response = Fog::AWS[:ecs].deregister_task_definition.body
-    end
-
-    tests('#deregister_task_definition nonexistent').raises(Fog::AWS::ECS::NotFound) do
-      response = Fog::AWS[:ecs].deregister_task_definition('taskDefinition' => 'foobar:7873287283').body
-    end
-
-  end
-
-end

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/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