fog-aws 0.4.1 → 0.5.0

data/lib/fog/aws/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module AWS
-    VERSION = "0.4.1"
+    VERSION = "0.5.0"
   end
 end

data/tests/requests/compute/vpc_tests.rb

@@ -52,6 +52,13 @@ Shindo.tests('Fog::Compute[:aws] | vpc requests', ['aws']) do
       data
     end
 
+    tests('#create_vpc').formats(@create_vpcs_format) do
+      data = Fog::Compute[:aws].create_vpc('10.255.254.0/28',
+        {'InstanceTenancy' => 'default'}).body
+      @vpc_id = data['vpcSet'].first['vpcId']
+      data
+    end
+
     tests('#describe_vpcs').formats(@describe_vpcs_format) do
       Fog::Compute[:aws].describe_vpcs.body
     end

data/tests/requests/ecs/cluster_tests.rb

@@ -0,0 +1,112 @@
+Shindo.tests('AWS::ECS | cluster requests', ['aws', 'ecs']) do
+
+  Fog::AWS[:ecs].reset_data
+
+  tests('success') do
+
+    tests("#create_cluster").formats(AWS::ECS::Formats::CREATE_CLUSTER) do
+      result = Fog::AWS[:ecs].create_cluster('clusterName' => 'cluster1').body
+      cluster = result['CreateClusterResult']['cluster']
+      returns('cluster1') { cluster['clusterName'] }
+      returns('ACTIVE') { cluster['status'] }
+      result
+    end
+
+    tests("#create_cluster another").formats(AWS::ECS::Formats::CREATE_CLUSTER) do
+      result = Fog::AWS[:ecs].create_cluster('clusterName' => 'foobar').body
+      cluster = result['CreateClusterResult']['cluster']
+      returns('foobar') { cluster['clusterName'] }
+      returns('ACTIVE') { cluster['status'] }
+      result
+    end
+
+    tests("#create_cluster without params").formats(AWS::ECS::Formats::CREATE_CLUSTER) do
+      result = Fog::AWS[:ecs].create_cluster.body
+      cluster = result['CreateClusterResult']['cluster']
+      returns('default') { cluster['clusterName'] }
+      result
+    end
+
+    tests("#list_clusters").formats(AWS::ECS::Formats::LIST_CLUSTERS) do
+      result = Fog::AWS[:ecs].list_clusters.body
+      clusters = result['ListClustersResult']['clusterArns']
+      returns(true) { clusters.size.eql?(3) }
+      result
+    end
+
+    tests("#describe_clusters with name").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
+      result = Fog::AWS[:ecs].describe_clusters('clusters' => 'cluster1').body
+      clusters = result['DescribeClustersResult']['clusters']
+      failures = result['DescribeClustersResult']['failures']
+      returns(true) { clusters.size.eql?(1) }
+      returns('cluster1') { clusters.first['clusterName'] }
+      returns(true) { failures.empty? }
+      result
+    end
+
+    tests("#describe_clusters without params").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
+      result = Fog::AWS[:ecs].describe_clusters.body
+      clusters = result['DescribeClustersResult']['clusters']
+      failures = result['DescribeClustersResult']['failures']
+      returns(true) { clusters.size.eql?(1) }
+      returns('default') { clusters.first['clusterName'] }
+      result
+    end
+
+    tests("#describe_clusters several with name").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
+      result = Fog::AWS[:ecs].describe_clusters('clusters' => %w(cluster1 foobar)).body
+      clusters = result['DescribeClustersResult']['clusters']
+      cluster_names = clusters.map { |c| c['clusterName'] }.sort
+      returns(true) { clusters.size.eql?(2) }
+      returns('cluster1') { cluster_names.first }
+      returns('foobar') { cluster_names[1] }
+      result
+    end
+
+    tests("#describe_clusters with errors").formats(AWS::ECS::Formats::DESCRIBE_CLUSTERS) do
+      result = Fog::AWS[:ecs].describe_clusters('clusters' => %w(foobar not_here wtf)).body
+      clusters = result['DescribeClustersResult']['clusters']
+      failures = result['DescribeClustersResult']['failures']
+      returns(true) { failures.size.eql?(2) }
+      returns('MISSING') { failures.first['reason'] }
+      returns(true) { clusters.size.eql?(1) }
+      result
+    end
+
+    tests("#delete_cluster").formats(AWS::ECS::Formats::DELETE_CLUSTER) do
+      cluster_name = 'foobar'
+      result = Fog::AWS[:ecs].delete_cluster('cluster' => cluster_name).body
+      cluster = result['DeleteClusterResult']['cluster']
+      returns(true) { cluster['clusterName'].eql?(cluster_name) }
+      returns('INACTIVE') { cluster['status'] }
+      result
+    end
+
+    tests("#list_clusters after one delete").formats(AWS::ECS::Formats::LIST_CLUSTERS) do
+      result = Fog::AWS[:ecs].list_clusters.body
+      clusters = result['ListClustersResult']['clusterArns']
+      returns(true) { clusters.size.eql?(2) }
+      result
+    end
+
+    tests("#delete_cluster by arn").formats(AWS::ECS::Formats::DELETE_CLUSTER) do
+      result1 = Fog::AWS[:ecs].describe_clusters.body
+      cluster1 = result1['DescribeClustersResult']['clusters'].first
+      result2 = Fog::AWS[:ecs].delete_cluster('cluster' => cluster1['clusterArn']).body
+      cluster2 = result2['DeleteClusterResult']['cluster']
+      returns('default') { cluster2['clusterName'] }
+      returns('INACTIVE') { cluster2['status'] }
+      result2
+    end
+
+  end
+
+  tests('failures') do
+
+    tests('#delete_cluster without params').raises(Fog::AWS::ECS::Error) do
+      response = Fog::AWS[:ecs].delete_cluster.body
+    end
+
+  end
+
+end

data/tests/requests/ecs/container_instance_tests.rb

@@ -0,0 +1,119 @@
+Shindo.tests('AWS::ECS | container instance requests', ['aws', 'ecs']) do
+
+  Fog::AWS[:ecs].reset_data
+
+  container_instance_arn = 'arn:aws:ecs:us-west-2:738152598183:container-instance/eff1068d-5fcb-4804-89f0-7d18ffc6879c'
+  ec2_instance_id = 'i-58f4b4ae'
+
+  Fog::AWS[:ecs].data[:container_instances] << {
+    'remainingResources' => [
+      {
+        'longValue'    => 0,
+        'name'         => 'CPU',
+        'integerValue' => 1004,
+        'doubleValue'  => 0.0,
+        'type'         => 'INTEGER'
+      },
+      {
+        'longValue'    => 0,
+        'name'         => 'MEMORY',
+        'integerValue' => 496,
+        'doubleValue'  => 0.0,
+        'type'         => 'INTEGER'
+      },
+      {
+        'stringSetValue' => [2376, 22, 80, 51678, 2375],
+        'longValue'      => 0,
+        'name'           => 'PORTS',
+        'integerValue'   => 0,
+        'doubleValue'    => 0.0,
+        'type'           => 'STRINGSET'
+      }
+    ],
+    'agentConnected'      => true,                                               
+    'runningTasksCount'   => 1,                                               
+    'status'              => 'ACTIVE',                                                   
+    'registeredResources' => [
+      {
+        'longValue'     => 0,
+         'name'         => 'CPU',
+         'integerValue' => 1024,
+         'doubleValue'  => 0.0,
+         'type'         => 'INTEGER'
+      },
+      {
+        'longValue'     => 0,
+        'name'          => 'MEMORY',
+        'integerValue'  => 996,
+        'doubleValue'   => 0.0,
+        'type'          => 'INTEGER'
+      },
+      {
+        'stringSetValue' => [2376, 22, 80, 51678, 2375],
+        'longValue'      => 0,
+        'name'           => 'PORTS',
+        'integerValue'   => 0,
+        'doubleValue'    => 0.0,
+        'type'           => 'STRINGSET'
+      }
+    ],
+    'containerInstanceArn' => container_instance_arn,
+    'pendingTasksCount'    => 0,                                               
+    'ec2InstanceId'        => ec2_instance_id
+  }
+
+  tests('success') do
+
+    tests("#list_container_instances").formats(AWS::ECS::Formats::LIST_CONTAINER_INSTANCES) do
+      result = Fog::AWS[:ecs].list_container_instances.body
+      list_instances_arns = result['ListContainerInstancesResult']['containerInstanceArns']
+      returns(false) { list_instances_arns.empty? }
+      returns(true)  { list_instances_arns.first.eql?(container_instance_arn) }
+      result
+    end
+
+    tests("#describe_container_instances").formats(AWS::ECS::Formats::DESCRIBE_CONTAINER_INSTANCES) do
+      result = Fog::AWS[:ecs].describe_container_instances('containerInstances' => container_instance_arn).body
+      instance = result['DescribeContainerInstancesResult']['containerInstances'].first
+      returns(true) { instance['containerInstanceArn'].eql?(container_instance_arn) }
+      returns(true) { instance['ec2InstanceId'].eql?(ec2_instance_id) }
+      returns(true) { instance['status'].eql?('ACTIVE') }
+      result
+    end
+
+    tests("#deregister_container_instance").formats(AWS::ECS::Formats::DEREGISTER_CONTAINER_INSTANCE) do
+      result = Fog::AWS[:ecs].deregister_container_instance('containerInstance' => container_instance_arn).body
+      instance = result['DeregisterContainerInstanceResult']['containerInstance']
+      returns(true) { instance['containerInstanceArn'].eql?(container_instance_arn) }
+      returns(true) { instance['ec2InstanceId'].eql?(ec2_instance_id) }
+      returns(true) { instance['pendingTasksCount'].eql?(0) }
+      result
+    end
+
+    tests("#list_container_instances again").formats(AWS::ECS::Formats::LIST_CONTAINER_INSTANCES) do
+      result = Fog::AWS[:ecs].list_container_instances.body
+      list_instances_arns = result['ListContainerInstancesResult']['containerInstanceArns']
+      returns(true) { list_instances_arns.empty? }
+      result
+    end
+
+  end
+
+  tests('failures') do
+
+    tests('#describe_container_instances without params').raises(Fog::AWS::ECS::Error) do
+      response = Fog::AWS[:ecs].describe_container_instances.body
+    end
+
+    tests('#deregister_container_instance without params').raises(Fog::AWS::ECS::Error) do
+      response = Fog::AWS[:ecs].deregister_container_instance.body
+    end
+
+    tests('#deregister_container_instance nonexistent').raises(Fog::AWS::ECS::Error) do
+      instance_uuid = 'ffffffff-ffff-0000-ffff-deadbeefff'
+      response = Fog::AWS[:ecs].deregister_container_instance('containerInstance' => instance_uuid).body
+    end
+
+  end
+
+end

data/tests/requests/ecs/helper.rb

@@ -0,0 +1,276 @@
+class AWS
+  module ECS
+    module Formats
+      BASIC = {
+        'ResponseMetadata' => { 'RequestId' => String }
+      }
+      CREATE_CLUSTER = BASIC.merge({
+        'CreateClusterResult' => {
+          'cluster' => {
+            'clusterName'                       => String,
+            'clusterArn'                        => String,
+            'status'                            => String,
+            'registeredContainerInstancesCount' => Integer,
+            'runningTasksCount'                 => Integer,
+            'pendingTasksCount'                 => Integer
+          }
+        }
+      })
+      LIST_CLUSTERS = BASIC.merge({
+        'ListClustersResult' => {
+          'clusterArns' => [String],
+          'nextToken'   => Fog::Nullable::String
+        }
+      })
+      DELETE_CLUSTER = BASIC.merge({
+        'DeleteClusterResult' => {
+          'cluster' => {
+            'clusterName'                       => String,
+            'clusterArn'                        => String,
+            'status'                            => String,
+            'registeredContainerInstancesCount' => Integer,
+            'runningTasksCount'                 => Integer,
+            'pendingTasksCount'                 => Integer
+          }
+        }
+      })
+      DESCRIBE_CLUSTERS = BASIC.merge({
+        'DescribeClustersResult' => {
+          'failures' => [Fog::Nullable::Hash],
+          'clusters' => [Fog::Nullable::Hash]
+        }
+      })
+      REGISTER_TASK_DEFINITION = BASIC.merge({
+        'RegisterTaskDefinitionResult' => {
+          'taskDefinition' => {
+            'revision'             => Integer,
+            'taskDefinitionArn'    => String,
+            'family'               => String,
+            'containerDefinitions' => [Hash],
+            'volumes'              => Fog::Nullable::Array
+          }
+        }
+      })
+      LIST_TASK_DEFINITIONS = BASIC.merge({
+        'ListTaskDefinitionsResult' => {
+          'taskDefinitionArns' => [String]
+        }
+      })
+      DESCRIBE_TASK_DEFINITION = BASIC.merge({
+        'DescribeTaskDefinitionResult' => {
+          'taskDefinition' => {
+            'revision'             => Integer,
+            'taskDefinitionArn'    => String,
+            'family'               => String,
+            'containerDefinitions' => [Hash],
+            'volumes'              => Fog::Nullable::Array
+          }
+        }
+      })
+      DEREGISTER_TASK_DEFINITION = BASIC.merge({
+        'DeregisterTaskDefinitionResult' => {
+          'taskDefinition' => {
+            'revision'             => Integer,
+            'taskDefinitionArn'    => String,
+            'family'               => String,
+            'containerDefinitions' => [Hash],
+            'volumes'              => Fog::Nullable::Array
+          }
+        }
+      })
+      LIST_TASK_DEFINITION_FAMILIES = BASIC.merge({
+        'ListTaskDefinitionFamiliesResult' => {
+          'families' => [String]
+        }
+      })
+      CREATE_SERVICE = BASIC.merge({
+        'CreateServiceResult' => {
+          'service' => {
+            'events'         => [Fog::Nullable::Hash],
+            'serviceName'    => String,
+            'serviceArn'     => String,
+            'taskDefinition' => String,
+            'clusterArn'     => String,
+            'status'         => String,
+            'roleArn'        => Fog::Nullable::String,
+            'loadBalancers'  => [Fog::Nullable::Hash],
+            'deployments'    => [Fog::Nullable::Hash],
+            'desiredCount'   => Integer,
+            'pendingCount'   => Integer,
+            'runningCount'   => Integer
+          }
+        }
+      })
+      DELETE_SERVICE = BASIC.merge({
+        'DeleteServiceResult' => {
+          'service' => {
+            'events'         => [Fog::Nullable::Hash],
+            'serviceName'    => String,
+            'serviceArn'     => String,
+            'taskDefinition' => String,
+            'clusterArn'     => String,
+            'status'         => String,
+            'roleArn'        => Fog::Nullable::String,
+            'loadBalancers'  => [Fog::Nullable::Hash],
+            'deployments'    => [Fog::Nullable::Hash],
+            'desiredCount'   => Integer,
+            'pendingCount'   => Integer,
+            'runningCount'   => Integer
+          }
+        }
+      })
+      DESCRIBE_SERVICES = BASIC.merge({
+        'DescribeServicesResult' => {
+          'failures' => [Fog::Nullable::Hash],
+          'services' => [{
+            'events'         => [Fog::Nullable::Hash],
+            'serviceName'    => String,
+            'serviceArn'     => String,
+            'taskDefinition' => String,
+            'clusterArn'     => String,
+            'status'         => String,
+            'roleArn'        => Fog::Nullable::String,
+            'loadBalancers'  => [Fog::Nullable::Hash],
+            'deployments'    => [Fog::Nullable::Hash],
+            'desiredCount'   => Integer,
+            'pendingCount'   => Integer,
+            'runningCount'   => Integer
+          }]
+        }
+      })
+      LIST_SERVICES = BASIC.merge({
+        'ListServicesResult' => {
+          'serviceArns'  => [Fog::Nullable::String],
+          'nextToken' => Fog::Nullable::String
+        }
+      })
+      UPDATE_SERVICE = BASIC.merge({
+        'UpdateServiceResult' => {
+          'service' => {
+            'events'         => [Fog::Nullable::Hash],
+            'serviceName'    => String,
+            'serviceArn'     => String,
+            'taskDefinition' => String,
+            'clusterArn'     => String,
+            'status'         => String,
+            'roleArn'        => Fog::Nullable::String,
+            'loadBalancers'  => [Fog::Nullable::Hash],
+            'deployments'    => [Fog::Nullable::Hash],
+            'desiredCount'   => Integer,
+            'pendingCount'   => Integer,
+            'runningCount'   => Integer
+          }
+        }
+      })
+      LIST_CONTAINER_INSTANCES = BASIC.merge({
+        'ListContainerInstancesResult' => {
+          'containerInstanceArns' => [Fog::Nullable::String]
+        }
+      })
+      DESCRIBE_CONTAINER_INSTANCES = BASIC.merge({
+        'DescribeContainerInstancesResult' => {
+          'containerInstances' => [{
+            'remainingResources'   => [Hash],
+            'agentConnected'       => Fog::Boolean,
+            'runningTasksCount'    => Integer,
+            'status'               => String,
+            'registeredResources'  => [Hash],
+            'containerInstanceArn' => String,
+            'pendingTasksCount'    => Integer,
+            'ec2InstanceId'        => String
+          }],
+          'failures' => [Fog::Nullable::Hash],
+        }
+      })
+      DEREGISTER_CONTAINER_INSTANCE = BASIC.merge({
+        'DeregisterContainerInstanceResult' => {
+          'containerInstance' => {
+            'remainingResources'   => [Hash],
+            'agentConnected'       => Fog::Boolean,
+            'runningTasksCount'    => Integer,
+            'status'               => String,
+            'registeredResources'  => [Hash],
+            'containerInstanceArn' => String,
+            'pendingTasksCount'    => Integer,
+            'ec2InstanceId'        => String
+          }
+        }
+      })
+      LIST_TASKS = BASIC.merge({
+        'ListTasksResult' => {
+          'taskArns' => [Fog::Nullable::String]
+        }
+      })
+      DESCRIBE_TASKS = BASIC.merge({
+        'DescribeTasksResult' => {
+          'failures' => [Fog::Nullable::Hash],
+          'tasks' => [
+            {
+              'clusterArn'           => String,
+              'containers'           => Array,
+              'overrides'            => Fog::Nullable::Hash,
+              'startedBy'            => Fog::Nullable::String,
+              'desiredStatus'        => String,
+              'taskArn'              => String,
+              'containerInstanceArn' => String,
+              'lastStatus'           => String,
+              'taskDefinitionArn'    => String
+            }
+          ]
+        }
+      })
+      RUN_TASK = BASIC.merge({
+        'RunTaskResult' => {
+          'failures' => [Fog::Nullable::Hash],
+          'tasks' => [
+            {
+              'clusterArn'           => String,
+              'containers'           => [Hash],
+              'overrides'            => Fog::Nullable::Hash,
+              'desiredStatus'        => String,
+              'taskArn'              => String,
+              'containerInstanceArn' => String,
+              'lastStatus'           => String,
+              'taskDefinitionArn'    => String
+            }
+          ]
+        }
+      })
+      STOP_TASK = BASIC.merge({
+        'StopTaskResult' => {
+          'task' => {
+            'clusterArn'           => String,
+            'containers'           => [Hash],
+            'overrides'            => Fog::Nullable::Hash,
+            'desiredStatus'        => String,
+            'taskArn'              => String,
+            'startedBy'            => Fog::Nullable::String,
+            'containerInstanceArn' => String,
+            'lastStatus'           => String,
+            'taskDefinitionArn'    => String
+          }
+        }
+      })
+      START_TASK = BASIC.merge({
+        'StartTaskResult' => {
+          'failures' => [Fog::Nullable::Hash],
+          'tasks' => [
+            {
+              'clusterArn'           => String,
+              'containers'           => [Hash],
+              'overrides'            => Fog::Nullable::Hash,
+              'desiredStatus'        => String,
+              'taskArn'              => String,
+              'containerInstanceArn' => String,
+              'lastStatus'           => String,
+              'taskDefinitionArn'    => String
+            }
+          ]
+        }
+      })
+    end
+    module Samples
+      TASK_DEFINITION_1 = File.dirname(__FILE__) + '/sample_task_definition1.json'
+    end
+  end
+end