fog 1.15.0 → 1.16.0

data/tests/aws/models/compute/subnet_tests.rb

@@ -1,5 +1,5 @@
 Shindo.tests("Fog::Compute[:aws] | subnet", ['aws']) do
   @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
-  model_tests(Fog::Compute[:aws].subnets, {:vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28'}, true)
+  model_tests(Fog::Compute[:aws].subnets, {:vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28', :availability_zone => 'us-east-1b'}, true)
   @vpc.destroy
 end

data/tests/aws/models/compute/subnets_tests.rb

@@ -1,6 +1,6 @@
 Shindo.tests("Fog::Compute[:aws] | subnets", ['aws']) do
   @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/28')
-  collection_tests(Fog::Compute[:aws].subnets, { :vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28'}, true)
+  collection_tests(Fog::Compute[:aws].subnets, { :vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28', :availability_zone => 'us-east-1c'}, true)
   @vpc.destroy
 end
 

data/tests/aws/requests/compute/instance_tests.rb

@@ -3,6 +3,7 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
   @instance_format = {
     'architecture'        => String,
     'amiLaunchIndex'      => Integer,
+    'associatePublicIP'   => Fog::Nullable::Boolean,    
     'attachmentId'        => Fog::Nullable::String,
     'blockDeviceMapping'  => [Fog::Nullable::Hash],
     'clientToken'         => Fog::Nullable::String,

data/tests/aws/requests/compute/network_interface_tests.rb

@@ -161,6 +161,23 @@ Shindo.tests('Fog::Compute[:aws] | network interface requests', ['aws']) do
      Fog::Compute[:aws].delete_network_interface(@nic_id).body
     end
 
+    @server.destroy
+    if !Fog.mocking?
+      @server.wait_for { state == 'terminated' }
+      # despite the fact that the state goes to 'terminated' we need a little delay for aws to do its thing
+    sleep 5
+    end
+
+    # Bring up another server to test vpc public IP association
+    @server = Fog::Compute[:aws].servers.create(:flavor_id => 'm1.small', :subnet_id => @subnet_id, :associate_public_ip => true)
+    @server.wait_for { ready? }
+    @instance_id = @server.id
+
+    test("#associate_public_ip") do
+      server = Fog::Compute[:aws].servers.get(@instance_id)
+      server.public_ip_address.nil? == false
+    end
+
     # Clean up resources
     @server.destroy
     if !Fog.mocking?

data/tests/aws/requests/compute/route_tests.rb

@@ -0,0 +1,277 @@
+Shindo.tests('Fog::Compute[:aws] | route table requests', ['aws']) do
+
+  @route_table_format = {
+    'routeTable' => [{
+      'routeSet'        => [{ 
+        'destinationCidrBlock'  => String,
+        'gatewayId'             => String,
+        'state'                 => String,
+      }],
+      'tagSet'          => Hash,
+      'associationSet'  => Array,
+      'routeTableId'    => String,
+      'vpcId'           => String,
+    }],
+    'requestId'   => String
+  }
+
+  @route_tables_format = {
+    'routeTableSet' => [{
+      'associationSet' => [{
+        'routeTableAssociationId' => Fog::Nullable::String,
+        'routeTableId'            => String,
+        'subnetId'                => Fog::Nullable::String,
+        'main'                    => Fog::Boolean
+      }],
+      'tagSet'         => Hash,
+      'routeSet'       => [{
+        'destinationCidrBlock' => String,
+        'gatewayId'            => Fog::Nullable::String,
+        'instanceId'           => Fog::Nullable::String,
+        'instanceOwnerId'      => Fog::Nullable::String,
+        'networkInterfaceId'   => Fog::Nullable::String,
+        'state'                => String,
+        'origin'               => String
+      }],
+      'routeTableId'   => String,
+      'vpcId'          => String,
+    }],
+    'requestId'    => String
+  }
+
+  vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+  if !Fog.mocking?
+    vpc.wait_for { state.eql? "available" }
+  end
+  @subnet_id = Fog::Compute[:aws].create_subnet(vpc.id, '10.0.10.0/24').body['subnetSet'].first['subnetId']
+  @network_interface = Fog::Compute[:aws].create_network_interface(@subnet_id, {"PrivateIpAddress" => "10.0.10.23"}).body
+  @internet_gateway_id = Fog::Compute[:aws].create_internet_gateway.body['internetGatewaySet'].first['internetGatewayId']
+  @network_interface_id = @network_interface['networkInterface']['networkInterfaceId']
+  key_name = 'fog-test-key'
+  key = Fog::Compute[:aws].key_pairs.create(:name => key_name)
+  @cidr_block = '10.0.10.0/24'
+  @destination_cidr_block = '10.0.10.0/23'
+  @ami = 'ami-79c0ae10' # ubuntu 12.04 daily build 20120728
+
+  tests('success') do
+
+    # Test create_route_table
+    #
+    tests("#create_route_table('#{vpc.id}')").formats(@route_table_format) do
+      data = Fog::Compute[:aws].create_route_table(vpc.id).body
+      @route_table_id = data['routeTable'].first['routeTableId']
+      data
+    end
+
+    # Test associate_route_table
+    #
+    tests("#associate_route_table('#{@route_table_id}', '#{@subnet_id}')").formats({'requestId'=>String, 'associationId'=>String}) do
+      data = Fog::Compute[:aws].associate_route_table(@route_table_id, @subnet_id).body
+      @association_id = data['associationId']
+      data
+    end
+
+    # Tests create_route
+    #   - using internet gateway
+    #   - using instance id
+    #   - using network interface
+    #
+    Fog::Compute[:aws].attach_internet_gateway(@internet_gateway_id, vpc.id).body
+    tests("#create_route('#{@route_table_id}', '#{@destination_cidr_block}', '#{@internet_gateway_id}', 'nil')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id, nil).body
+    end
+
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance.wait_for { state.eql? "running" }
+    tests("#create_route('#{@route_table_id}', '10.0.10.0/22', 'nil', '#{instance.id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/22', nil, instance.id).body
+    end
+
+    tests("#create_route('#{@route_table_id}', '10.0.10.0/21', 'nil', 'nil', '#{@network_interface_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/21', nil, nil, @network_interface_id).body
+    end
+
+    # Tests describe_route_tables
+    #   - no parameters
+    #   - filter: vpc-id => vpc_id
+    #   - filter: vpc-id => ['all']
+    #
+    tests('#describe_route_tables').formats(@route_tables_format) do
+      Fog::Compute[:aws].describe_route_tables.body
+    end
+    tests("#describe_route_tables('vpc-id' => #{vpc.id})").formats(@route_tables_format) do
+      Fog::Compute[:aws].describe_route_tables('vpc-id' => vpc.id).body
+    end
+    tests("#describe_route_tables('vpc-id' => ['all'])").formats(@route_tables_format) do
+      Fog::Compute[:aws].describe_route_tables('vpc-id' => ['all']).body
+    end
+
+    # Test delete_route(route_table_id, cidr_block)
+    #
+    tests("#delete_route('#{@route_table_id}', '10.0.10.0/21')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route(@route_table_id, '10.0.10.0/21').body
+    end
+    tests("#delete_route('#{@route_table_id}', '10.0.10.0/22')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route(@route_table_id, '10.0.10.0/22').body
+    end
+
+    Fog::Compute[:aws].servers.all('instance-id'=>instance.id).first.destroy
+    if !Fog.mocking?
+      instance.wait_for { state.eql? "terminated" }
+    end
+    tests("#delete_route('#{@route_table_id}', '#{@destination_cidr_block}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route(@route_table_id, @destination_cidr_block).body
+    end
+
+    # Test disassociate_route_table(association_id)
+    #
+    tests("#disassociate_route_table('#{@association_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].disassociate_route_table(@association_id).body
+    end
+
+    # Test delete_route_table(route_table_id)
+    #
+    tests("#delete_route_table('#{@route_table_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_route_table(@route_table_id).body
+    end
+  end
+  tests('failure') do
+
+    @route_table_id = Fog::Compute[:aws].create_route_table(vpc.id).body['routeTable'].first['routeTableId']
+    @association_id = Fog::Compute[:aws].associate_route_table(@route_table_id, @subnet_id).body['associationId']
+    Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id, nil)
+    instance = Fog::Compute[:aws].servers.create(:image_id => @ami, :flavor_id => 't1.micro', :key_name => 'fog-test-key', :subnet_id => @subnet_id)
+    instance.wait_for { state.eql? "running" }
+
+    # Tests create_route_table
+    #   - no parameters
+    #   - passing a nonexisting vpc
+    #
+    tests('#create_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].create_route_table
+    end
+    tests("#create_route_table('vpc-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route_table('vpc-00000000')
+    end
+
+    # Tests associate_route_table
+    #   - no parameters
+    #   - passing a nonexisiting route table
+    #   - passing a nonexisiting subnet
+    #
+    tests('#associate_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].associate_route_table
+    end
+    tests("#associate_route_table('rtb-00000000', '#{@subnet_id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].associate_route_table('rtb-00000000', @subnet_id)
+    end
+    tests("#associate_route_table('#{@route_table_id}', 'subnet-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].associate_route_table(@route_table_id, 'subnet-00000000')
+    end
+
+    # Tests create_route
+    #    - no parameters
+    #    - passing a nonexisiting route table and an exisiting internet gateway
+    #    - passing a nonexisiting internet gateway
+    #    - passing a nonexisting route table and an exisiting instance
+    #    - passing a nonexisiting instance
+    #    - passing a nonexsiting route table and an exisiting network interface
+    #    - passing a nonexisiting network interface
+    #    - attempting to add a route at the same destination cidr block as another
+    #    - attempting to add a route at a less specific destination cidr block
+    #
+    tests('#create_route').raises(ArgumentError) do
+      Fog::Compute[:aws].create_route
+    end
+    tests("#create_route('rtb-00000000', '#{@destination_cidr_block}', '#{@internet_gateway_id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route('rtb-00000000', @destination_cidr_block, @internet_gateway_id)
+    end
+    tests("#create_route('#{@route_table_id}', '#{@destination_cidr_block}', 'igw-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, 'igw-00000000')
+    end
+    tests("#create_route('rtb-00000000', '#{@destination_cidr_block}', 'nil', '#{instance.id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route('rtb-00000000', @destination_cidr_block, instance.id)
+    end
+    tests("#create_route('#{@route_table_id}', '#{@destination_cidr_block}', 'nil', 'i-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, nil, 'i-00000000')
+    end
+    tests("#create_route('#{@route_table_id}', '#{@destinationCidrBlock}', 'nil', 'nil', 'eni-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, nil, nil, 'eni-00000000')
+    end
+    tests("#create_route('#rtb-00000000', '#{@destination_cidr_block}', 'nil, 'nil', '#{@network_interface_id}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].create_route('rtb-00000000', @destination_cidr_block, nil, nil, @network_interface_id)
+    end
+    tests("#create_route same destination_cidr_block").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, @internet_gateway_id)
+      Fog::Compute[:aws].create_route(@route_table_id, @destination_cidr_block, nil, nil, @network_interface_id).body
+    end
+    if !Fog.mocking?
+      tests("#create_route less specific destination_cidr_block").raises(Fog::Compute::AWS::Error) do
+        Fog::Compute[:aws].create_route(@route_table_id, '10.0.10.0/25', @internet_gateway_id)
+       Fog::Compute[:aws].delete_route(@route_table_id, @destination_cidr_block).body
+      end
+    end
+
+    # Test describe_route_tables
+    #   - passing a nonexisiting vpc
+    #
+    tests("#describe_route_tables('vpc-id' => 'vpc-00000000").formats({'routeTableSet'=>Array, 'requestId'=>String}) do
+      Fog::Compute[:aws].describe_route_tables('vpc-id' => 'vpc-00000000').body
+    end
+
+    # Tests delete_route
+    #   - no parameters
+    #   - passing a nonexisiting route table
+    #
+    tests('#delete_route').raises(ArgumentError) do
+      Fog::Compute[:aws].delete_route
+    end
+    tests("#delete_route('rtb-00000000', '#{@destination_cidr_block}')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].delete_route('rtb-00000000', @destination_cidr_block)
+    end
+
+    # Tests disassociate_route_table
+    #   - no parameters
+    #   - passing a nonexisiting route table association id
+    #
+    tests('#disassociate_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].disassociate_route_table
+    end
+    tests("#disassociate_route_table('rtbassoc-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].disassociate_route_table('rtbassoc-00000000')
+    end
+
+    # Tests delete_route_table
+    #   - no parameters
+    #   - passing a nonexisiting route table
+    #
+    tests('#delete_route_table').raises(ArgumentError) do
+      Fog::Compute[:aws].delete_route_table
+    end
+    tests("#delete_route_table('rtb-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].delete_route_table('rtb-00000000')
+    end
+
+    # Dependency Tests
+    #   - route is depending on route_table, so route_table cannot be deleted
+    #
+    tests("#delete_route_table('#{@route_table_id}')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].delete_route_table(@route_table_id)
+    end
+
+    Fog::Compute[:aws].servers.all('instance-id'=>instance.id).first.destroy
+    if !Fog.mocking?
+      instance.wait_for { state.eql? "terminated" }
+    end
+    Fog::Compute[:aws].delete_route(@route_table_id, @destination_cidr_block)
+    Fog::Compute[:aws].disassociate_route_table(@association_id)
+    Fog::Compute[:aws].delete_route_table(@route_table_id)
+  end
+  
+  Fog::Compute[:aws].delete_network_interface(@network_interface_id)
+  Fog::Compute[:aws].detach_internet_gateway(@internet_gateway_id, vpc.id)
+  Fog::Compute[:aws].delete_internet_gateway(@internet_gateway_id)
+  Fog::Compute[:aws].delete_subnet(@subnet_id)
+  vpc.destroy
+  key.destroy
+end

data/tests/aws/requests/data_pipeline/helper.rb

@@ -6,6 +6,14 @@ class AWS
         'pipelineId' => String,
       }
 
+      FIELDS = [
+        {
+          "key" => String,
+          "refValue" => Fog::Nullable::String,
+          "stringValue" => Fog::Nullable::String,
+        }
+      ]
+
       LIST_PIPELINES = {
         "hasMoreResults" => Fog::Nullable::Boolean,
         "marker" => Fog::Nullable::String,
@@ -17,19 +25,31 @@ class AWS
         ]
       }
 
+      QUERY_OBJECTS = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "ids" => Fog::Nullable::Array,
+      }
+
+      DESCRIBE_OBJECTS = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "pipelineObjects" => [
+          {
+            'id' => String,
+            'name' => String,
+            'fields' => FIELDS,
+          }
+        ]
+      }
+
       DESCRIBE_PIPELINES = {
         "pipelineDescriptionList" => [
           {
             "description" => Fog::Nullable::String,
             "name" => String,
             "pipelineId" => String,
-            "fields" => [
-              {
-                "key" => String,
-                "refValue" => Fog::Nullable::String,
-                "stringValue" => Fog::Nullable::String,
-              }
-            ]
+            "fields" => FIELDS,
           }
         ]
       }
@@ -38,7 +58,17 @@ class AWS
         "errored" => Fog::Boolean,
         "validationErrors" => Fog::Nullable::Array,
       }
-	
+
+      GET_PIPELINE_DEFINITION = {
+        "pipelineObjects" => [
+          {
+            "id" => String,
+            "name" => String,
+            "fields" => FIELDS,
+          }
+        ]
+      }
+
     end
   end
 end

data/tests/aws/requests/data_pipeline/pipeline_tests.rb

@@ -46,7 +46,31 @@ Shindo.tests('AWS::DataPipeline | pipeline_tests', ['aws', 'data_pipeline']) do
       Fog::AWS[:data_pipeline].activate_pipeline(@pipeline_id)
     end
 
-    tests("#delete_pipeline") do
+    tests("#get_pipeline_definition").formats(AWS::DataPipeline::Formats::GET_PIPELINE_DEFINITION) do
+      Fog::AWS[:data_pipeline].get_pipeline_definition(@pipeline_id)
+    end
+
+    tests("#query_objects") do
+      tests("for COMPONENTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'COMPONENT')
+      end
+
+      tests("for INSTANCEs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'INSTANCE')
+      end
+
+      tests("for ATTEMPTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT')
+      end
+    end
+
+    tests('#describe_objects').formats(AWS::DataPipeline::Formats::DESCRIBE_OBJECTS) do
+      attempts = Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT')
+      object_ids = attempts['ids'][0..5]
+      Fog::AWS[:data_pipeline].describe_objects(@pipeline_id, object_ids)
+    end
+
+    tests("#delete_pipeline").returns(true) do
       Fog::AWS[:data_pipeline].delete_pipeline(@pipeline_id)
     end
 

data/tests/aws/requests/elasticache/security_group_tests.rb

@@ -1,10 +1,9 @@
 Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache']) do
 
   tests('success') do
-    pending if Fog.mocking?
 
     name = 'fog-test'
-    description = 'Fog Test Group'
+    description = 'Fog Test Security Group'
 
     tests(
     '#create_cache_security_group'
@@ -74,6 +73,8 @@ Shindo.tests('AWS::Elasticache | security group requests', ['aws', 'elasticache'
       tests(
       '#revoke_cache_security_group_ingress'
       ).formats(AWS::Elasticache::Formats::SINGLE_SECURITY_GROUP) do
+        pending if Fog.mocking?
+
         body = AWS[:elasticache].revoke_cache_security_group_ingress(
           name, ec2_group.name, ec2_group.owner_id
         ).body