fog-aws 3.5.2 → 3.19.0

data/tests/models/iam/policies_tests.rb

@@ -1,57 +0,0 @@
-Shindo.tests("Fog::Compute[:iam] | policies", ['aws','iam']) do
-
-  iam = Fog::AWS[:iam]
-
-  @username = 'fake_user'
-  @user = iam.users.create(:id => @username)
-  @policy_document = {"Statement"=>[{"Action"=>["sqs:*"], "Effect"=>"Allow", "Resource"=>"*"}]}
-  @policy_name = 'fake-sqs-policy'
-
-  tests('#all', 'there is no policies').succeeds do
-    @user.policies.empty?
-  end
-
-  tests('#create') do
-    tests('a valid policy').succeeds do
-      policy = @user.policies.create(:id => @policy_name, :document => @policy_document)
-      policy.id == @policy_name
-      policy.username == @username
-      policy.document == @policy_document
-    end
-
-    # The mocking doesn't validate the document policy
-    #tests('an invalid valid policy').succeeds do
-    #  raises(Fog::AWS::IAM::Error) { @user.policies.create(id: 'non-valid-document', document: 'invalid json blob') }
-    #end
-  end
-
-  @user.policies.create(:id => 'another-policy', :document => {})
-
-  tests('#all','there are two policies').succeeds do
-    @user.policies.size == 2
-  end
-
-  tests('#get') do
-    tests('a valid policy').succeeds do
-      policy = @user.policies.get(@policy_name)
-      policy.id == @polic_name
-      policy.username == @username
-      policy.document == @policy_document
-    end
-
-    tests('an invalid policy').succeeds do
-      @user.policies.get('non-existing') == nil
-    end
-  end
-
-  tests('#destroy').succeeds do
-    @user.policies.get(@policy_name).destroy
-  end
-
-  # clean up
-  @user.access_keys.map(&:destroy)
-  @user.policies.map(&:destroy)
-  @user.destroy
-
-
-end

data/tests/models/iam/roles_tests.rb

@@ -1,71 +0,0 @@
-Shindo.tests("Fog::Compute[:iam] | roles", ['aws','iam']) do
-
-  @iam = Fog::AWS[:iam]
-  @role_one_name = 'fake_role_one'
-  @role_two_name = 'fake_role_two'
-
-  @role_three_name = 'fake_role_three'
-  @role_three_path = '/path/to/fake_role_three/'
-  @role_four_name  = 'fake_role_four'
-
-  tests('#create').succeeds do
-    @role_one = @iam.roles.create(:rolename => @role_one_name)
-    @role_one.rolename == @role_one_name
-  end
-
-  tests('#all','there is only one role').succeeds do
-    @iam.roles.size == 1
-  end
-
-  tests('#all','the only role should match').succeeds do
-    @iam.roles.first.rolename == @role_one_name
-  end
-
-  tests('#create','a second role').succeeds do
-    @role_two = @iam.roles.create(:rolename => @role_two_name)
-    @role_two.rolename == @role_two_name
-  end
-
-  tests('#all','there are two roles').succeeds do
-    @iam.roles.size == 2
-  end
-
-  tests('#get','an existing role').succeeds do
-    @iam.roles.get(@role_one_name).rolename == @role_one_name
-  end
-
-  tests('#get',"returns nil if the role doesn't exists").succeeds do
-    @iam.roles.get('blah').nil?
-  end
-
-  tests('#create', 'assigns path').succeeds do
-    @role_three = @iam.roles.create(:rolename => @role_three_name, :path => @role_three_path)
-    @role_three.path == @role_three_path
-  end
-
-  tests('#create', 'defaults path to /').succeeds do
-    @role_four = @iam.roles.create(:rolename => @role_four_name)
-    @role_four.path == '/'
-  end
-
-  tests('#destroy','an existing role').succeeds do
-    @iam.roles.get(@role_one_name).destroy
-  end
-
-  tests('#all', 'limit 1').succeeds do
-    1 == @iam.roles.all(:limit => 1).size
-  end
-
-  tests('#all', 'each_entry').succeeds do
-    roles = []; @iam.roles.each(:limit => 1) { |r| roles << r }
-
-    3 == roles.size
-  end
-
-  tests('#destroy','clean up remaining roles').succeeds do
-    @iam.roles.get(@role_two_name).destroy
-    @iam.roles.get(@role_three_name).destroy
-    @iam.roles.get(@role_four_name).destroy
-  end
-
-end

data/tests/models/iam/users_tests.rb

@@ -1,119 +0,0 @@
-Shindo.tests("Fog::Compute[:iam] | users", ['aws','iam']) do
-
-  iam = Fog::AWS[:iam]
-
-  user_one_name   = 'fake_user_one'
-  user_two_name   = 'fake_user_two'
-  user_three_name = 'fake_user_three'
-  user_three_path = '/path/to/fake_user_three/'
-  user_four_name  = 'fake_user_four'
-
-  def all_users
-    Fog::AWS[:iam].users.all.select{|user| user.id =~ /^fake_user/ }
-  end
-
-  tests('#create').succeeds do
-    user_one = iam.users.create(:id => user_one_name)
-    user_one.id == user_one_name
-  end
-
-  tests('#all','there is only one user').succeeds do
-    all_users.size == 1
-  end
-
-  tests('#all','the only user should match').succeeds do
-    all_users.first.id == user_one_name
-  end
-
-  tests('#create','a second user').succeeds do
-    user_two = iam.users.create(:id => user_two_name)
-    user_two.id == user_two_name
-  end
-
-  tests('#all','there are two users').succeeds do
-    all_users.size == 2
-  end
-
-  user = iam.users.get(user_one_name)
-
-  tests('#get','an existing user').succeeds do
-    user.id == user_one_name
-  end
-
-  tests('#current').succeeds do
-    iam.users.current
-  end
-
-  tests('#get',"returns nil if the user doesn't exists").succeeds do
-    iam.users.get('non-exists') == nil
-  end
-
-  tests('#policies','it has no policies').succeeds do
-    user.policies.empty?
-  end
-
-  tests('#access_keys','it has no keys').succeeds do
-    user.access_keys.empty?
-  end
-
-  # test that users create in mock and be signed in via access key and share data
-  if Fog.mocking?
-    tests("mocking access key usage") do
-      access_key = user.access_keys.create
-
-      user_client = Fog::AWS::IAM.new(
-        :aws_access_key_id     => access_key.identity,
-        :aws_secret_access_key => access_key.secret_access_key
-      )
-
-      tests("sets correct data").succeeds do
-        user_client.users.size > 1
-      end
-
-      tests("set current user name").succeeds do
-        user_client.current_user_name == user.identity
-      end
-    end
-  end
-
-  tests('#password=nil', 'without a password').succeeds do
-    user.password = nil
-    user.password_created_at.nil?
-  end
-
-  tests('#password=(password)').succeeds do
-    user.password = SecureRandom.base64(10)
-
-    user.password_created_at.is_a?(Time)
-  end
-
-  tests('#password=(update_password)').succeeds do
-    user.password = SecureRandom.base64(10)
-
-    user.password_created_at.is_a?(Time)
-  end
-
-  tests('#password=nil', 'with a password').succeeds do
-    user.password = nil
-    user.password_created_at.nil?
-  end
-
-  tests('#create', 'assigns path').succeeds do
-    user_three = iam.users.create(:id => user_three_name, :path => user_three_path)
-    user_three.path == user_three_path
-  end
-
-  tests('#create', 'defaults path to /').succeeds do
-    user_four = iam.users.create(:id => user_four_name)
-    user_four.path == '/'
-  end
-
-  tests('#destroy','an existing user').succeeds do
-    iam.users.get(user_one_name).destroy
-  end
-
-  tests('#destroy','clean up remaining user').succeeds do
-    iam.users.get(user_two_name).destroy
-  end
-
-end

data/tests/models/rds/cluster_tests.rb

@@ -1,54 +0,0 @@
-Shindo.tests("AWS::RDS | cluster", ["aws", "rds"]) do
-  model_tests(Fog::AWS[:rds].clusters, rds_default_cluster_params) do
-    @cluster_id = @instance.id
-    @instance.wait_for(20*60) { ready? }
-    @cluster_with_final_snapshot = Fog::AWS[:rds].clusters.create(rds_default_cluster_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
-
-    tests("#servers") do
-      returns([]) { @instance.servers }
-    end
-
-    @server = Fog::AWS[:rds].servers.create(rds_default_server_params.reject { |k,v| [:allocated_storage, :master_username, :password, :backup_retention_period].include?(k) }.merge(:engine => "aurora", :cluster_id => @instance.id, :flavor_id => "db.r3.large"))
-    @server.wait_for(20*60) { ready? }
-
-    tests("#servers") do
-      @instance.reload
-      returns([{"DBInstanceIdentifier" => @server.id, "master" => true}]) { @instance.db_cluster_members }
-      returns([@server]) { @instance.servers }
-    end
-
-    tests("#snapshots") do
-      returns([]) { @instance.snapshots }
-
-      snapshot_id = uniq_id("manual-snapshot")
-      snapshot = @instance.snapshots.create(:id => snapshot_id)
-      returns(snapshot_id) { snapshot.id }
-      snapshot.wait_for { ready? }
-      returns([snapshot.id]) { @instance.snapshots.map(&:id) }
-      snapshot.destroy
-    end
-
-    tests("#destroy") do
-      snapshot_id = uniq_id("fog-snapshot")
-
-      @instance.servers.map(&:destroy)
-
-      @cluster_with_final_snapshot.wait_for(20*60) { ready? }
-      @cluster_with_final_snapshot.destroy(snapshot_id)
-
-      snapshot = Fog::AWS[:rds].cluster_snapshots.get(snapshot_id)
-      snapshot.wait_for { ready? }
-      returns(snapshot_id) { snapshot.id }
-      snapshot.destroy
-    end
-
-    after do
-      if cluster = Fog::AWS[:rds].clusters.get(@cluster_id)
-        unless cluster.state = 'deleting'
-          cluster.servers.map(&:destroy)
-          cluster.destroy
-        end
-      end
-    end
-  end
-end

data/tests/models/rds/clusters_tests.rb

@@ -1,5 +0,0 @@
-Shindo.tests("AWS::RDS | clusters", ["aws", "rds"]) do
-  collection_tests(Fog::AWS[:rds].clusters, rds_default_cluster_params) do
-    @instance.wait_for { ready? }
-  end
-end

data/tests/models/rds/event_subscription_tests.rb

@@ -1,9 +0,0 @@
-Shindo.tests("AWS::RDS | event_subscription", ['aws', 'rds']) do
-  pending unless Fog.mocking?
-
-  name = 'fog'
-  params = {:id => name, :sns_topic_arn => 'arn:aws:sns:us-east-1:12345678910:fog'}
-
-  model_tests(Fog::AWS[:rds].event_subscriptions, params) do
-  end
-end

data/tests/models/rds/event_subscriptions_tests.rb

@@ -1,6 +0,0 @@
-Shindo.tests("AWS::RDS | event subscriptions", ['aws', 'rds']) do
-  pending unless Fog.mocking?
-  params = {:id => "fog", :sns_topic_arn => 'arn:aws:sns:us-east-1:12345678910:fog'}
-
-  collection_tests(Fog::AWS[:rds].event_subscriptions, params)
-end

data/tests/models/rds/helper.rb

@@ -1,25 +0,0 @@
-def rds_default_server_params
-  {
-    :allocated_storage       => 5,
-    :backup_retention_period => 0,
-    :engine                  => 'mysql',
-    :version                 => '5.6.22',
-    :id                      => uniq_id,
-    :master_username         => 'foguser',
-    :password                => 'fogpassword',
-    :flavor_id               => 'db.m3.medium',
-  }
-end
-
-def rds_default_cluster_params
-  {
-    :allocated_storage       => 50,
-    :backup_retention_period => 10,
-    :engine                  => "aurora",
-    :version                 => "5.6.10a",
-    :id                      => uniq_id,
-    :master_username         => "fogclusteruser",
-    :password                => "fogpassword",
-    :flavor_id               => "db.r3.large"
-  }
-end

data/tests/models/rds/instance_option_tests.rb

@@ -1,14 +0,0 @@
-Shindo.tests("AWS::RDS | db instance options", ['aws', 'rds']) do
-
-  params = {:engine => 'mysql'}
-
-  pending if Fog.mocking?
-
-  tests('#options') do
-    tests 'contains options' do
-      @instance = Fog::AWS[:rds].instance_options.new(params)
-      returns(true) { @instance.engine == 'mysql' }
-    end
-  end
-
-end

data/tests/models/rds/parameter_group_tests.rb

@@ -1,24 +0,0 @@
-Shindo.tests("AWS::RDS | parameter_group", ['aws', 'rds']) do
-
-  group_name = 'fog-test'
-  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
-
-  pending if Fog.mocking?
-  model_tests(Fog::AWS[:rds].parameter_groups, params, false) do
-    tests('#parameters') do
-      #search for a sample parameter
-      tests 'contains parameters' do
-        returns(true){ @instance.parameters.any? {|p| p.name == 'query_cache_size'}}
-      end
-    end
-
-    tests('#modify') do
-      @instance.modify([{:name => 'query_cache_size', :value => '6553600', :apply_method => 'immediate'}])
-
-      tests 'parameter has changed' do
-        returns('6553600'){@instance.parameters.find {|p| p.name == 'query_cache_size'}.value}
-      end
-    end
-
-  end
-end

data/tests/models/rds/parameter_groups_tests.rb

@@ -1,8 +0,0 @@
-Shindo.tests("AWS::RDS | parameter_groups", ['aws', 'rds']) do
-
-  group_name = 'fog-test'
-  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
-
-  pending if Fog.mocking?
-  collection_tests(Fog::AWS[:rds].parameter_groups, params, false)
-end

data/tests/models/rds/security_group_tests.rb

@@ -1,77 +0,0 @@
-Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
-  group_name = 'fog-test'
-  params = {:id => group_name, :description => 'fog test'}
-
-  model_tests(Fog::AWS[:rds].security_groups, params) do
-
-    tests("#description").returns('fog test') { @instance.description }
-
-    @ec2_sec_group = Fog::Compute[:aws].security_groups.create(:name => uniq_id("fog-rds-test"), :description => 'fog test')
-
-    tests("#authorize_ec2_security_group('#{@ec2_sec_group.name}')").succeeds do
-      @instance.authorize_ec2_security_group(@ec2_sec_group.name)
-      returns('authorizing') do
-        @instance.ec2_security_groups.find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
-      end
-    end
-
-    @instance.wait_for { ready? }
-
-    tests("#revoke_ec2_security_group('#{@ec2_sec_group.name}')").succeeds do
-      @instance.revoke_ec2_security_group(@ec2_sec_group.name)
-
-      returns('revoking') do
-        @instance.ec2_security_groups.find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
-      end
-
-      @instance.wait_for { ready? }
-
-      returns(false) { @instance.ec2_security_groups.any?{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name} }
-    end
-
-    @instance.wait_for { ready? }
-
-    tests("#authorize_ec2_security_group('#{@ec2_sec_group.group_id}')").succeeds do
-      @instance.authorize_ec2_security_group(@ec2_sec_group.group_id)
-      returns('authorizing') do
-        @instance.ec2_security_groups.find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
-      end
-    end
-
-    @instance.wait_for { ready? }
-
-    tests("#revoke_ec2_security_group('#{@ec2_sec_group.group_id}')").succeeds do
-      @instance.revoke_ec2_security_group(@ec2_sec_group.group_id)
-
-      returns('revoking') do
-        @instance.ec2_security_groups.find{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
-      end
-
-      @instance.wait_for { ready? }
-
-      returns(false) { @instance.ec2_security_groups.any?{|h| h['EC2SecurityGroupId'] == @ec2_sec_group.group_id} }
-    end
-
-    @instance.wait_for { ready? }
-
-    @ec2_sec_group.destroy
-
-    tests("#authorize_cidrip").succeeds do
-      @cidr = '127.0.0.1/32'
-      @instance.authorize_cidrip(@cidr)
-      returns('authorizing') { @instance.ip_ranges.find{|h| h['CIDRIP'] == @cidr}['Status'] }
-    end
-
-    tests("#revoke_cidrip").succeeds do
-      pending if Fog.mocking?
-
-      @instance.wait_for { ready? }
-      @instance.revoke_cidrip(@cidr)
-      returns('revoking') { @instance.ip_ranges.find{|h| h['CIDRIP'] == @cidr}['Status'] }
-      @instance.wait_for { ready? }
-      returns(false) { @instance.ip_ranges.any?{|h| h['CIDRIP'] == @cidr} }
-
-    end
-
-  end
-end

data/tests/models/rds/security_groups_tests.rb

@@ -1,5 +0,0 @@
-Shindo.tests("AWS::RDS | security groups", ['aws', 'rds']) do
-  params = {:id => 'fog-test', :description => 'fog test'}
-
-  collection_tests(Fog::AWS[:rds].security_groups, params)
-end

data/tests/models/rds/server_tests.rb

@@ -1,131 +0,0 @@
-Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
-  model_tests(Fog::AWS[:rds].servers, rds_default_server_params) do
-    # We'll need this later; create it early to avoid waiting
-    @instance_with_final_snapshot = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
-    @instance_with_encrypted_storage = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:storage_encrypted => true))
-
-    @instance.wait_for(20*60) { ready? }
-    @instance_with_encrypted_storage.wait_for(20*60) { ready? }
-    @final_snapshot_id = uniq_id('fog-test-snapshot')
-
-    tests("#storage_encrypted") do
-      returns(true) { @instance_with_encrypted_storage.storage_encrypted }
-    end
-
-    test('#read_replica_identifiers is []') do
-      returns([]) { @instance.read_replica_identifiers }
-    end
-
-    tests('#snapshots') do
-      snapshot = nil
-
-      tests('#create').succeeds do
-        snapshot = @instance.snapshots.create(:id => uniq_id('fog-snapshot-test'))
-      end
-
-      snapshot.wait_for { ready?}
-
-      @instance.wait_for { ready? }
-
-      returns(true) { @instance.snapshots.map{ |s| s.id }.include?(snapshot.id) }
-      snapshot.destroy
-    end
-
-    tests("#modify").succeeds do
-      pending if Fog.mocking?
-
-      engine  = rds_default_server_params.fetch(:engine)
-      version = rds_default_server_params.fetch(:version).match(/\d+\.\d+/).to_s
-
-      orig_parameter_group = @instance.db_parameter_groups.first['DBParameterGroupName']
-      parameter_group = Fog::AWS[:rds].parameter_groups.create(:id => uniq_id, :family => "#{engine}#{version}", :description => 'fog-test')
-
-      orig_security_groups = @instance.db_security_groups.map{|h| h['DBSecurityGroupName']}
-      security_group = Fog::AWS[:rds].security_groups.create(:id => uniq_id, :description => 'fog-test')
-
-      modify_options = {
-        'DBParameterGroupName' => parameter_group.id,
-        'DBSecurityGroups' => orig_security_groups + [security_group.id]
-      }
-
-      @instance.modify(true, modify_options)
-      @instance.wait_for { ready? }
-
-      returns(parameter_group.id, 'new parameter group') do
-        @instance.db_parameter_groups.first['DBParameterGroupName']
-      end
-
-      returns(true, "new security group") do
-        @instance.db_security_groups.any?{|hash| hash['DBSecurityGroupName'] == security_group.id}
-      end
-
-      @instance.reboot
-      @instance.wait_for { state == 'rebooting' }
-      @instance.wait_for { ready? }
-
-      # Restore back to original state using symbols
-      restore_options = {
-       :parameter_group_name => orig_parameter_group,
-       :security_group_names => orig_security_groups
-      }
-      @instance.modify(true, restore_options)
-
-      @instance.reboot
-      @instance.wait_for { state == 'rebooting' }
-      @instance.wait_for do
-        ready? &&
-          db_security_groups.all? {|hash| hash['Status'] == 'active'} &&
-          db_parameter_groups.all? {|hash| hash['ParameterApplyStatus'] == 'in-sync' }
-      end
-
-      parameter_group.destroy
-      security_group.destroy
-    end
-
-    tests("#reboot").succeeds do
-      @instance.reboot
-    end
-    @instance.wait_for { state == 'rebooting' }
-    @instance.wait_for { ready? }
-
-    replica = nil
-
-    tests('#create_read_replica').succeeds do
-      replica = @instance_with_final_snapshot.create_read_replica(uniq_id('fog-replica'))
-      @instance_with_final_snapshot.reload
-      returns([replica.id]) { @instance_with_final_snapshot.read_replica_identifiers }
-      returns(@instance_with_final_snapshot.id) { replica.read_replica_source }
-
-      replica.wait_for { ready? }
-
-      # FinalDBSnapshotIdentifier can not be specified when deleting a replica instance
-      raises(Fog::AWS::RDS::Error) { replica.destroy("foobar") }
-    end
-
-    tests('#promote_read_replica').succeeds do
-      replica.promote.wait_for { state != "modifying" }
-
-      replica.read_replica_source == nil
-    end
-
-    tests('#promote_read_replica', 'master').raises(Fog::AWS::RDS::Error) {
-      @instance_with_final_snapshot.promote
-    }
-
-    replica && replica.destroy
-
-    test("Destroying with a final snapshot") do
-
-      @instance_with_final_snapshot.wait_for { ready? }
-      @instance_with_final_snapshot.destroy(@final_snapshot_id)
-      returns(true, "Final snapshot created") do
-        @final_snapshot = Fog::AWS[:rds].snapshots.get(@final_snapshot_id)
-        !@final_snapshot.nil?
-      end
-
-      @final_snapshot.wait_for { ready? }
-      @final_snapshot.destroy
-    end
-
-  end
-end

data/tests/models/rds/servers_tests.rb

@@ -1,24 +0,0 @@
-Shindo.tests("AWS::RDS | servers", ['aws', 'rds']) do
-
-  collection_tests(Fog::AWS[:rds].servers, rds_default_server_params) do
-    @instance.wait_for { ready? }
-  end
-
-  tests("#restore").succeeds do
-    instance = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test")))
-
-    snapshot_id = uniq_id('fog-snapshot-test')
-    @snapshot = instance.snapshots.create(:id => snapshot_id )
-    instance.destroy
-
-    db_name = uniq_id('fog-db-name')
-    @restore_instance = Fog::AWS[:rds].servers.restore('master_username' => instance.master_username, 'flavor_id' => 'db.m3.medium', 'source_snapshot_id' => snapshot_id, 'id' => uniq_id('restored-instance'))
-  end
-
-  if Fog.mocking? && @restore_instance.respond_to?(:ready?)
-    @restore_instance.wait_for { ready? }
-  end
-
-  @snapshot.destroy
-  @restore_instance.destroy
-end

data/tests/models/rds/snapshot_tests.rb

@@ -1,12 +0,0 @@
-Shindo.tests("AWS::RDS | snapshot", ['aws', 'rds']) do
-
-  @server = Fog::AWS[:rds].servers.create(rds_default_server_params)
-  @server.wait_for { ready? }
-
-  params = {:id => uniq_id, :instance_id => @server.id}
-  model_tests(Fog::AWS[:rds].snapshots, params) do
-    @instance.wait_for { ready? }
-  end
-
-  @server.destroy
-end

data/tests/models/rds/snapshots_tests.rb

@@ -1,12 +0,0 @@
-Shindo.tests("AWS::RDS | snapshots", ['aws', 'rds']) do
-
-  @server = Fog::AWS[:rds].servers.create(rds_default_server_params)
-  @server.wait_for { ready? }
-
-  params = {:id => uniq_id, :instance_id => @server.id}
-  collection_tests(Fog::AWS[:rds].snapshots, params) do
-    @instance.wait_for { ready? }
-  end
-
-  @server.destroy
-end