fog-aws 0.0.5

data/tests/requests/iam/server_certificate_tests.rb

@@ -0,0 +1,130 @@
+Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
+  @key_name = 'fog-test'
+  @key_name_chained = 'fog-test-chained'
+
+  @certificate_format = {
+    'Arn' => String,
+    'Path' => String,
+    'ServerCertificateId' => String,
+    'ServerCertificateName' => String,
+    'UploadDate' => Time
+  }
+  @upload_format = {
+    'Certificate' => @certificate_format,
+    'RequestId' => String
+  }
+  @update_format = {
+    'RequestId' => String
+  }
+  @get_server_certificate_format = {
+    'Certificate' => @certificate_format,
+    'RequestId' => String
+  }
+  @list_format = {
+    'Certificates' => [@certificate_format]
+  }
+
+  tests('#upload_server_certificate') do
+    public_key  = AWS::IAM::SERVER_CERT
+    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
+    private_key_pkcs8 = AWS::IAM::SERVER_CERT_PRIVATE_KEY_PKCS8
+    private_key_mismatch = AWS::IAM::SERVER_CERT_PRIVATE_KEY_MISMATCHED
+
+    tests('empty public key').raises(Fog::AWS::IAM::ValidationError) do
+      Fog::AWS::IAM.new.upload_server_certificate('', private_key, @key_name)
+    end
+
+    tests('empty private key').raises(Fog::AWS::IAM::ValidationError) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, '', @key_name)
+    end
+
+    tests('invalid public key').raises(Fog::AWS::IAM::MalformedCertificate) do
+      Fog::AWS::IAM.new.upload_server_certificate('abcde', private_key, @key_name)
+    end
+
+    tests('invalid private key').raises(Fog::AWS::IAM::MalformedCertificate) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, 'abcde', @key_name)
+    end
+
+    tests('non-RSA private key').raises(Fog::AWS::IAM::MalformedCertificate) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_pkcs8, @key_name)
+    end
+
+    tests('mismatched private key').raises(Fog::AWS::IAM::KeyPairMismatch) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key_mismatch, @key_name)
+    end
+
+    tests('format').formats(@upload_format) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, @key_name).body
+    end
+
+    tests('format with chain').formats(@upload_format) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, @key_name_chained, { 'CertificateChain' => public_key }).body
+    end
+
+    tests('duplicate name').raises(Fog::AWS::IAM::EntityAlreadyExists) do
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, @key_name)
+    end
+  end
+
+  tests('#update_server_certificate') do
+    public_key  = AWS::IAM::SERVER_CERT
+    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
+    key_name    = "update-key"
+
+    Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, key_name)
+
+    tests('duplicate name').raises(Fog::AWS::IAM::EntityAlreadyExists) do
+      other_key_name = "other-key-name"
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, other_key_name)
+
+      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
+    end
+
+    tests('unknown name').raises(Fog::AWS::IAM::NotFound) do
+      Fog::AWS::IAM.new.update_server_certificate("unknown-key-name", {'NewServerCertificateName' => "other-keyname"})
+    end
+
+    tests('format').formats(@update_format) do
+      Fog::AWS::IAM.new.update_server_certificate(key_name).body
+    end
+
+    tests('updates name') do
+      other_key_name = "successful-update-key-name"
+      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
+      returns(true) { Fog::AWS::IAM.new.get_server_certificate(other_key_name).body['Certificate']['ServerCertificateName'] == other_key_name }
+    end
+  end
+
+  tests('#get_server_certificate').formats(@get_server_certificate_format) do
+    tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
+      Fog::AWS::IAM.new.get_server_certificate("#{@key_name}fake")
+    end
+    Fog::AWS::IAM.new.get_server_certificate(@key_name).body
+  end
+
+  tests('#list_server_certificates').formats(@list_format) do
+    result = Fog::AWS::IAM.new.list_server_certificates.body
+    tests('includes key name') do
+      returns(true) { result['Certificates'].any?{|c| c['ServerCertificateName'] == @key_name} }
+    end
+    result
+  end
+
+  tests("#list_server_certificates('path-prefix' => '/'").formats(@list_format) do
+    result = Fog::AWS::IAM.new.list_server_certificates('PathPrefix' => '/').body
+    tests('includes key name') do
+      returns(true) { result['Certificates'].any?{|c| c['ServerCertificateName'] == @key_name} }
+    end
+    result
+  end
+
+  tests('#delete_server_certificate').formats(AWS::IAM::Formats::BASIC) do
+    tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
+      Fog::AWS::IAM.new.delete_server_certificate("#{@key_name}fake")
+    end
+    Fog::AWS::IAM.new.delete_server_certificate(@key_name).body
+  end
+
+  Fog::AWS::IAM.new.delete_server_certificate(@key_name_chained)
+end

data/tests/requests/iam/user_policy_tests.rb

@@ -0,0 +1,45 @@
+Shindo.tests('AWS::IAM | user policy requests', ['aws']) do
+
+  Fog::AWS[:iam].create_user('fog_user_policy_tests')
+
+  tests('success') do
+
+    @policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+    tests("#put_user_policy('fog_user_policy_tests', 'fog_policy', #{@policy.inspect})").formats(AWS::IAM::Formats::BASIC) do
+      Fog::AWS[:iam].put_user_policy('fog_user_policy_tests', 'fog_policy', @policy).body
+    end
+
+    @user_policies_format = {
+      'IsTruncated' => Fog::Boolean,
+      'PolicyNames' => [String],
+      'RequestId'   => String
+    }
+
+    tests("#list_user_policies('fog_user_policy_tests')").formats(@user_policies_format) do
+      Fog::AWS[:iam].list_user_policies('fog_user_policy_tests').body
+    end
+
+    @user_policy_format = {
+      'UserName' => String,
+      'PolicyName' => String,
+      'PolicyDocument' => Hash,
+    }
+
+    tests("#get_user_policy('fog_user_policy_tests', 'fog_policy'").formats(@user_policy_format) do
+      Fog::AWS[:iam].get_user_policy('fog_policy', 'fog_user_policy_tests').body['Policy']
+    end
+
+    tests("#delete_user_policy('fog_user_policy_tests', 'fog_policy')").formats(AWS::IAM::Formats::BASIC) do
+      Fog::AWS[:iam].delete_user_policy('fog_user_policy_tests', 'fog_policy').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+  Fog::AWS[:iam].delete_user('fog_user_policy_tests')
+
+end

data/tests/requests/iam/user_tests.rb

@@ -0,0 +1,77 @@
+Shindo.tests('AWS::IAM | user requests', ['aws']) do
+
+  Fog::AWS[:iam].create_group('fog_user_tests')
+
+  tests('success') do
+
+    @user_format = {
+      'User' => {
+        'Arn'        => String,
+        'Path'       => String,
+        'UserId'     => String,
+        'UserName'   => String,
+        'CreateDate' => Time
+      },
+      'RequestId' => String
+    }
+
+    tests("#create_user('fog_user')").formats(@user_format) do
+      Fog::AWS[:iam].create_user('fog_user').body
+    end
+
+    @users_format = {
+      'Users' => [{
+        'Arn'        => String,
+        'Path'       => String,
+        'UserId'     => String,
+        'UserName'   => String,
+        'CreateDate' => Time
+      }],
+      'IsTruncated' => Fog::Boolean,
+      'RequestId'   => String
+    }
+
+    tests("#list_users").formats(@users_format) do
+      Fog::AWS[:iam].list_users.body
+    end
+
+    tests("#get_user").formats(@user_format) do
+      Fog::AWS[:iam].get_user('fog_user').body
+    end
+
+    tests("#add_user_to_group('fog_user_tests', 'fog_user')").formats(AWS::IAM::Formats::BASIC) do
+      Fog::AWS[:iam].add_user_to_group('fog_user_tests', 'fog_user').body
+    end
+
+    @groups_format = {
+      'GroupsForUser' => [{
+        'Arn'       => String,
+        'GroupId'   => String,
+        'GroupName' => String,
+        'Path'      => String
+      }],
+      'IsTruncated' => Fog::Boolean,
+      'RequestId'   => String
+    }
+
+    tests("#list_groups_for_user('fog_user')").formats(@groups_format) do
+      Fog::AWS[:iam].list_groups_for_user('fog_user').body
+    end
+
+    tests("#remove_user_from_group('fog_user_tests', 'fog_user')").formats(AWS::IAM::Formats::BASIC) do
+      Fog::AWS[:iam].remove_user_from_group('fog_user_tests', 'fog_user').body
+    end
+
+    tests("#delete_user('fog_user')").formats(AWS::IAM::Formats::BASIC) do
+      Fog::AWS[:iam].delete_user('fog_user').body
+    end
+
+  end
+
+  tests('failure') do
+    test('failing conditions')
+  end
+
+  Fog::AWS[:iam].delete_group('fog_user_tests')
+
+end

data/tests/requests/rds/describe_events.rb

@@ -0,0 +1,16 @@
+Shindo.tests('AWS::RDS | describe DB events requests',['aws', 'rds']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests(
+    '#describe_events'
+    ).formats(AWS::RDS::Formats::EVENT_LIST) do
+      Fog::AWS[:rds].describe_events().body['Events']
+    end
+  end
+
+  tests('failure') do
+    #TODO: What constitutes a failure here?
+  end
+end

data/tests/requests/rds/event_subscription_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests('AWS::RDS | event subscription requests', ['aws', 'rds']) do
+  pending unless Fog.mocking?
+
+  @name = 'fog'
+  @arn  = 'arn:aws:sns:us-east-1:12345678910:fog'
+
+  tests('success') do
+    tests('#create_event_subscription').formats(AWS::RDS::Formats::CREATE_EVENT_SUBSCRIPTION) do
+      body = Fog::AWS[:rds].create_event_subscription('SubscriptionName' => @name, 'SnsTopicArn' => @arn).body
+
+      returns(@name) { body['CreateEventSubscriptionResult']['EventSubscription']['CustSubscriptionId'] }
+      returns('creating') { body['CreateEventSubscriptionResult']['EventSubscription']['Status'] }
+      body
+    end
+
+    tests("#describe_event_subscriptions").formats(AWS::RDS::Formats::DESCRIBE_EVENT_SUBSCRIPTIONS) do
+      returns('active') { Fog::AWS[:rds].describe_event_subscriptions.body['DescribeEventSubscriptionsResult']['EventSubscriptionsList'].first['Status'] }
+      Fog::AWS[:rds].describe_event_subscriptions.body
+    end
+
+    tests("#delete_event_subscription").formats(AWS::RDS::Formats::BASIC) do
+      body = Fog::AWS[:rds].delete_event_subscription(@name).body
+
+      returns('deleting') { Fog::AWS[:rds].describe_event_subscriptions('SubscriptionName' => @name).body['DescribeEventSubscriptionsResult']['EventSubscriptionsList'].first['Status'] }
+      raises(Fog::AWS::RDS::NotFound) { Fog::AWS[:rds].describe_event_subscriptions('SubscriptionName' => @name) }
+
+      body
+    end
+  end
+end

data/tests/requests/rds/helper.rb

@@ -0,0 +1,296 @@
+class AWS
+  module RDS
+    module Formats
+      BASIC = {
+        'ResponseMetadata' => { 'RequestId' => String }
+      }
+
+      DB_AVAILABILITY_ZONE_OPTION = {
+          'Name' => String,
+          'ProvisionedIopsCapable' => Fog::Boolean
+      }
+
+      DB_PARAMETER_GROUP = {
+          'DBParameterGroupFamily' => String,
+          'DBParameterGroupName' => String,
+          'Description' => String
+      }
+      CREATE_DB_PARAMETER_GROUP = {
+        'ResponseMetadata' => { 'RequestId' => String },
+        'CreateDBParameterGroupResult' => {
+          'DBParameterGroup' => DB_PARAMETER_GROUP
+        }
+      }
+
+      DB_SECURITY_GROUP = {
+        'DBSecurityGroupDescription' => String,
+        'DBSecurityGroupName' => String,
+        'EC2SecurityGroups' => [Fog::Nullable::Hash],
+        'IPRanges' => [Fog::Nullable::Hash],
+        'OwnerId' => Fog::Nullable::String
+      }
+
+      CREATE_DB_SECURITY_GROUP = BASIC.merge({
+        'CreateDBSecurityGroupResult' => {
+        'DBSecurityGroup' => DB_SECURITY_GROUP
+        }
+      })
+
+      AUTHORIZE_DB_SECURITY_GROUP = BASIC.merge({
+        'AuthorizeDBSecurityGroupIngressResult' => {
+          'DBSecurityGroup' => DB_SECURITY_GROUP
+        }
+      })
+
+      REVOKE_DB_SECURITY_GROUP = BASIC.merge({
+        'RevokeDBSecurityGroupIngressResult' => {
+          'DBSecurityGroup' => DB_SECURITY_GROUP
+        }
+      })
+
+      DESCRIBE_DB_SECURITY_GROUP = BASIC.merge({
+        'DescribeDBSecurityGroupsResult' => {
+          'DBSecurityGroups' => [DB_SECURITY_GROUP]
+        }
+      })
+
+      DB_SUBNET_GROUP = {
+        'DBSubnetGroupName' => String,
+        'DBSubnetGroupDescription' => String,
+        'SubnetGroupStatus' => String,
+        'VpcId' => String,
+        'Subnets' => [String]
+      }
+
+      CREATE_DB_SUBNET_GROUP = BASIC.merge({
+        'CreateDBSubnetGroupResult' => {
+          'DBSubnetGroup' => DB_SUBNET_GROUP
+        }
+      })
+
+      DESCRIBE_DB_SUBNET_GROUPS = BASIC.merge({
+        'DescribeDBSubnetGroupsResult' => {
+          'DBSubnetGroups' => [DB_SUBNET_GROUP]
+        }
+      })
+
+      DESCRIBE_DB_PARAMETER_GROUP = {
+        'ResponseMetadata' => { 'RequestId' => String },
+        'DescribeDBParameterGroupsResult' => {
+          'DBParameterGroups' => [DB_PARAMETER_GROUP]
+        }
+      }
+
+      ORDERABLE_DB_INSTANCE_OPTION = {
+          'MultiAZCapable' => Fog::Boolean,
+          'Engine' => String,
+          'LicenseModel' => String,
+          'ReadReplicaCapable' => Fog::Boolean,
+          'EngineVersion' => String,
+          'AvailabilityZones' => [DB_AVAILABILITY_ZONE_OPTION],
+          'DBInstanceClass' => String,
+          'Vpc' => Fog::Boolean
+      }
+
+      DESCRIBE_ORDERABLE_DB_INSTANCE_OPTION = BASIC.merge({
+          'DescribeOrderableDBInstanceOptionsResult' => {
+              'OrderableDBInstanceOptions' => [ORDERABLE_DB_INSTANCE_OPTION]
+          }
+      })
+
+      MODIFY_PARAMETER_GROUP = BASIC.merge({
+        'ModifyDBParameterGroupResult' => {
+          'DBParameterGroupName' => String
+        }
+      })
+
+      DB_PARAMETER = {
+        'ParameterValue' => Fog::Nullable::String,
+        'DataType' => String,
+        'AllowedValues' => Fog::Nullable::String,
+        'Source' => String,
+        'IsModifiable' => Fog::Boolean,
+        'Description' => String,
+        'ParameterName' => String,
+        'ApplyType' => String
+      }
+
+      DESCRIBE_DB_PARAMETERS = BASIC.merge({
+        'DescribeDBParametersResult' => {
+          'Marker' => Fog::Nullable::String,
+          'Parameters' => [DB_PARAMETER]
+        }
+
+      })
+
+      DB_LOG_FILE = {
+        'LastWritten' => Time,
+        'Size' => Integer,
+        'LogFileName' => String
+      }
+
+      DESCRIBE_DB_LOG_FILES = BASIC.merge({
+        'DescribeDBLogFilesResult' => {
+          'Marker' => Fog::Nullable::String,
+          'DBLogFiles' => [DB_LOG_FILE]
+        }
+      })
+
+      SNAPSHOT = {
+        'AllocatedStorage' => Integer,
+        'AvailabilityZone' => String,
+        'DBInstanceIdentifier' => String,
+        'DBSnapshotIdentifier' => String,
+        'EngineVersion' => String,
+        'Engine' => String,
+        'InstanceCreateTime' => Time,
+        'Iops' => Fog::Nullable::Integer,
+        'MasterUsername' => String,
+        'Port' => Integer,
+        'SnapshotCreateTime' => Fog::Nullable::Time,
+        'Status' => String,
+        'SnapshotType' => String
+      }
+
+      INSTANCE = {
+        'AllocatedStorage' => Integer,
+        'AutoMinorVersionUpgrade' => Fog::Boolean,
+        'AvailabilityZone' => Fog::Nullable::String,
+        'BackupRetentionPeriod' => Integer,
+        'DBInstanceClass' => String,
+        'DBInstanceIdentifier' => String,
+        'DBInstanceStatus' => String,
+        'DBName' => Fog::Nullable::String,
+        'DBParameterGroups' => [{
+            'ParameterApplyStatus' => String,
+            'DBParameterGroupName' => String
+          }],
+        'DBSecurityGroups' => [{
+            'Status' => String,
+            'DBSecurityGroupName' => String
+          }],
+        'DBSubnetGroupName' => Fog::Nullable::String,
+        'PubliclyAccessible' => Fog::Boolean,
+        'Endpoint' => {
+          'Address' => Fog::Nullable::String,
+          'Port' => Fog::Nullable::Integer
+        },
+        'Engine' => String,
+        'EngineVersion' => String,
+        'InstanceCreateTime' => Fog::Nullable::Time,
+        'Iops' => Fog::Nullable::Integer,
+        'LatestRestorableTime' => Fog::Nullable::Time,
+        'LicenseModel' => String,
+        'MasterUsername' => String,
+        'MultiAZ' => Fog::Boolean,
+        'PendingModifiedValues' => {
+          'BackupRetentionPeriod' => Fog::Nullable::Integer,
+          'DBInstanceClass'       => Fog::Nullable::String,
+          'EngineVersion'         => Fog::Nullable::String,
+          'MasterUserPassword'    => Fog::Nullable::String,
+          'MultiAZ'               => Fog::Nullable::String,
+          'AllocatedStorage'      => Fog::Nullable::Integer,
+          'Port'                  => Fog::Nullable::Integer
+        },
+        'PreferredBackupWindow' => String,
+        'PreferredMaintenanceWindow' => String,
+        'ReadReplicaDBInstanceIdentifiers' => [Fog::Nullable::String]
+      }
+
+      REPLICA_INSTANCE = INSTANCE.merge({
+        'BackupRetentionPeriod' => Fog::Nullable::String,
+        'PreferredBackupWindow' => Fog::Nullable::String,
+        'ReadReplicaSourceDBInstanceIdentifier' => String
+      })
+
+      CREATE_DB_INSTANCE = BASIC.merge({
+        'CreateDBInstanceResult' => {
+          'DBInstance' => INSTANCE
+        }
+      })
+
+      DESCRIBE_DB_INSTANCES = BASIC.merge({
+        'DescribeDBInstancesResult' =>  {
+          'Marker' => Fog::Nullable::String,
+          'DBInstances' => [INSTANCE]
+        }
+      })
+
+      MODIFY_DB_INSTANCE = BASIC.merge({
+        'ModifyDBInstanceResult' => {
+          'DBInstance' => INSTANCE
+        }
+      })
+
+      DELETE_DB_INSTANCE = BASIC.merge({
+        'DeleteDBInstanceResult' => {
+          'DBInstance' => INSTANCE
+        }
+      })
+
+      REBOOT_DB_INSTANCE = BASIC.merge({
+        'RebootDBInstanceResult' => {
+          'DBInstance' => INSTANCE
+        }
+      })
+
+      CREATE_READ_REPLICA = BASIC.merge({
+        'CreateDBInstanceReadReplicaResult' => {
+          'DBInstance' => REPLICA_INSTANCE
+        }
+      })
+
+      PROMOTE_READ_REPLICA = BASIC.merge({
+        'PromoteReadReplicaResult' => {
+            'DBInstance' => INSTANCE
+        }
+      })
+
+      CREATE_DB_SNAPSHOT = BASIC.merge({
+        'CreateDBSnapshotResult' => {
+          'DBSnapshot' => SNAPSHOT
+        }
+      })
+
+      DESCRIBE_DB_SNAPSHOTS = BASIC.merge({
+        'DescribeDBSnapshotsResult' => {
+          'Marker' => Fog::Nullable::String,
+          'DBSnapshots' => [SNAPSHOT]
+        }
+      })
+      DELETE_DB_SNAPSHOT = BASIC.merge({
+        'DeleteDBSnapshotResult' => {
+          'DBSnapshot' => SNAPSHOT
+        }
+      })
+
+      LIST_TAGS_FOR_RESOURCE = {
+        'ListTagsForResourceResult' => {
+          'TagList' => Fog::Nullable::Hash
+        }
+      }
+
+      EVENT_SUBSCRIPTION = {
+        'CustSubscriptionId' => String,
+        'EventCategories'    => Array,
+        'SourceType'         => Fog::Nullable::String,
+        'Enabled'            => String,
+        'Status'             => String,
+        'CreationTime'       => Time,
+        'SnsTopicArn'        => String
+      }
+
+      CREATE_EVENT_SUBSCRIPTION = {
+        'CreateEventSubscriptionResult' => {
+          'EventSubscription' => EVENT_SUBSCRIPTION
+        }
+      }
+
+      DESCRIBE_EVENT_SUBSCRIPTIONS = {
+        'DescribeEventSubscriptionsResult' => {
+          'EventSubscriptionsList' => [EVENT_SUBSCRIPTION]
+        }
+      }
+    end
+  end
+end