aws-sdk 2.0.1 → 2.0.5

package/features/elastictranscoder/step_definitions/elastictranscoder.js

@@ -0,0 +1,56 @@
+module.exports = function() {
+  this.Before("@elastictranscoder", function (callback) {
+    this.iam = new this.AWS.IAM();
+    this.s3 = new this.AWS.S3();
+    this.service = new this.AWS.ElasticTranscoder();
+    callback();
+  });
+
+  this.Given(/^I create an Elastic Transcoder pipeline with name prefix "([^"]*)"$/, function(prefix, callback) {
+    this.pipelineName = this.uniqueName(prefix);
+    var params = {
+      Name: this.pipelineName,
+      InputBucket: this.bucket,
+      OutputBucket: this.bucket,
+      Role: this.iamRoleArn,
+      Notifications: {"Progressing":"","Completed":"","Warning":"","Error":""}
+    };
+
+    var world = this;
+    var next = function() {
+      if (world.data) world.pipelineId = world.data.Pipeline.Id;
+      callback();
+    }
+
+    this.request(null, 'createPipeline', params, next, false);
+  });
+
+  this.Given(/^I list pipelines$/, function(callback) {
+    this.request(null, 'listPipelines', {}, callback);
+  });
+
+  this.Then(/^the list should contain the pipeline$/, function(callback) {
+    var id = this.pipelineId;
+    this.assert.contains(this.data.Pipelines, function (pipeline) {
+      return pipeline.Id === id;
+    });
+    callback();
+  });
+
+  this.Then(/^I pause the pipeline$/, function(callback) {
+    this.request(null, 'updatePipelineStatus', {Id:this.pipelineId, Status: 'Paused'}, callback);
+  });
+
+  this.Then(/^I read the pipeline$/, function(callback) {
+    this.request(null, 'readPipeline', {Id: this.pipelineId}, callback);
+  });
+
+  this.Then(/^the pipeline status should be "([^"]*)"$/, function(status, callback) {
+    this.assert.equal(this.data.Pipeline.Status, status);
+    callback();
+  });
+
+  this.Then(/^I delete the pipeline$/, function(callback) {
+    this.request(null, 'deletePipeline', {Id: this.pipelineId}, callback);
+  });
+};

package/features/elb/elb.feature

@@ -0,0 +1,19 @@
+# language: en
+@elb
+Feature: Elastic Load Balancing
+
+  I want to use Elastic Load Balancing
+
+  Scenario: Creating load balancers
+    Given I create a load balancer with name prefix "aws-sdk-js"
+    And I describe load balancers with the load balancer name
+    Then the load balancer should be in the list
+    And I delete the load balancer
+
+  Scenario: Error handling
+    Given I create a load balancer with name prefix "verylongelasticloadbalancername"
+    Then the error code should be "ValidationError"
+    Then the error message should be:
+    """
+    LoadBalancer name cannot be longer than 32 characters
+    """

package/features/elb/step_definitions/elb.js

@@ -0,0 +1,37 @@
+module.exports = function() {
+  this.Before("@elb", function (callback) {
+    this.service = new this.AWS.ELB();
+    callback();
+  });
+
+  this.Given(/^I create a load balancer with name prefix "([^"]*)"$/, function(prefix, callback) {
+    this.loadBalancerName = prefix + '-' + new Date().getTime();
+
+    var params = {
+      LoadBalancerName: this.loadBalancerName,
+      Listeners: [{Protocol: 'TCP', LoadBalancerPort: 80, InstancePort: 80}],
+      AvailabilityZones: ['us-east-1a']
+    };
+    this.request(null, 'createLoadBalancer', params, callback, false);
+  });
+
+  this.Given(/^I describe load balancers with the load balancer name$/, function(callback) {
+    var params = {LoadBalancerNames: [this.loadBalancerName]};
+    this.request(null, 'describeLoadBalancers', params, callback);
+  });
+
+  this.Then(/^the load balancer should be in the list$/, function(callback) {
+    var name = this.data.LoadBalancerDescriptions[0].LoadBalancerName;
+    this.assert.equal(name, this.loadBalancerName);
+    callback();
+  });
+
+  this.Then(/^I delete the load balancer$/, function(callback) {
+    var params = {LoadBalancerName: this.loadBalancerName};
+    this.request(null, 'deleteLoadBalancer', params, callback);
+  });
+
+  this.Given(/^I try to create a load balancer with no name$/, function(callback) {
+    this.request(null, 'createLoadBalancer', {}, callback);
+  });
+};

package/features/emr/emr.feature

@@ -0,0 +1,16 @@
+# language: en
+@emr
+Feature: Amazon Elastic MapReduce
+
+  I want to use Amazon Elastic MapReduce
+
+  Scenario: Running a job flow
+    Given I run an EMR job flow with name prefix "aws-sdk-js-integration"
+    Then I should store the job flow ID
+    And when I describe the EMR job flows
+    Then the list should contain the job flow ID
+    And I terminate the job flow
+
+  Scenario: Error handling
+    Given I run an EMR job flow with invalid parameters
+    Then the error code should be "ValidationException"

package/features/emr/step_definitions/emr.js

@@ -0,0 +1,45 @@
+module.exports = function() {
+  this.Before("@emr", function (callback) {
+    this.service = new this.AWS.EMR();
+    callback();
+  });
+
+  this.Given(/^I run an EMR job flow with name prefix "([^"]*)"$/, function(prefix, callback) {
+    var params = {
+      Name: this.uniqueName(prefix),
+      Instances: {
+        MasterInstanceType: 'm1.small',
+        SlaveInstanceType: 'm1.small',
+        InstanceCount: 1,
+        TerminationProtected: false
+      }
+    };
+    this.request(null, 'runJobFlow', params, callback);
+  });
+
+  this.Then(/^I should store the job flow ID$/, function(callback) {
+    this.jobFlowId = this.data.JobFlowId;
+    callback();
+  });
+
+  this.Then(/^when I describe the EMR job flows$/, function(callback) {
+    this.request(null, 'describeJobFlows', {}, callback);
+  });
+
+  this.Then(/^the list should contain the job flow ID$/, function(callback) {
+    var jobFlowId = this.jobFlowId;
+    this.assert.contains(this.data.JobFlows, function(job) {
+      return job.JobFlowId === jobFlowId;
+    });
+    callback();
+  });
+
+  this.Then(/^I terminate the job flow$/, function(callback) {
+    this.request(null, 'terminateJobFlows', {JobFlowIds: [this.jobFlowId]}, callback);
+  });
+
+  this.Given(/^I run an EMR job flow with invalid parameters$/, function(callback) {
+    var params = {Name: '', Instances: {MasterInstanceType: 'invalid'}};
+    this.request(null, 'runJobFlow', params, callback, false);
+  });
+};

package/features/extra/assertions.js

@@ -0,0 +1,29 @@
+var assert = require('assert');
+
+assert.match = function assertMatches(string, matcher, message) {
+  assert.ok(string.match(matcher), message ||
+    'Expected ' + string + ' to match ' + matcher);
+};
+
+assert.contains = function assertContains(list, matcher, message) {
+  var found = false;
+  for (var i in list) {
+    if (!list.hasOwnProperty(i)) continue;
+    if (typeof matcher === 'function') {
+      found = matcher(list[i]);
+    } else {
+      found = (list[i] === matcher);
+    }
+    if (found) return;
+  }
+  assert.fail(list, matcher, message, 'does not contain');
+};
+
+assert.compare = function assertComparison(actual, operator, expected, message) {
+  var compare = actual + ' ' + operator + ' ' + expected;
+  assert.ok(eval(compare), message || compare);
+}
+
+module.exports = {
+  assert: assert
+};

package/features/extra/fixtures/testfile.txt

@@ -0,0 +1 @@
+CONTENTS OF FILE

package/features/extra/helpers.js

@@ -0,0 +1,113 @@
+module.exports = {
+
+  assert: require('./assertions').assert,
+
+  uniqueName: function uniqueName(base) {
+    if (base === "") return "";
+    return base + '-' + new Date().getTime();
+  },
+
+  /**
+   * Call this function with a block that will be executed multiple times
+   * to deal with eventually consistent conditions.
+   *
+   *   this.When(/^I something is eventually consistent$/, function(callback) {
+   *     this.eventually(callback, function(next) {
+   *       doSomething(function(response) {
+   *         if (response != notWhatIExpect) {
+   *           next.fail();
+   *         } else {
+   *           next();
+   *         }
+   *       });
+   *     });
+   *   });
+   *
+   * You can pass in a few options after the function:
+   *
+   *   delay: The number of milliseconds to delay before retrying.
+   *   backoff: Add this number of milliseconds to the delay between each attempt.
+   *   maxTime: Maximum duration of milliseconds to wait for success.
+   */
+  eventually: function eventually(callback, block, options) {
+
+    if (!options) options = {};
+    if (!options.delay) options.delay = 0;
+    if (!options.backoff) options.backoff = 500;
+    if (!options.maxTime) options.maxTime = 5;
+
+    var delay = options.delay;
+    var started = this.AWS.util.date.getDate();
+
+    var self = this;
+    var retry = function() { callback(); };
+    retry.fail = function(err) {
+      var now = self.AWS.util.date.getDate();
+      if (now - started < options.maxTime * 1000) {
+        setTimeout(function () {
+          delay += options.backoff;
+          block.call(self, retry);
+        }, delay);
+      } else {
+        callback.fail(err || new Error('Eventually block timed out'));
+      }
+    };
+
+    block.call(this, retry);
+
+  },
+
+  /**
+   * A short-cut for calling a service operation and waiting for it to
+   * finish execution before moving onto the next step in the scenario.
+   */
+  request: function request(svc, operation, params, next, extra) {
+    var world = this;
+
+    if (!svc) svc = this.service;
+    if (typeof svc == 'string') svc = this[svc];
+
+    svc[operation](params, function(err, data) {
+      world.response = this;
+      world.error = err;
+      world.data = data;
+
+      try {
+        if (typeof next.condition === 'function') {
+          var condition = next.condition.call(world, world);
+          if (!condition) {
+            next.fail(new Error('Request success condition failed'));
+            return;
+          }
+        }
+
+        if (extra) {
+          extra.call(world, world.response);
+          next.call(world);
+        }
+        else if (extra !== false && err) {
+          world.unexpectedError(world.response, next);
+        } else {
+          next.call(world);
+        }
+      } catch (err) {
+        next.fail(err);
+      }
+    });
+  },
+
+  /**
+   * Given a response that contains an error, this fails the current
+   * step with a formatted error message that indicates which service and
+   * operation failed.
+   */
+  unexpectedError: function unexpectedError(resp, next) {
+    var svc = resp.request.service.api.serviceName;
+    var op = resp.request.operation;
+    var code = resp.error.code;
+    var msg = resp.error.message;
+    var err = 'Received unexpected error from ' + svc + '.' + op + ', ' + code + ': ' + msg;
+    next.fail(new Error(err));
+  }
+
+};

package/features/extra/hooks.js

@@ -0,0 +1,107 @@
+var realExit = process.exit;
+
+module.exports = function () {
+  var world = require("./world.js").WorldInstance;
+  this.World = require("./world.js").World;
+
+  world.cleanupTasks = new world.AWS.SequentialExecutor();
+
+  process.exit = function(code) {
+    var finalCallback = function() { realExit(code); };
+    world.cleanupTasks.emit('cleanup', [], finalCallback);
+  };
+
+  this.AfterAll = function(callback) {
+    world.cleanupTasks.onAsync('cleanup', callback.bind(world));
+  }
+
+  this.Before(function(callback) {
+    this.params = {};
+    callback();
+  });
+
+  /* Global error code steps */
+
+  this.Then(/^the error code should be "([^"]*)"$/, function(code, callback) {
+    this.assert.ok(this.error, 'Response does not contain an error');
+    this.assert.equal(this.error.code, code);
+    callback();
+  });
+
+  this.Then(/^the error message should (be|equal|match|contain):$/, function(matcher, message, callback) {
+    if (matcher === 'be') matcher = 'equal';
+    if (matcher === 'contain') matcher = 'match';
+    this.assert.ok(this.error, 'Response does not contain an error');
+    this.assert[matcher](this.error.message, message);
+    callback();
+  });
+
+  this.Then(/^the status code should be (\d+)$/, function(status, callback) {
+    this.assert.equal(this.response.httpResponse.statusCode, parseInt(status));
+    callback();
+  });
+
+  this.Then(/^I should get the error:$/, function(table, callback) {
+    var err = table.hashes()[0]
+    this.assert.equal(this.error.code, err.code);
+    this.assert.equal(this.error.message, err.message);
+    callback();
+  });
+
+  this.Given(/^I have a "([^"]*)" service in the "([^"]*)" region$/, function(svc, region, callback) {
+    this.service = new this.AWS[svc]({ region: region });
+    callback();
+  });
+
+  this.Given(/^I paginate the "([^"]*)" operation with limit (\d+)(?: and max pages (\d+))?$/, function(operation, limit, maxPages, callback) {
+    limit = parseInt(limit);
+    if (maxPages) maxPages = parseInt(maxPages);
+
+    var world = this;
+    this.numPages = 0;
+    this.numMarkers = 0
+    this.operation = operation;
+    this.paginationConfig = this.service.paginationConfig(operation);
+    this.params = this.params || {};
+
+    var marker = this.paginationConfig.outputToken;
+    if (this.paginationConfig.limitKey) {
+      this.params[this.paginationConfig.limitKey] = limit;
+    }
+    this.service[operation](this.params).eachPage(function (err, data) {
+      if (err) callback.fail(err);
+      else if (data === null) callback();
+      else if (maxPages && world.numPages === maxPages) {
+        callback();
+        return false;
+      }
+      else {
+        if (data[marker]) world.numMarkers++;
+        world.numPages++;
+        world.data = data;
+      }
+    });
+  });
+
+  this.Then(/^I should get more than one page$/, function(callback) {
+    this.assert.compare(this.numPages, '>', 1);
+    callback();
+  });
+
+  this.Then(/^I should get (\d+) pages$/, function(numPages, callback) {
+    this.assert.equal(this.numPages, parseInt(numPages));
+    callback();
+  });
+
+  this.Then(/^I should get numPages - 1 markers$/, function(callback) {
+    this.assert.equal(this.numMarkers, this.numPages - 1);
+    callback();
+  });
+
+  this.Then(/^the last page should not contain a marker$/, function(callback) {
+    var marker = this.paginationConfig.outputToken;
+    this.assert.equal(this.data[marker], null);
+    callback();
+  });
+
+};

package/features/extra/world.js

@@ -0,0 +1,12 @@
+var world = require('./helpers');
+world.AWS = require('../../lib/aws');
+try {
+  world.AWS.config.loadFromPath(__dirname + '/../../configuration');
+} catch (e) { }
+
+var WorldConstructor = function WorldConstructor(callback) {
+  callback(world);
+};
+
+exports.World = WorldConstructor;
+exports.WorldInstance = world;

package/features/glacier/glacier.feature

@@ -0,0 +1,47 @@
+# language: en
+@glacier
+Feature: Amazon Glacier
+
+  I want to use Amazon Glacier
+
+  @vault
+  Scenario: Creating a vault
+    Given I have a Glacier vault
+    When I describe the Glacier vault
+    Then the result should contain a property NumberOfArchives with a number
+
+  @archive
+  Scenario: Uploading an archive
+    Given I have a Glacier vault
+    When I upload a 0.25MB Glacier archive to the vault
+    Then the result should contain the Glacier archive ID
+    And the result should contain the same tree hash checksum
+    And I delete the Glacier archive
+
+  @multipart
+  Scenario: Multi-part upload
+    Given I have a Glacier vault
+    When I initiate a Glacier multi-part upload on a 2.5MB archive in 1MB chunks
+    Then the result should contain the Glacier multi-part upload ID
+    And I send the Glacier archive data in chunks
+    And I complete the Glacier multi-part upload
+    Then the result should contain the Glacier archive ID
+    And the result should contain the same tree hash checksum
+    And I delete the Glacier archive
+
+  @error
+  Scenario: Error handling
+    Given I have a Glacier vault
+    And I upload a 0.05MB Glacier archive to the vault with incorrect checksum
+    Then the error code should be "InvalidParameterValueException"
+    And the error message should match:
+    """
+    Checksum mismatch:
+    """
+
+    When I upload a 0.05MB Glacier archive to the vault with invalid checksum
+    Then the error code should be "InvalidParameterValueException"
+    And the error message should equal:
+    """
+    Invalid x-amz-sha256-tree-hash: 000
+    """

package/features/glacier/step_definitions/glacier.js

@@ -0,0 +1,112 @@
+module.exports = function() {
+  this.Before("@glacier", function (callback) {
+    this.service = new this.AWS.Glacier();
+    callback();
+  });
+
+  this.Given(/^I have a Glacier vault$/, function(callback) {
+    this.vaultName = 'aws-sdk-js-integration';
+    var params = {vaultName: this.vaultName};
+    this.request(null, 'createVault', params, callback, false);
+  });
+
+  this.Given(/^I upload a (\d+(?:\.\d+)?)MB Glacier archive to the vault( with (?:invalid|incorrect) checksum)?$/, function(size, invalid, callback) {
+    var data = new Buffer(parseFloat(size) * 1024 * 1024);
+    data.fill('0');
+    var params = {vaultName: this.vaultName, body: data};
+    if (invalid) {
+      if (invalid.match("invalid")) params.checksum = '000';
+      else params.checksum = '00000000000000000000000000000000';
+    }
+    this.request(null, 'uploadArchive', params, callback, false);
+  });
+
+  this.Then(/^the result should contain the Glacier archive ID$/, function(callback) {
+    this.archiveId = this.data.archiveId;
+    callback();
+  });
+
+  this.Then(/^the result should contain the same tree hash checksum$/, function(callback) {
+    var hash = this.response.request.httpRequest.headers['x-amz-sha256-tree-hash'];
+    this.assert.equal(this.data.checksum, hash);
+    callback();
+  });
+
+  this.When(/^I describe the Glacier vault$/, function(callback) {
+    var params = {vaultName: this.vaultName};
+    this.request(null, 'describeVault', params, callback);
+  });
+
+  this.Then(/^I delete the Glacier archive$/, function(callback) {
+    var params = {vaultName: this.vaultName, archiveId: this.archiveId};
+    this.request(null, 'deleteArchive', params, callback);
+  });
+
+  this.Then(/^I delete the Glacier vault$/, function(callback) {
+    var params = {vaultName: this.vaultName};
+    this.eventually(callback, function(next) {
+      this.request(null, 'deleteVault', params, next);
+    });
+  });
+
+  this.When(/^I initiate a Glacier multi-part upload on a (\d+(?:\.\d+)?)MB archive in (\d+)MB chunks$/, function(totalSize, partSize, callback) {
+    // setup multi-part upload
+    this.uploadData = new Buffer(totalSize * 1024 * 1024);
+    this.uploadData.fill('0');
+    this.checksums = this.service.computeChecksums(this.uploadData);
+    this.partCounter = 0;
+    this.partSize = partSize * 1024 * 1024;
+
+    var params = {vaultName: this.vaultName, partSize: this.partSize.toString()};
+    this.request(null, 'initiateMultipartUpload', params, callback);
+  });
+
+  this.Then(/^the result should contain the Glacier multi-part upload ID$/, function(callback) {
+    this.uploadId = this.data.uploadId;
+    callback();
+  });
+
+  this.Then(/^I send the next part$/, function(callback) {
+    var start = this.partCounter;
+    var end = Math.min(start + this.partSize, this.uploadData.length);
+    var buf = this.uploadData.slice(start, end);
+    var range = 'bytes ' + start + '-' + (end-1) + '/*';
+    var params = {
+      vaultName: this.vaultName,
+      uploadId: this.uploadId,
+      range: range,
+      body: buf
+    };
+    this.request(null, 'uploadMultipartPart', params, callback);
+    this.partCounter += this.partSize;
+  });
+
+  this.Then(/^I send the Glacier archive data in chunks$/, function(callback) {
+    var numPartsLeft = Math.ceil(this.uploadData.length / this.partSize);
+    for (var i = 0; i < this.uploadData.length; i += this.partSize) {
+      var end = Math.min(i + this.partSize, this.uploadData.length);
+      var buf = this.uploadData.slice(i, end);
+      var range = 'bytes ' + i + '-' + (end-1) + '/*';
+      var params = {
+        vaultName: this.vaultName,
+        uploadId: this.uploadId,
+        range: range,
+        body: buf
+      };
+      this.service.uploadMultipartPart(params, function() {
+        if (--numPartsLeft == 0) callback();
+      });
+    }
+  });
+
+  this.Then(/^I complete the Glacier multi-part upload$/, function(callback) {
+    var params = {
+      vaultName: this.vaultName,
+      uploadId: this.uploadId,
+      archiveSize: this.uploadData.length.toString(),
+      checksum: this.checksums.treeHash
+    }
+    this.request(null, 'completeMultipartUpload', params, callback);
+  });
+
+};

package/features/iam/iam.feature

@@ -0,0 +1,24 @@
+# language: en
+@iam
+Feature: IAM
+
+  I want to use IAM
+
+  Scenario: Users
+    Given I have an IAM username "js-test"
+    And I create an IAM user with the username
+    And I list the IAM users
+    Then the list should contain the user
+    And I delete the IAM user
+
+  Scenario: Roles
+    Given I create an IAM role with name prefix "aws-sdk-js"
+    Then the IAM role should exist
+    And I delete the IAM role
+
+  Scenario: Error handling
+    Given I have an IAM username "js-test-dupe"
+    And I create an IAM user with the username
+    And I create an IAM user with the username
+    Then the error code should be "EntityAlreadyExists"
+    And I delete the IAM user