fog-aws 3.12.0 → 3.15.0

data/tests/models/compute/vpcs_tests.rb

@@ -1,19 +0,0 @@
-Shindo.tests("Fog::Compute[:aws] | vpcs", ['aws']) do
-
-  collection_tests(Fog::Compute[:aws].vpcs, {:cidr_block => '10.0.10.0/28'}, true)
-
-  tests('tags') do
-    test_tags = {'foo' => 'bar'}
-    @vpc = Fog::Compute[:aws].vpcs.create(:cidr_block => '1.2.3.4/24', :tags => test_tags)
-
-    tests('@vpc.tags').returns(test_tags) do
-      @vpc.reload.tags
-    end
-
-    unless Fog.mocking?
-      Fog::Compute[:aws].tags.all('resource-id' => @vpc.id).each {|tag| tag.destroy}
-    end
-
-    @vpc.destroy
-  end
-end

data/tests/models/data_pipeline/pipeline_tests.rb

@@ -1,8 +0,0 @@
-Shindo.tests("AWS::DataPipeline | pipelines", ['aws', 'data_pipeline']) do
-  pending if Fog.mocking?
-
-  unique_id = uniq_id
-  model_tests(Fog::AWS[:data_pipeline].pipelines, { :id => unique_id, :name => "#{unique_id}-name", :unique_id => unique_id }) do
-    @instance.wait_for { state }
-  end
-end

data/tests/models/data_pipeline/pipelines_tests.rb

@@ -1,8 +0,0 @@
-Shindo.tests("AWS::DataPipeline | pipelines", ['aws', 'data_pipeline']) do
-  pending if Fog.mocking?
-
-  unique_id = uniq_id
-  collection_tests(Fog::AWS[:data_pipeline].pipelines, { :id => unique_id, :name => "#{unique_id}-name", :unique_id => unique_id }) do
-    @instance.wait_for { state }
-  end
-end

data/tests/models/dns/record_tests.rb

@@ -1,33 +0,0 @@
-Shindo.tests("Fog::Dns[:aws] | record", ['aws', 'dns']) do
-
-  tests("zones#create").succeeds do
-    @zone = Fog::DNS[:aws].zones.create(:domain => generate_unique_domain)
-  end
-
-  params = { :name => @zone.domain, :type => 'A', :ttl => 3600, :value => ['1.2.3.4'] }
-
-  model_tests(@zone.records, params) do
-
-    # Newly created records should have a change id
-    tests("#change_id") do
-      returns(true) { @instance.change_id != nil }
-    end
-
-    # Waits for changes to sync to all Route 53 DNS servers.  Usually takes ~30 seconds to complete.
-    tests("#ready? - may take a minute to complete...").succeeds do
-      @instance.wait_for { ready? }
-    end
-
-    tests("#modify") do
-      new_value = ['5.5.5.5']
-      returns(true) { @instance.modify(:value => new_value) }
-      returns(new_value) { @instance.value }
-    end
-
-  end
-
-  tests("zones#destroy").succeeds do
-    @zone.destroy
-  end
-
-end

data/tests/models/dns/records_tests.rb

@@ -1,41 +0,0 @@
-Shindo.tests("Fog::DNS[:aws] | records", ['aws', 'dns']) do
-
-  tests("zones#create").succeeds do
-    @zone = Fog::DNS[:aws].zones.create(:domain => generate_unique_domain)
-  end
-
-  param_groups = [
-    # A record
-    { :name => @zone.domain, :type => 'A', :ttl => 3600, :value => ['1.2.3.4'] },
-    # CNAME record
-    { :name => "www.#{@zone.domain}", :type => "CNAME", :ttl => 300, :value => @zone.domain}
-  ]
-
-  param_groups.each do |params|
-    collection_tests(@zone.records, params)
-  end
-
-  records = []
-
-  100.times do |i|
-    records << @zone.records.create(:name => "#{i}.#{@zone.domain}", :type => "A", :ttl => 3600, :value => ['1.2.3.4'])
-  end
-
-  records << @zone.records.create(:name => "*.#{@zone.domain}", :type => "A", :ttl => 3600, :value => ['1.2.3.4'])
-
-  tests("#all!").returns(101) do
-    @zone.records.all!.size
-  end
-
-  tests("#all wildcard parsing").returns(true) do
-    @zone.records.map(&:name).include?("*.#{@zone.domain}")
-  end
-
-  records.each do |record|
-    record.destroy
-  end
-
-  tests("zones#destroy").succeeds do
-    @zone.destroy
-  end
-end

data/tests/models/dns/zone_tests.rb

@@ -1,4 +0,0 @@
-Shindo.tests("Fog::DNS[:aws] | zone", ['aws', 'dns']) do
-  params = {:domain => generate_unique_domain }
-  model_tests(Fog::DNS[:aws].zones, params)
-end

data/tests/models/dns/zones_tests.rb

@@ -1,4 +0,0 @@
-Shindo.tests("Fog::DNS[:aws] | zones", ['aws', 'dns']) do
-  params = {:domain => generate_unique_domain }
-  collection_tests(Fog::DNS[:aws].zones, params)
-end

data/tests/models/efs/file_system_tests.rb

@@ -1,12 +0,0 @@
-Shindo.tests("AWS::EFS | file system", ["aws", "efs"]) do
-  file_system_params = {
-    :creation_token => "fogtoken#{rand(999).to_s}"
-  }
-
-  model_tests(Fog::AWS[:efs].file_systems, file_system_params, true)
-
-  file_system_params = {
-    :creation_token => "fogtoken#{rand(999).to_s}"
-  }
-  collection_tests(Fog::AWS[:efs].file_systems, file_system_params, true)
-end

data/tests/models/efs/mount_target_tests.rb

@@ -1,45 +0,0 @@
-Shindo.tests("AWS::EFS | mount target", ["aws", "efs"]) do
-  @file_system = Fog::AWS[:efs].file_systems.create(:creation_token => "fogtoken#{rand(999).to_s}")
-  @file_system.wait_for { ready? }
-
-  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_data = Fog::Compute[:aws].data[:security_groups].values.find do |sg|
-      sg['groupDescription'] == 'default_elb security group'
-    end
-    default_security_group = Fog::Compute[:aws].security_groups.new(default_security_group_data)
-  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#{rand(999).to_s}",
-    :description => "fog#{rand(999).to_s}"
-  )
-
-  mount_target_params = {
-    :file_system_id  => @file_system.identity,
-    :subnet_id       => subnet.identity,
-  }
-
-  model_tests(Fog::AWS[:efs].mount_targets, mount_target_params, true) do
-    @instance.wait_for { ready? }
-
-    tests("#security_groups") do
-      returns([default_security_group.group_id]) { @instance.security_groups }
-    end
-
-    tests("#security_groups=") do
-      @instance.security_groups = [security_group.group_id]
-      returns([security_group.group_id]) { @instance.security_groups }
-    end
-  end
-
-  @file_system.wait_for { number_of_mount_targets == 0 }
-  @file_system.destroy
-  security_group.destroy
-end

data/tests/models/efs/mount_targets_tests.rb

@@ -1,30 +0,0 @@
-Shindo.tests("AWS::EFS | mount targets", ["aws", "efs"]) do
-  @file_system = Fog::AWS[:efs].file_systems.create(:creation_token => "fogtoken#{rand(999).to_s}")
-  @file_system.wait_for { ready? }
-
-  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")
-  else
-    vpc = Fog::Compute[:aws].vpcs.first
-    subnet = vpc.subnets.first
-  end
-
-  security_group = Fog::Compute[:aws].security_groups.create(
-    :vpc_id      => vpc.id,
-    :name        => "fog#{rand(999).to_s}",
-    :description => "fog#{rand(999).to_s}"
-  )
-
-  mount_target_params = {
-    :file_system_id  => @file_system.identity,
-    :subnet_id       => subnet.identity,
-    :security_groups => [security_group.group_id]
-  }
-
-  collection_tests(Fog::AWS[:efs].mount_targets(:file_system_id => @file_system.identity), mount_target_params, true)
-
-  @file_system.wait_for { number_of_mount_targets == 0 }
-  @file_system.destroy
-  security_group.destroy
-end

data/tests/models/elasticache/cluster_tests.rb

@@ -1,30 +0,0 @@
-Shindo.tests('AWS::Elasticache | cache clusters', ['aws', 'elasticache']) do
-  cluster_params = {
-    :id               => "fog-test-cluster-#{rand(999).to_s}",
-    :node_type        => 'cache.m1.large',
-    :security_groups  => ['default'],
-    :engine           => 'memcached',
-    :num_nodes        => 1
-  }
-
-  pending if Fog.mocking?
-
-  Fog::Formatador.display_line "Creating cluster #{cluster_params[:id]}..."
-  model_tests(Fog::AWS[:elasticache].clusters, cluster_params, false) do
-    @instance.reload  # Reload to get the cluster info from AWS
-    Fog::Formatador.display_line "Waiting for #{@instance.id} "+
-      "to become available (#{@instance.status})..."
-    @instance.wait_for {ready?}
-  end
-
-  # Single model is still deleting, so re-randomize the cluster ID
-  cluster_params[:id] = "fog-test-cluster-#{rand(999).to_s}"
-  Fog::Formatador.display_line "Creating cluster #{cluster_params[:id]}..."
-  collection_tests(Fog::AWS[:elasticache].clusters, cluster_params, false) do
-    @instance.reload  # Reload to get the cluster info from AWS
-    Fog::Formatador.display_line "Waiting for #{@instance.id} "+
-      "to become available (#{@instance.status})..."
-    @instance.wait_for {ready?}
-  end
-
-end

data/tests/models/elasticache/parameter_groups_tests.rb

@@ -1,15 +0,0 @@
-Shindo.tests('AWS::Elasticache | parameter groups', ['aws', 'elasticache']) do
-  group_name = 'fog-test'
-  description = 'Fog Test'
-
-  model_tests(
-    Fog::AWS[:elasticache].parameter_groups,
-    {:id => group_name, :description => description}, true
-  )
-
-  collection_tests(
-    Fog::AWS[:elasticache].parameter_groups,
-    {:id => group_name, :description => description}, true
-  )
-
-end

data/tests/models/elasticache/security_groups_tests.rb

@@ -1,52 +0,0 @@
-Shindo.tests('AWS::Elasticache | security groups', ['aws', 'elasticache']) do
-  group_name = 'fog-test'
-  description = 'Fog Test'
-
-  pending if Fog.mocking?
-
-  model_tests(
-  Fog::AWS[:elasticache].security_groups,
-  {:id => group_name, :description => description}, false
-  ) do
-
-    # An EC2 group to authorize
-    ec2_group = Fog::Compute.new(:provider => 'AWS').security_groups.create(
-      :name => 'fog-test-elasticache', :description => 'fog test'
-    )
-
-    # Reload to get the instance owner_id
-    @instance.reload
-
-    tests('#authorize_ec2_group') do
-      @instance.authorize_ec2_group(ec2_group.name)
-      returns('authorizing') do
-        group = @instance.ec2_groups.find do |g|
-          g['EC2SecurityGroupName'] == ec2_group.name
-        end
-        group['Status']
-      end
-      returns(false, 'not ready') { @instance.ready? }
-    end
-
-    @instance.wait_for { ready? }
-
-    tests('#revoke_ec2_group') do
-      @instance.revoke_ec2_group(ec2_group.name)
-      returns('revoking') do
-        group = @instance.ec2_groups.find do |g|
-          g['EC2SecurityGroupName'] == ec2_group.name
-        end
-        group['Status']
-      end
-      returns(false, 'not ready') { @instance.ready? }
-    end
-
-    ec2_group.destroy
-  end
-
-  collection_tests(
-    Fog::AWS[:elasticache].security_groups,
-    {:id => group_name, :description => description}, false
-  )
-
-end

data/tests/models/elasticache/subnet_groups_tests.rb

@@ -1,43 +0,0 @@
-Shindo.tests('AWS::Elasticache | subnet group', ['aws', 'elasticache']) do
-  # random_differentiator
-  # Useful when rapidly re-running tests, so we don't have to wait
-  # serveral minutes for deleted VPCs/subnets to disappear
-  suffix = rand(65536).to_s(16)
-  @subnet_group_name = "fog-test-#{suffix}"
-
-  vpc_range = rand(245) + 10
-  @vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => "10.#{vpc_range}.0.0/16")
-
-  # Create 4 subnets in this VPC, each one in a different AZ
-  subnet_az = 'us-east-1a'
-  subnet_range = 8
-  @subnets = (1..3).map do
-    result = Fog::Compute[:aws].create_subnet(@vpc.id, "10.#{vpc_range}.#{subnet_range}.0/24",
-                                              'AvailabilityZone' => subnet_az)
-    subnet = result.body['subnet']
-    subnet_az = subnet_az.succ
-    subnet_range *= 2
-    subnet
-  end
-
-  tests('success') do
-    group_name = 'fog-test'
-    description = 'Fog Test'
-    subnet_ids = @subnets.map { |sn| sn['subnetId'] }.to_a
-
-    model_tests(
-      Fog::AWS[:elasticache].subnet_groups,
-      {:name => group_name, :subnet_ids => subnet_ids, :description => description}, true
-    )
-
-    collection_tests(
-      Fog::AWS[:elasticache].subnet_groups,
-      {:name => group_name, :subnet_ids => subnet_ids, :description => description}, true
-    )
-  end
-
-  @subnets.each do |sn|
-    Fog::Compute[:aws].delete_subnet(sn['subnetId'])
-  end
-  @vpc.destroy
-end