aws-sdk 2.0.1 → 2.0.5

package/features/iam/step_definitions/iam.js

@@ -0,0 +1,66 @@
+module.exports = function() {
+  this.Before("@iam", function (callback) {
+    this.iam = new this.AWS.IAM();
+    callback();
+  });
+
+  this.Given(/^I have an IAM username "([^"]*)"$/, function(name, callback) {
+    this.iamUserArn = '';
+    this.iamUser = this.uniqueName(name);
+    callback();
+  });
+
+  this.Given(/^I create an IAM user with the username$/, function(callback) {
+    var world = this;
+    var next = function() {
+      if (world.data) this.iamUserArn = world.data.User.Arn;
+      else this.iamUserArn = null;
+      callback();
+    };
+    next.fail = callback.fail;
+    this.request('iam', 'createUser', {UserName: this.iamUser}, next, false);
+  });
+
+  this.Given(/^I list the IAM users$/, function(callback) {
+    this.request('iam', 'listUsers', {}, callback);
+  });
+
+  this.Then(/^the list should contain the user$/, function(callback) {
+    var name = this.iamUser;
+    this.assert.contains(this.data.Users, function(user) {
+      return user.UserName === name;
+    });
+    callback();
+  });
+
+  this.Then(/^I delete the IAM user$/, function(callback) {
+    this.request('iam', 'deleteUser', {UserName: this.iamUser}, callback);
+  });
+
+  this.Given(/^I create an IAM role with name prefix "([^"]*)"$/, function(name, callback) {
+    this.iamRoleName = this.uniqueName(name);
+
+    var world = this;
+    var assumeRolePolicyDocument = '{"Version":"2008-10-17","Statement":[' +
+      '{"Effect":"Allow","Principal":{"Service":["ec2.amazonaws.com"]},' +
+      '"Action":["sts:AssumeRole"]}]}';
+    var params = {RoleName: this.iamRoleName,
+      AssumeRolePolicyDocument: assumeRolePolicyDocument};
+    var next = function() {
+      world.iamRoleArn = world.data.Role.Arn;
+      callback();
+    }
+    next.fail = callback.fail;
+
+    this.request('iam', 'createRole', params, next);
+  });
+
+  this.Then(/^the IAM role should exist$/, function(callback) {
+    this.assert.compare(this.iamRoleArn.length, '>', 0);
+    callback();
+  });
+
+  this.Then(/^I delete the IAM role$/, function(callback) {
+    this.request('iam', 'deleteRole', {RoleName: this.iamRoleName}, callback);
+  });
+};

package/features/importexport/importexport.feature

@@ -0,0 +1,53 @@
+# language: en
+@importexport @requiresakid
+Feature: AWS Import/Export
+
+  I want to use AWS Import/Export
+
+  Scenario: Creating a job
+    Given I create a bucket
+    When I create an Import job with manifest:
+    """
+    manifestVersion: 2.0
+    accessKeyId: {ACCESS_KEY_ID}
+    bucket: {BUCKET}
+    deviceId: ABCDE
+    generator: AWS ImportExport Web Service Tool 1.0
+    prefix: imported/
+    eraseDevice: yes
+    notificationEmail: invalid.address@example.com
+    returnAddress:
+        name: Joe Random
+        company: Amazon Web Services
+        street1: 123 Any Street
+        city: Seattle
+        stateOrProvince: WA
+        postalCode: 91111
+        phoneNumber: 555-555-0100
+        country: USA
+    serviceLevel: expeditedShipping
+    """
+    And I store the Import job ID
+    And I get the Import job status
+    Then the result should contain a property CreationDate with a Date
+    And I cancel the Import job
+    And the result should contain Success with expression true
+    And I get the Import job status
+    Then the result should contain ProgressCode with string value "Canceled"
+    And I delete the bucket
+
+  Scenario: Listing jobs
+    When I list Import/Export jobs
+    Then the result should contain a property IsTruncated with a boolean
+    And the result should contain a property Jobs with an Array
+
+  Scenario: Error handling
+    When I create an Import job with manifest:
+    """
+    INVALID MANIFEST
+    """
+    Then the error code should be "MalformedManifestException"
+    And the error message should be:
+    """
+    Your manifest is not well-formed
+    """

package/features/importexport/step_definitions/importexport.js

@@ -0,0 +1,42 @@
+module.exports = function() {
+  this.Before("@importexport", function (callback) {
+    this.s3 = new this.AWS.S3();
+    this.service = new this.AWS.ImportExport();
+    callback();
+  });
+
+  this.When(/^I create an (Import|Export) job with manifest:$/, function(type, manifest, callback) {
+    manifest = manifest.replace('{ACCESS_KEY_ID}', this.service.config.credentials.accessKeyId);
+    manifest = manifest.replace('{BUCKET}', this.bucket);
+    var params = {JobType: type, Manifest: manifest, ValidateOnly: false};
+    this.request(null, 'createJob', params, callback, false);
+  });
+
+  this.When(/^I store the Import job ID$/, function(callback) {
+    this.jobId = this.data.JobId;
+    callback();
+  });
+
+  this.Then(/^the result should contain (\S+) with expression (.+)$/, function(property, expr, callback) {
+    this.assert.equal(this.data[property], eval(expr));
+    callback();
+  });
+
+  this.Then(/^the result should contain (\S+) with string value "([^"]*)"$/, function(property, value, callback) {
+    this.assert.equal(this.data[property], value);
+    callback();
+  });
+
+  this.When(/^I get the Import job status$/, function(callback) {
+    this.request(null, 'getStatus', {JobId: this.jobId}, callback);
+  });
+
+  this.When(/^I cancel the Import job$/, function(callback) {
+    var params = {JobId: this.jobId};
+    this.request(null, 'cancelJob', params, callback);
+  });
+
+  this.When(/^I list Import\/Export jobs$/, function(callback) {
+    this.request(null, 'listJobs', {}, callback);
+  });
+};

package/features/kinesis/kinesis.feature

@@ -0,0 +1,9 @@
+# language: en
+@kinesis
+Feature: Amazon Kinesis
+
+  I want to use Amazon Kinesis
+
+  Scenario: Error handling
+    Given I try to describe a stream in Kinesis
+    Then the error code should be "ResourceNotFoundException"

package/features/kinesis/step_definitions/kinesis.js

@@ -0,0 +1,10 @@
+module.exports = function() {
+  this.Before("@kinesis", function (callback) {
+    this.service = new this.AWS.Kinesis();
+    callback();
+  });
+
+  this.Given(/^I try to describe a stream in Kinesis$/, function(callback) {
+    this.request(null, 'describeStream', {StreamName: 'XXINVALIDXX'}, callback, false);
+  });
+};

package/features/opsworks/opsworks.feature

@@ -0,0 +1,26 @@
+# language: en
+@opsworks
+Feature: AWS OpsWorks
+
+  I want to use AWS OpsWorks
+
+  Scenario: Creating and deleting user profiles
+    Given I have an IAM username "aws-js-sdk"
+    And I create an IAM user with the username
+    And I create an OpsWorks user profile with the IAM user ARN
+    And the IAM user ARN is in the result
+    And I describe the OpsWorks user profiles
+    Then the IAM user ARN should be in the result
+    And the name should be equal to the IAM username
+    And the SSH username should be equal to the IAM username
+    And I delete the OpsWorks user profile
+    And I delete the IAM user
+
+  Scenario: Error handling
+    Given I have an IAM username ""
+    And I create an OpsWorks user profile with the IAM user ARN
+    Then the error code should be "ValidationException"
+    Then the error message should be:
+    """
+    Please provide user ARN
+    """

package/features/opsworks/step_definitions/opsworks.js

@@ -0,0 +1,42 @@
+module.exports = function() {
+  this.Before("@opsworks", function (callback) {
+    this.iam = new this.AWS.IAM();
+    this.service = new this.AWS.OpsWorks();
+    callback();
+  });
+
+  this.Given(/^I create an OpsWorks user profile with the IAM user ARN$/, function(callback) {
+    var params = {IamUserArn: this.iamUserArn};
+    this.request(null, 'createUserProfile', params, callback, false);
+  });
+
+  this.Given(/^the IAM user ARN is in the result$/, function(callback) {
+    this.assert.equal(this.data.IamUserArn, this.iamUserArn);
+    callback();
+  });
+
+  this.Given(/^I describe the OpsWorks user profiles$/, function(callback) {
+    var params = {IamUserArns: [this.iamUserArn]};
+    this.request(null, 'describeUserProfiles', params, callback);
+  });
+
+  this.Then(/^the IAM user ARN should be in the result$/, function(callback) {
+    this.assert.equal(this.data.UserProfiles[0].IamUserArn, this.iamUserArn);
+    callback();
+  });
+
+  this.Then(/^the name should be equal to the IAM username$/, function(callback) {
+    this.assert.equal(this.data.UserProfiles[0].Name, this.iamUser);
+    callback();
+  });
+
+  this.Then(/^the SSH username should be equal to the IAM username$/, function(callback) {
+    this.assert.equal(this.data.UserProfiles[0].SshUsername, this.iamUser);
+    callback();
+  });
+
+  this.Then(/^I delete the OpsWorks user profile$/, function(callback) {
+    var params = {IamUserArn: this.iamUserArn};
+    this.request(null, 'deleteUserProfile', params, callback, false);
+  });
+};

package/features/rds/rds.feature

@@ -0,0 +1,32 @@
+# language: en
+@rds
+Feature: Amazon Relational Database Service
+
+  I want to use Amazon Relational Database Service
+
+  Scenario: Creating and deleting security groups
+    Given I create a RDS security group with prefix name "aws-js-sdk"
+    And the RDS security group name is in the result
+    And I describe the RDS security group
+    Then the RDS security group should be described
+    And I delete the RDS security group
+
+  Scenario: Error handling
+    Given I create a RDS security group with prefix name ""
+    Then the error code should be "InvalidParameterValue"
+    Then the error message should be:
+    """
+    DBSecurityGroupName is required
+    """
+
+  @pagination
+  Scenario: Paginating responses
+    Given I paginate the "describeReservedDBInstancesOfferings" operation with limit 100
+    Then I should get more than one page
+    And I should get numPages - 1 markers
+    And the last page should not contain a marker
+
+  @pagination
+  Scenario: Paginating responses (with callback)
+    Given I paginate the "describeReservedDBInstancesOfferings" operation asynchronously with limit 100
+    Then I should be able to asynchronously paginate all pages

package/features/rds/step_definitions/rds.js

@@ -0,0 +1,72 @@
+module.exports = function() {
+  this.Before("@rds", function (callback) {
+    this.service = new this.AWS.RDS();
+    callback();
+  });
+
+  this.Given(/^I create a RDS security group with prefix name "([^"]*)"$/, function(prefix, callback) {
+    this.dbGroupName = this.uniqueName(prefix);
+    var params = { DBSecurityGroupDescription: 'Description', DBSecurityGroupName: this.dbGroupName };
+    this.request(null, 'createDBSecurityGroup', params, callback, false);
+  });
+
+  this.Given(/^the RDS security group name is in the result$/, function(callback) {
+    var name = this.data.DBSecurityGroup.DBSecurityGroupName;
+    this.assert.equal(name, this.dbGroupName);
+    callback();
+  });
+
+  this.Given(/^I describe the RDS security group$/, function(callback) {
+    var params = {DBSecurityGroupName: this.dbGroupName};
+    this.request(null, 'describeDBSecurityGroups', params, callback);
+  });
+
+  this.Then(/^the RDS security group should be described$/, function(callback) {
+    var item = this.data.DBSecurityGroups[0];
+    this.assert.equal(item.DBSecurityGroupName, this.dbGroupName);
+    callback();
+  });
+
+  this.Then(/^I delete the RDS security group$/, function(callback) {
+    var params = {DBSecurityGroupName: this.dbGroupName};
+    this.request(null, 'deleteDBSecurityGroup', params, callback);
+  });
+
+  this.Given(/^I paginate the "([^"]*)" operation asynchronously with limit (\d+)$/, function (operation, limit, callback) {
+    var maxPages = 3;
+    limit = parseInt(limit);
+
+    var world = this;
+    this.numPages = 0;
+    this.numMarkers = 0
+    this.operation = operation;
+    this.paginationConfig = this.service.paginationConfig(operation);
+    this.params = this.params || {};
+    this.finishedPagination = false;
+
+    var marker = this.paginationConfig.outputToken;
+    if (this.paginationConfig.limitKey) {
+      this.params[this.paginationConfig.limitKey] = limit;
+    }
+    this.service[operation](this.params).eachPage(function (err, data, done) {
+      process.nextTick(function() {
+        if (err) callback.fail(err);
+        else if (data === null || world.numPages === maxPages) {
+          world.finishedPagination = true;
+          callback();
+        } else {
+          if (data[marker]) world.numMarkers++;
+          world.numPages++;
+          world.data = data;
+        }
+
+        done(); // start getting next page
+      });
+    });
+  });
+
+  this.Then(/^I should be able to asynchronously paginate all pages$/, function (callback) {
+    this.assert.equal(this.finishedPagination, true);
+    callback();
+  });
+};

package/features/redshift/redshift.feature

@@ -0,0 +1,20 @@
+# language: en
+@redshift
+Feature: Amazon Redshift
+
+  I want to use Amazon Redshift
+
+  Scenario: Creating and deleting cluster security groups
+    Given I create a Redshift cluster security group with prefix name "aws-js-sdk"
+    And the Redshift cluster security group name is in the result
+    And I describe Redshift cluster security groups
+    Then the Redshift cluster security group should be in the list
+    And I delete the Redshift cluster security group
+
+  Scenario: Error handling
+    Given I create a Redshift cluster security group with prefix name ""
+    Then the error code should be "InvalidParameterValue"
+    Then the error message should be:
+    """
+    ClusterSecurityGroupName is required
+    """

package/features/redshift/step_definitions/redshift.js

@@ -0,0 +1,33 @@
+module.exports = function() {
+  this.Before("@redshift", function (callback) {
+    this.service = new this.AWS.Redshift();
+    callback();
+  });
+
+  this.Given(/^I create a Redshift cluster security group with prefix name "([^"]*)"$/, function(prefix, callback) {
+    this.clusterGroupName = this.uniqueName(prefix);
+    var params = { Description: 'Description', ClusterSecurityGroupName: this.clusterGroupName };
+    this.request(null, 'createClusterSecurityGroup', params, callback, false);
+  });
+
+  this.Given(/^the Redshift cluster security group name is in the result$/, function(callback) {
+    var name = this.data.ClusterSecurityGroup.ClusterSecurityGroupName;
+    this.assert.equal(name, this.clusterGroupName);
+    callback();
+  });
+  this.Given(/^I describe Redshift cluster security groups$/, function(callback) {
+    var params = {ClusterSecurityGroupName: this.clusterGroupName};
+    this.request(null, 'describeClusterSecurityGroups', params, callback);
+  });
+
+  this.Then(/^the Redshift cluster security group should be in the list$/, function(callback) {
+    var item = this.data.ClusterSecurityGroups[0];
+    this.assert.equal(item.ClusterSecurityGroupName, this.clusterGroupName);
+    callback();
+  });
+
+  this.Then(/^I delete the Redshift cluster security group$/, function(callback) {
+    var params = {ClusterSecurityGroupName: this.clusterGroupName};
+    this.request(null, 'deleteClusterSecurityGroup', params, callback);
+  });
+};

package/features/route53/route53.feature

@@ -0,0 +1,41 @@
+# language: en
+@route53
+Feature: Amazon Route 53
+
+  I want to use Amazon Route 53
+
+  Scenario: Managing hosted zones
+    When I create a Route53 hosted zone with name prefix "aws-sdk-js"
+    Then the result should contain the hosted zone ID
+    And the result should contain the change ID
+    And the result should contain the hosted zone name
+
+    When I get information about the Route53 change ID
+    Then the change status should be PENDING or INSYNC
+
+    When I get information about the Route53 hosted zone ID
+    Then the result should contain multiple nameservers
+
+    And I delete the Route53 hosted zone
+
+  Scenario: Managing health checks
+    When I create a Route53 TCP health check with name prefix "aws-sdk-js"
+    Then the result should contain health check information
+    And the result should contain the health check ID
+
+    When I get information about the health check ID
+    Then the result should contain the previous health check information
+
+    And I delete the Route53 TCP health check
+
+  Scenario: Type checking
+    When I list Route53 hosted zones
+    And the result should contain a property HostedZones with an Array
+
+  Scenario: Error handling
+    When I create a Route53 hosted zone with name prefix ""
+    Then the error code should be "InvalidInput"
+    And the error message should match:
+    """
+    Member must have length greater than or equal to 1
+    """

package/features/route53/step_definitions/route53.js

@@ -0,0 +1,97 @@
+module.exports = function() {
+  this.Before("@route53", function (callback) {
+    this.service = new this.AWS.Route53();
+    callback();
+  });
+
+  this.When(/^I create a Route53 hosted zone with name prefix "([^"]*)"$/, function(prefix, callback) {
+    this.zoneName = 'zone1.example.com';
+    var params = {
+      Name: this.zoneName,
+      CallerReference: this.uniqueName(prefix),
+      HostedZoneConfig: {
+        Comment: 'A comment about the zone'
+      }
+    };
+    this.request(null, 'createHostedZone', params, callback, false);
+  });
+
+  this.Then(/^the result should contain the hosted zone ID$/, function(callback) {
+    this.hostedZoneId = this.data.HostedZone.Id;
+    callback();
+  });
+
+  this.Then(/^the result should contain the change ID$/, function(callback) {
+    this.changeInfoId = this.data.ChangeInfo.Id;
+    callback();
+  });
+
+  this.Then(/^the result should contain the hosted zone name$/, function(callback) {
+    this.assert.equal(this.data.HostedZone.Name, this.zoneName + '.');
+    callback();
+  });
+
+  this.When(/^I get information about the Route53 change ID$/, function(callback) {
+    this.request(null, 'getChange', {Id: this.changeInfoId}, callback);
+  });
+
+  this.Then(/^the change status should be PENDING or INSYNC$/, function(callback) {
+    this.assert.match(this.data.ChangeInfo.Status, /^(PENDING|INSYNC)$/);
+    callback();
+  });
+
+  this.When(/^I get information about the Route53 hosted zone ID$/, function(callback) {
+    this.request(null, 'getHostedZone', {Id: this.hostedZoneId}, callback);
+  });
+
+  this.Then(/^the result should contain multiple nameservers$/, function(callback) {
+    this.assert.compare(this.data.DelegationSet.NameServers.length, '>=', 0);
+    this.assert.equal(typeof this.data.DelegationSet.NameServers[0], 'string');
+    callback();
+  });
+
+  this.Then(/^I delete the Route53 hosted zone$/, function(callback) {
+    this.request(null, 'deleteHostedZone', {Id: this.hostedZoneId}, callback);
+  });
+
+  this.When(/^I create a Route53 TCP health check with name prefix "([^"]*)"$/, function(prefix, callback) {
+    var params = {
+      CallerReference: this.uniqueName(prefix),
+      HealthCheckConfig: {
+        IPAddress: '192.0.43.10', // example.com
+        Port: 80,
+        Type: 'TCP'
+      }
+    }
+    this.request(null, 'createHealthCheck', params, callback);
+  });
+
+  this.Then(/^the result should contain health check information$/, function(callback) {
+    this.healthCheckInfo = this.data.HealthCheck;
+    callback();
+  });
+
+  this.Then(/^the result should contain the health check ID$/, function(callback) {
+    this.healthCheckId = this.data.HealthCheck.Id;
+    callback();
+  });
+
+  this.When(/^I get information about the health check ID$/, function(callback) {
+    var params = {HealthCheckId: this.healthCheckId};
+    this.request(null, 'getHealthCheck', params, callback);
+  });
+
+  this.Then(/^the result should contain the previous health check information$/, function(callback) {
+    this.assert.deepEqual(this.data.HealthCheck, this.healthCheckInfo);
+    callback();
+  });
+
+  this.Then(/^I delete the Route53 TCP health check$/, function(callback) {
+    var params = {HealthCheckId: this.healthCheckId};
+    this.request(null, 'deleteHealthCheck', params, callback);
+  });
+
+  this.When(/^I list Route53 hosted zones$/, function(callback) {
+    this.request(null, 'listHostedZones', {}, callback);
+  });
+};

package/features/s3/buckets.feature

@@ -0,0 +1,40 @@
+# language: en
+@s3 @buckets
+Feature: Working with Buckets
+
+  Scenario: CRUD buckets
+    When I create a bucket
+    Then the bucket should exist
+    When I delete the bucket
+    Then the bucket should not exist
+
+  @cors
+  Scenario: Bucket CORS
+    When I create a bucket
+    And I put a bucket CORS configuration
+    And I get the bucket CORS configuration
+    Then the AllowedMethods list should inclue "DELETE POST PUT"
+    Then the AllowedOrigin value should equal "http://example.com"
+    Then the AllowedHeader value should equal "*"
+    Then the ExposeHeader value should equal "x-amz-server-side-encryption"
+    Then the MaxAgeSeconds value should equal 5000
+
+  @lifecycle
+  Scenario: Bucket lifecycles
+    When I create a bucket
+    And I put a transition lifecycle configuration on the bucket with prefix "/"
+    And I get the transition lifecycle configuration on the bucket
+    Then the lifecycle configuration should have transition days of 0
+    And the lifecycle configuration should have transition storage class of "GLACIER"
+
+  @tagging
+  Scenario: Bucket Tagging
+    When I create a bucket
+    And I put a bucket tag with key "KEY" and value "VALUE"
+    And I get the bucket tagging
+    Then the first tag in the tag set should have key and value "KEY", "VALUE"
+
+  # this test will exercise following 307 redirects
+#  Scenario: Creating a bucket with a location constraint
+#    When I create a bucket with the location constraint "EU"
+#    Then the bucket should have a location constraint of "EU"