aws-sdk 2.0.1 → 2.0.5

package/features/cloudwatch/step_definitions/cloudwatch.js

@@ -0,0 +1,48 @@
+module.exports = function() {
+  this.Before("@cloudwatch", function (callback) {
+    this.service = new this.AWS.CloudWatch();
+    callback();
+  });
+
+  this.Given(/^I create a CloudWatch alarm with (prefix|name) "([^"]*)"$/, function(prefix, name, callback) {
+    var timestamp = new Date().getTime();
+    this.cloudWatchAlarm = {
+      AlarmName: name,
+      MetricName: 'aws-sdk-js-metric-' + timestamp,
+      Namespace: 'aws-sdk-js-namespace' + timestamp,
+      ComparisonOperator: 'GreaterThanThreshold',
+      EvaluationPeriods: 5,
+      Period: 60,
+      Statistic: 'Average',
+      Threshold: 50.0
+    };
+
+    if (prefix === 'prefix') {
+      this.cloudWatchAlarm.AlarmName += '-' + timestamp;
+    }
+
+    this.request(null, 'putMetricAlarm', this.cloudWatchAlarm,
+      callback, prefix === 'name' ? false : undefined);
+  });
+
+  this.Given(/^I list the CloudWatch alarms$/, function(callback) {
+    var params = {
+      MetricName: this.cloudWatchAlarm.MetricName,
+      Namespace: this.cloudWatchAlarm.Namespace
+    };
+    this.request(null, 'describeAlarmsForMetric', params, callback);
+  });
+
+  this.Then(/^the list should contain the CloudWatch alarm$/, function(callback) {
+    var name = this.cloudWatchAlarm.AlarmName;
+    this.assert.contains(this.data.MetricAlarms, function(alarm) {
+      return alarm.AlarmName === name;
+    });
+    callback();
+  });
+
+  this.Then(/^I delete the CloudWatch alarm$/, function(callback) {
+    this.request(null, 'deleteAlarms',
+      {AlarmNames: [this.cloudWatchAlarm.AlarmName]}, callback);
+  });
+};

package/features/datapipeline/datapipeline.feature

@@ -0,0 +1,23 @@
+# language: en
+@datapipeline
+Feature: AWS Data Pipeline
+
+  I want to use AWS Data Pipeline
+
+  Scenario: Managing pipelines
+    Given I create a Data Pipeline with name prefix "aws-sdk-js"
+    Then the response should contain the pipeline ID
+    When I describe the Data Pipelines
+    Then the pipeline should be in the list
+    And I put a Data Pipeline definition
+    And I get the Data Pipeline definition
+    And the the objects should be in the Data Pipeline definition
+    And I delete the Data Pipeline
+
+  Scenario: Error handling
+    Given I create a Data Pipeline with name prefix ""
+    Then the error code should be "ValidationException"
+    And the error message should match:
+    """
+    Member must have length greater than or equal to 1
+    """

package/features/datapipeline/step_definitions/datapipeline.js

@@ -0,0 +1,79 @@
+module.exports = function() {
+  this.Before("@datapipeline", function (callback) {
+    this.service = new this.AWS.DataPipeline();
+    callback();
+  });
+
+  var sortObjects = function sortObjects(objects) {
+    this.AWS.util.arrayEach(objects, function(item) {
+      item.fields.sort(function (field1, field2) {
+        return field1.key < field2.key ? -1 : 1;
+      });
+    });
+  };
+
+  this.Given(/^I create a Data Pipeline with name prefix "([^"]*)"$/, function(prefix, callback) {
+    var params = {
+      name: this.uniqueName(prefix), uniqueId: this.uniqueName('aws-js-sdk')
+    };
+    this.request(null, 'createPipeline', params, callback, false);
+  });
+
+  this.Then(/^the response should contain the pipeline ID$/, function(callback) {
+    this.pipelineId = this.data.pipelineId;
+    callback();
+  });
+
+  this.When(/^I describe the Data Pipelines$/, function(callback) {
+    var params = {pipelineIds: [this.pipelineId]};
+    this.request(null, 'describePipelines', params, callback);
+  });
+
+  this.Then(/^the pipeline should be in the list$/, function(callback) {
+    var id = this.data.pipelineDescriptionList[0].pipelineId;
+    this.assert.equal(id, this.pipelineId);
+    callback();
+  });
+
+  this.Then(/^I put a Data Pipeline definition$/, function(callback) {
+    this.pipelineDefinition = {
+      pipelineId: this.pipelineId,
+      pipelineObjects: [
+        {id: 'Schedule', name: 'Schedule', fields: [
+          {key: 'type', stringValue: 'Schedule'},
+          {key: 'period', stringValue: '1 hour'},
+          {key: 'startDateTime', stringValue: '2012-12-12T00:00:00'},
+          {key: 'endDateTime', stringValue: '2012-12-21T18:00:00'}
+        ]},
+        {id: 'Default', name: 'Default', fields: [
+          {key: 'workerGroup', stringValue: 'workerGroup'}
+        ]},
+        {id: 'SayHello', name: 'SayHello', fields: [
+          {key: 'type', stringValue: 'ShellCommandActivity'},
+          {key: 'command', stringValue: 'echo hello'},
+          {key: 'parent', refValue: 'Default'},
+          {key: 'schedule', refValue: 'Schedule'}
+        ]}
+      ]
+    };
+    sortObjects.call(this, this.pipelineDefinition.pipelineObjects);
+    this.request(null, 'putPipelineDefinition', this.pipelineDefinition, callback);
+  });
+
+  this.Then(/^I get the Data Pipeline definition$/, function(callback) {
+    var params = {pipelineId:this.pipelineId};
+    this.request(null, 'getPipelineDefinition', params, callback);
+  });
+
+  this.Then(/^the the objects should be in the Data Pipeline definition$/, function(callback) {
+    var objects = this.pipelineDefinition.pipelineObjects;
+    sortObjects.call(this, this.data.pipelineObjects);
+    this.assert.deepEqual(this.data.pipelineObjects, objects);
+    callback();
+  });
+
+  this.Then(/^I delete the Data Pipeline$/, function(callback) {
+    var params = {pipelineId: this.pipelineId};
+    this.request(null, 'deletePipeline', params, callback);
+  });
+};

package/features/directconnect/directconnect.feature

@@ -0,0 +1,20 @@
+# language: en
+@directconnect
+Feature: AWS Direct Connect
+
+  I want to use AWS Direct Connect
+
+  Scenario: Managing connections
+    Given I create a Direct Connect connection with name prefix "aws-sdk-js"
+    Then I should get a Direct Connect connection ID
+    And I describe the connection
+    Then the bandwidth should match the connection bandwidth
+    And I delete the Direct Connect connection
+
+  Scenario: Error handling
+    Given I create a Direct Connect connection with an invalid location
+    Then the error code should be "DirectConnectServerException"
+    And the error message should be:
+    """
+    Unable to process request
+    """

package/features/directconnect/step_definitions/directconnect.js

@@ -0,0 +1,44 @@
+module.exports = function() {
+  this.Before("@directconnect", function (callback) {
+    this.service = new this.AWS.DirectConnect();
+    callback();
+  });
+
+  this.When(/^I create a Direct Connect connection with name prefix "([^"]*)"$/, function(prefix, callback) {
+    var params = {
+      bandwidth: '1Gbps', location: 'EqDC2',
+      connectionName: this.uniqueName(prefix)
+    };
+    this.request(null, 'createConnection', params, callback);
+  });
+
+  this.Then(/^I should get a Direct Connect connection ID$/, function(callback) {
+    this.connectionId = this.data.connectionId;
+    this.connectionData = this.data;
+    callback();
+  });
+
+  this.Then(/^I describe the connection$/, function(callback) {
+    var params = {connectionId: this.connectionId};
+    this.request(null, 'describeConnections', params, callback);
+  });
+
+  this.Then(/^the bandwidth should match the connection bandwidth$/, function(callback) {
+    this.assert.equal(this.connectionData.bandwidth, this.data.connections[0].bandwidth);
+    callback();
+  });
+
+  this.Then(/^I delete the Direct Connect connection$/, function(callback) {
+    var params = {connectionId: this.connectionId};
+    this.request(null, 'deleteConnection', params, callback);
+  });
+
+  this.Given(/^I create a Direct Connect connection with an invalid location$/, function(callback) {
+    var params = {
+      bandwidth: '1Gbps',
+      location: 'INVALID_LOCATION',
+      connectionName: this.uniqueName('aws-sdk-js')
+    };
+    this.request(null, 'createConnection', params, callback, false);
+  });
+};

package/features/dynamodb/crc32.feature

@@ -0,0 +1,18 @@
+# language: en
+@dynamodb @dynamodb-2011-12-05 @crc32
+Feature: CRC32 response validation
+
+  Scenario: Retry on corrupted request
+    Given my first request is corrupted with CRC checking ON
+    Then the request should be retried
+    And the request should not fail with a CRC checking error
+
+  Scenario: Failed retries on corrupted request
+    Given all of my requests are corrupted with CRC checking ON
+    Then the request is retried the maximum number of times
+    And the request should fail with a CRC checking error
+
+  Scenario: Ignore corrupted request with CRC checking OFF
+    Given my first request is corrupted with CRC checking OFF
+    Then the request should not be retried
+    And the request should not fail with a CRC checking error

package/features/dynamodb/step_definitions/dynamodb.js

@@ -0,0 +1,154 @@
+module.exports = function() {
+  this.Before("@dynamodb-2011-12-05", function (next) {
+    this.service = new this.AWS.DynamoDB({
+      apiVersion: '2011-12-05',
+      region: 'us-west-2',
+      maxRetries: 2
+    });
+    next();
+  });
+
+  this.Before("@dynamodb-2012-08-10", function (next) {
+    this.service = new this.AWS.DynamoDB({
+      apiVersion: '2012-08-10',
+      region: 'us-west-2',
+      maxRetries: 2
+    });
+    next();
+  });
+
+  function createTable(world, callback) {
+    var db = new world.AWS.DynamoDB({
+      apiVersion: '2011-12-05',
+      region: 'us-west-2'
+    });
+
+    var params = {
+      TableName: world.tableName,
+      KeySchema: {
+        HashKeyElement: { AttributeName: 'id', AttributeType: 'S' }
+      },
+      ProvisionedThroughput: {
+        ReadCapacityUnits: 10,
+        WriteCapacityUnits: 5,
+      }
+    };
+
+    db.createTable(params, function(err, data) {
+      if (err) {
+        callback.fail(err);
+        return;
+      }
+      params = { TableName: world.tableName };
+      db.waitFor('tableExists', params, callback);
+    });
+  }
+
+  this.Given(/^I have a table$/, function(callback) {
+    var world = this;
+    this.tableName = 'aws-sdk-js-integration-test';
+    this.service.listTables(function(err, data) {
+      for (var i = 0; i < data.TableNames.length; i++) {
+        if (data.TableNames[i] == world.tableName) {
+          callback();
+          return;
+        }
+      }
+      createTable(world, callback);
+    });
+  });
+
+  this.When(/^I put the item:$/, function(string, next) {
+    var params = {TableName: this.tableName, Item: JSON.parse(string)};
+    this.request(null, 'putItem', params, next);
+  });
+
+  this.Then(/^the item with id "([^"]*)" should exist$/, function(key, next) {
+    var world = this;
+    var params;
+    if (this.service.config.apiVersion === '2011-12-05') {
+      params = {TableName: this.tableName, Key: {HashKeyElement: {S: key}}};
+    } else if (this.service.config.apiVersion === '2012-08-10') {
+      params = {TableName: this.tableName, Key: {id: {S: key}}};
+    }
+    this.request(null, 'getItem', params, next);
+  });
+
+  this.Then(/^it should have attribute "([^"]*)" containing "([^"]*)"$/, function(attr, value, next) {
+    this.assert.equal(this.data.Item[attr].S, value);
+    next();
+  });
+
+  this.When(/^I delete the table$/, function(next) {
+    var params = {TableName: this.tableName};
+    this.request(null, 'deleteTable', params, next);
+  });
+
+  this.Then(/^the table should eventually not exist$/, function(callback) {
+    var params = {TableName: this.tableName};
+    this.service.waitFor('tableNotExists', params, callback);
+  });
+
+  this.Given(/^my first request is corrupted with CRC checking (ON|OFF)$/, function(toggle, callback) {
+    var world = this;
+    this.service.config.dynamoDbCrc32 = toggle == 'ON' ? true : false;
+    var req = this.service.listTables();
+    this.service.config.dynamoDbCrc32 = true;
+    req.removeAllListeners('httpData');
+    req.on('httpData', function(chunk, resp) {
+      if (resp.retryCount == 0) {
+        resp.httpResponse.body = new Buffer('{"invalid":"response"}');
+      } else {
+        world.AWS.EventListeners.Core.HTTP_DATA.call(this, chunk, resp);
+      }
+    });
+    req.on('complete', function(resp) {
+      world.error = resp.error;
+      world.response = resp;
+      if (resp.error) callback.fail(resp.error);
+      else callback();
+    });
+    req.send();
+  });
+
+  this.Then(/^the request should( not)? be retried$/, function(retry, callback) {
+    if (retry && this.response.retryCount > 0) callback.fail('Request was incorrectly retried');
+    if (!retry && this.response.retryCount == 0) callback.fail('Request was incorrectly retried');
+    callback();
+  });
+
+  this.Given(/^all of my requests are corrupted with CRC checking ON$/, function(callback) {
+    var world = this;
+    var req = this.service.listTables();
+    req.removeAllListeners('httpData');
+    req.on('httpData', function(chunk, resp) {
+      resp.httpResponse.body = new Buffer('{"invalid":"response"}');
+    });
+    req.on('complete', function(resp) {
+      world.error = resp.error;
+      world.response = resp;
+      callback();
+    });
+    req.send();
+  });
+
+  this.When(/^the request is retried the maximum number of times$/, function(callback) {
+    if (this.response.retryCount != 2) callback.fail('Incorrect retry count');
+    callback();
+  });
+
+  this.Then(/^the request should( not)? fail with a CRC checking error$/, function(failed, callback) {
+    if (failed && this.error) callback.fail(this.error);
+    if (!failed && !this.error) callback.fail('Did not fail when should have');
+    callback();
+  });
+
+  this.Given(/^I try to delete an item with key "([^"]*)" from table "([^"]*)"$/, function(key, table, callback) {
+    var params = {TableName: table, Key: {HashKeyElement: {S: key}}};
+    this.request(null, 'deleteItem', params, callback, false);
+  });
+
+  this.Given(/^I try to delete a table with an empty table parameter$/, function(callback) {
+    this.request(null, 'deleteTable', {TableName: ''}, callback, false);
+  });
+};

package/features/dynamodb/tables.feature

@@ -0,0 +1,50 @@
+# language: en
+@dynamodb @dynamodb-2011-12-05 @tables
+Feature: DynamoDB Tables (2011-12-05)
+
+  Scenario: Item CRUD
+    Given I have a table
+    When I put the item:
+    """
+    {"id": {"S": "foo"}, "data": {"S": "bår"}}
+    """
+    Then the item with id "foo" should exist
+    And it should have attribute "data" containing "bår"
+
+  Scenario: UTF-8 support
+    Given I try to delete an item with key "føø" from table "table"
+    Then the error code should be "ResourceNotFoundException"
+
+  Scenario: Improper table deletion
+    Given I try to delete a table with an empty table parameter
+    Then the error code should be "ValidationException"
+    And the error message should be:
+    """
+    TableName must be at least 3 characters long and at most 255 characters long
+    """
+    And the status code should be 400
+
+@dynamodb @dynamodb-2012-08-10 @tables
+Feature: DynamoDB Tables (2012-08-10)
+
+  Scenario: Item CRUD
+    Given I have a table
+    When I put the item:
+    """
+    {"id": {"S": "foo"}, "data": {"S": "bår"}}
+    """
+    Then the item with id "foo" should exist
+    And it should have attribute "data" containing "bår"
+
+  Scenario: UTF-8 support
+    Given I try to delete an item with key "føø" from table "table"
+    Then the error code should be "ResourceNotFoundException"
+
+  Scenario: Improper table deletion
+    Given I try to delete a table with an empty table parameter
+    Then the error code should be "ValidationException"
+    And the error message should be:
+    """
+    TableName must be at least 3 characters long and at most 255 characters long
+    """
+    And the status code should be 400

package/features/ec2/ec2.feature

@@ -0,0 +1,28 @@
+# language: en
+@ec2
+Feature: Amazon Elastic Compute Cloud
+
+  I want to use Amazon Elastic Compute Cloud
+
+  Scenario: DescribeRegions
+    Given I describe EC2 regions "us-east-1, us-west-1"
+    Then the EC2 endpoint for "us-east-1" should be "ec2.us-east-1.amazonaws.com"
+    And the EC2 endpoint for "us-west-1" should be "ec2.us-west-1.amazonaws.com"
+
+  Scenario: Error handling
+    Given I describe the EC2 instance ""
+    Then the error code should be "MissingParameter"
+    And the error message should be:
+    """
+    The request must contain the parameter InstanceId
+    """
+    And the status code should be 400
+
+  Scenario: Encrypted CopySnapshot
+    Given I attempt to copy an encrypted snapshot across regions
+    Then the copy snapshot attempt should be successful
+
+  @pagination
+  Scenario: Paginating responses
+    Given I paginate the "describeReservedInstancesOfferings" operation with limit 20 and max pages 3
+    Then I should get 3 pages

package/features/ec2/step_definitions/ec2.js

@@ -0,0 +1,65 @@
+module.exports = function() {
+  this.Before("@ec2", function (callback) {
+    this.service = new this.AWS.EC2();
+    callback();
+  });
+
+  this.Given(/^I describe EC2 regions "([^"]*)"$/, function(regions, callback) {
+    regions = regions.split(/\s*,\s*/);
+    this.request(null, 'describeRegions', {RegionNames: regions}, callback);
+  });
+
+  this.Then(/^the EC2 endpoint for "([^"]*)" should be "([^"]*)"$/, function(region, endpoint, callback) {
+    this.assert.contains(this.data.Regions, function(region) {
+      return region.Endpoint === endpoint;
+    });
+    callback();
+  });
+
+  this.Given(/^I describe the EC2 instance "([^"]*)"$/, function(instanceId, callback) {
+    this.request(null, 'describeInstances', {InstanceIds: [instanceId]}, callback, false);
+  });
+
+  this.Given(/^I attempt to copy an encrypted snapshot across regions$/, function (callback) {
+    var self = this;
+    var volId, srcSnapId, dstSnapId, params;
+    var sourceRegion = 'us-west-2';
+    var destRegion = 'us-east-1';
+    var srcEc2 = new this.AWS.EC2({region: sourceRegion});
+    var dstEc2 = new this.AWS.EC2({region: destRegion});
+
+    function teardown() {
+      if (volId) srcEc2.deleteVolume({VolumeId: volId}).send();
+      if (srcSnapId) srcEc2.deleteSnapshot({SnapshotId: srcSnapId}).send();
+      if (dstSnapId) dstEc2.deleteSnapshot({SnapshotId: dstSnapId}).send();
+    }
+
+    params = {AvailabilityZone:sourceRegion+'a',Size:1,Encrypted:true};
+    srcEc2.createVolume(params, function(err, data) {
+      if (err) return teardown();
+      volId = data.VolumeId;
+
+      setTimeout(function() {
+        srcEc2.createSnapshot({VolumeId: volId}, function(err, data) {
+          if (err) return teardown();
+          srcSnapId = data.SnapshotId;
+
+          setTimeout(function() {
+            params = {SourceRegion: sourceRegion, SourceSnapshotId: srcSnapId};
+            dstEc2.copySnapshot(params, function(err, data) {
+              if (data) dstSnapId = data.SnapshotId;
+              self.success = true;
+              callback();
+              teardown();
+            });
+          }, 1000);
+        });
+      }, 1500);
+    });
+  });
+
+  this.Then(/^the copy snapshot attempt should be successful$/, function (callback) {
+    this.assert.equal(this.success, true);
+    callback();
+  });
+};

package/features/elasticache/elasticache.feature

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

package/features/elasticache/step_definitions/elasticache.js

@@ -0,0 +1,34 @@
+module.exports = function() {
+  this.Before("@elasticache", function (callback) {
+    this.service = new this.AWS.ElastiCache();
+    callback();
+  });
+
+  this.Given(/^I create a ElastiCache security group with prefix name "([^"]*)"$/, function(prefix, callback) {
+    this.cacheGroupName = this.uniqueName(prefix);
+    var params = { Description: 'Description', CacheSecurityGroupName: this.cacheGroupName };
+    this.request(null, 'createCacheSecurityGroup', params, callback, false);
+  });
+
+  this.Given(/^the ElastiCache security group name is in the result$/, function(callback) {
+    var name = this.data.CacheSecurityGroup.CacheSecurityGroupName;
+    this.assert.equal(name, this.cacheGroupName);
+    callback();
+  });
+
+  this.Given(/^I describe the ElastiCache security group$/, function(callback) {
+    var params = {CacheSecurityGroupName: this.cacheGroupName};
+    this.request(null, 'describeCacheSecurityGroups', params, callback);
+  });
+
+  this.Then(/^the ElastiCache security group should be described$/, function(callback) {
+    var item = this.data.CacheSecurityGroups[0];
+    this.assert.equal(item.CacheSecurityGroupName, this.cacheGroupName);
+    callback();
+  });
+
+  this.Then(/^I delete the ElastiCache security group$/, function(callback) {
+    var params = {CacheSecurityGroupName: this.cacheGroupName};
+    this.request(null, 'deleteCacheSecurityGroup', params, callback);
+  });
+};

package/features/elasticbeanstalk/elasticbeanstalk.feature

@@ -0,0 +1,22 @@
+# language: en
+@elasticbeanstalk
+Feature: AWS Elastic Beanstalk
+
+  I want to use AWS Elastic Beanstalk
+
+  @requiresakid
+  Scenario: Creating applications and application versions
+    Given I create an Elastic Beanstalk application with name prefix "aws-js-sdk"
+    And I create an Elastic Beanstalk application version with label "1.0.0"
+    And I describe the Elastic Beanstalk application
+    Then the result should contain the Elastic Beanstalk application version
+    And the result should contain the Elastic Beanstalk application name
+    And I delete the Elastic Beanstalk application
+
+  Scenario: Error handling
+    Given I create an Elastic Beanstalk application with name prefix ""
+    Then the error code should be "ValidationError"
+    And the error message should match:
+    """
+    Value '' at 'applicationName'
+    """

package/features/elasticbeanstalk/step_definitions/elasticbeanstalk.js

@@ -0,0 +1,38 @@
+module.exports = function() {
+  this.Before("@elasticbeanstalk", function (callback) {
+    this.service = new this.AWS.ElasticBeanstalk();
+    callback();
+  });
+
+  this.Given(/^I create an Elastic Beanstalk application with name prefix "([^"]*)"$/, function(prefix, callback) {
+    this.appName = this.uniqueName(prefix);
+    var params = { ApplicationName: this.appName };
+    this.request(null, 'createApplication', params, callback, false);
+  });
+
+  this.Given(/^I create an Elastic Beanstalk application version with label "([^"]*)"$/, function(label, callback) {
+    this.appVersion = label;
+    var params = { ApplicationName: this.appName, VersionLabel: this.appVersion };
+    this.request(null, 'createApplicationVersion', params, callback);
+  });
+
+  this.Given(/^I describe the Elastic Beanstalk application$/, function(callback) {
+    var params = { ApplicationNames: [this.appName] };
+    this.request(null, 'describeApplications', params, callback);
+  });
+
+  this.Then(/^the result should contain the Elastic Beanstalk application version$/, function(callback) {
+    this.assert.deepEqual(this.data.Applications[0].Versions, [this.appVersion]);
+    callback();
+  });
+
+  this.Then(/^the result should contain the Elastic Beanstalk application name$/, function(callback) {
+    this.assert.equal(this.data.Applications[0].ApplicationName, this.appName);
+    callback();
+  });
+
+  this.Then(/^I delete the Elastic Beanstalk application$/, function(callback) {
+    var params = { ApplicationName: this.appName };
+    this.request(null, 'deleteApplication', params, callback);
+  });
+};

package/features/elastictranscoder/elastictranscoder.feature

@@ -0,0 +1,24 @@
+# language: en
+@elastictranscoder
+Feature: Elastic Transcoder
+
+  I want to use Amazon Elastic Transcoder
+
+  @pipelines
+  Scenario: Pipeline CRUD
+    Given I create an IAM role with name prefix "aws-sdk-js"
+    And I create a bucket
+    And I create an Elastic Transcoder pipeline with name prefix "aws-sdk-js"
+    And I list pipelines
+    Then the list should contain the pipeline
+    And I pause the pipeline
+    And I read the pipeline
+    Then the pipeline status should be "Paused"
+    And I delete the pipeline
+    And I delete the bucket
+    And I delete the IAM role
+
+  @error
+  Scenario: Error handling
+    Given I create an Elastic Transcoder pipeline with name prefix ""
+    Then the error code should be "ValidationException"