fog-aws 1.4.1 → 3.27.0

data/tests/models/iam/managed_policies_tests.rb

@@ -1,89 +0,0 @@
-Shindo.tests("Fog::Compute[:iam] | managed_policies", ['aws','iam']) do
-
-  iam = Fog::AWS[:iam]
-
-  tests('#all').succeeds do
-    iam.managed_policies.size == 100
-  end
-
-  tests('#each').succeeds do
-    policies = []
-
-    iam.managed_policies.each { |policy| policies << policy }
-
-    policies.size > 100
-  end
-
-  policy = iam.managed_policies.get("arn:aws:iam::aws:policy/IAMReadOnlyAccess")
-
-  tests("#document").succeeds do
-    policy.document == {
-      "Version"   => "2012-10-17",
-      "Statement" => [
-        {
-          "Effect"   => "Allow",
-          "Action"   => [ "iam:GenerateCredentialReport", "iam:GenerateServiceLastAccessedDetails", "iam:Get*", "iam:List*" ],
-          "Resource" => "*"
-        }
-      ]
-    }
-  end
-
-  tests("users") do
-    user = iam.users.create(:id => uniq_id("fog-test-user"))
-
-    tests("#attach").succeeds do
-      user.attach(policy)
-
-      user.attached_policies.map(&:identity) == [policy.identity]
-    end
-
-    returns(1) { policy.reload.attachments}
-
-    tests("#detach").succeeds do
-      user.detach(policy)
-
-      user.attached_policies.map(&:identity) == []
-    end
-
-    user.destroy
-  end
-
-  tests("groups") do
-    group = iam.groups.create(:name => uniq_id("fog-test-group"))
-
-    tests("#attach").succeeds do
-      group.attach(policy)
-
-      group.attached_policies.map(&:identity) == [policy.identity]
-    end
-
-    returns(1) { policy.reload.attachments}
-
-    tests("#detach").succeeds do
-      group.detach(policy)
-
-      group.attached_policies.map(&:identity) == []
-    end
-
-    group.destroy
-  end
-
-  tests("roles") do
-    role = iam.roles.create(:rolename => uniq_id("fog-test-role"))
-
-    tests("#attach").succeeds do
-      role.attach(policy)
-      role.attached_policies.map(&:identity) == [policy.identity]
-    end
-
-    returns(1) { policy.reload.attachments}
-
-    tests("#detach").succeeds do
-      role.detach(policy)
-      role.attached_policies.map(&:identity) == []
-    end
-
-    role.destroy
-  end
-end

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