aws-sdk 2.0.1 → 2.0.5

package/features/s3/objects.feature

@@ -0,0 +1,122 @@
+# language: en
+@s3 @objects
+Feature: Working with Objects in S3
+
+  As a user of S3
+  I need to be able to work with objects in a bucket.
+
+  Scenario: CRUD objects
+    When I write "world" to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain "world"
+    When I write "new world" to the key "hello"
+    Then the object with the key "hello" should exist
+    Then the object with the key "hello" should contain "new world"
+
+    # Empty files
+    When I write "" to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain ""
+
+    # ContentLength
+    When I write "foobar" to the key "hello" with ContentLength 3
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain "foo"
+
+    # ContentLength
+    When I write empty buffer to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain ""
+
+    # UTF-8
+    When I write "åß∂ƒ©" to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain "åß∂ƒ©"
+
+    When I copy an object with the key "hello" to "byebye"
+    Then the object with the key "byebye" should exist
+    And the object with the key "byebye" should contain "åß∂ƒ©"
+    And I delete the object with the key "byebye"
+
+    # Unauthenticated request
+    When I write "world" to the public key "hello"
+    Then the unauthenticated request to read key "hello" should equal "world"
+
+    When I delete the object with the key "hello"
+    Then the object with the key "hello" should not exist
+
+  @presigned
+  Scenario: Pre-signed URLs
+    Given I get a pre-signed URL to PUT the key "hello"
+    And I access the URL via HTTP PUT with data "PRESIGNED BODY CONTENTS"
+    When I get a pre-signed URL to GET the key "hello"
+    And I access the URL via HTTP GET
+    Then the HTTP response should equal "PRESIGNED BODY CONTENTS"
+
+  @presigned @checksum
+  Scenario: Pre-signed URLs with checksum
+    Given I get a pre-signed URL to PUT the key "hello" with data "CHECKSUMMED"
+    And I access the URL via HTTP PUT with data "NOT CHECKSUMMED"
+    Then the HTTP response should contain "SignatureDoesNotMatch"
+
+  @buffer
+  Scenario: Buffers and streams
+    When I write buffer "world" to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain "world"
+
+    When I write file "testfile.txt" to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain "CONTENTS OF FILE"
+
+    When I stream key "hello"
+    Then the streamed data should contain "CONTENTS OF FILE"
+
+    When I stream2 key "hello"
+    Then the streamed data should contain "CONTENTS OF FILE"
+
+  @progress
+  Scenario: Progress events
+    When I write a 512KB buffer to the key "hello" with progress events
+    Then more than 1 "httpUploadProgress" event should fire
+    And the "total" value of the progress event should equal 512KB
+    And the "loaded" value of the first progress event should be greater than 10 bytes
+
+    When I read the key "hello" with progress events
+    Then more than 1 "httpDownloadProgress" event should fire
+    And the "total" value of the progress event should equal 512KB
+    And the "loaded" value of the first progress event should be greater than 10 bytes
+
+  @proxy
+  Scenario: Proxy support
+    When I write "world" to the key "hello"
+    Then the object with the key "hello" should exist
+    And the object with the key "hello" should contain "world"
+
+    When I delete the object with the key "hello"
+    Then the object with the key "hello" should not exist
+
+    And I teardown the local proxy server
+
+  @pagination
+  Scenario: Paginating responses
+    Given I delete the object with the key "hello"
+    And I write "data" to the key "obj0"
+    And I write "data" to the key "obj1"
+    And I write "data" to the key "obj2"
+    And I write "data" to the key "obj3"
+    And I write "data" to the key "obj4"
+    And I write "data" to the key "obj5"
+    And I write "data" to the key "obj6"
+    And I write "data" to the key "obj7"
+    And I write "data" to the key "obj8"
+    And I write "data" to the key "obj9"
+    And the object with the key "obj9" should exist
+    And I setup the listObjects request for the bucket
+    When I paginate the "listObjects" operation with limit 3
+    Then I should get 4 pages
+
+  @error
+  Scenario: Error handling
+    Given I write "data" to the invalid key ""
+    Then the status code should be 400

package/features/s3/step_definitions/buckets.js

@@ -0,0 +1,136 @@
+module.exports = function() {
+
+  this.When(/^I create a bucket$/, function(next) {
+    this.bucket = this.uniqueName('aws-sdk-js-integration');
+    this.request('s3', 'createBucket', {Bucket:this.bucket}, next);
+  });
+
+  this.When(/^I create a bucket with the location constraint "([^"]*)"$/, function(loc, next) {
+    this.bucket = this.uniqueName('aws-sdk-js-integration');
+    var params = { Bucket: this.bucket, CreateBucketConfiguration: { LocationConstraint: loc }};
+    this.request('s3', 'createBucket', params, next);
+  });
+
+  this.Then(/^the bucket should exist$/, function(next) {
+    this.s3.waitFor('bucketExists', {Bucket:this.bucket}, next);
+  });
+
+  this.When(/^I delete the bucket$/, function(next) {
+    this.request('s3', 'deleteBucket', {Bucket:this.bucket}, next);
+  });
+
+  this.Then(/^the bucket should not exist$/, function(next) {
+    this.s3.waitFor('bucketNotExists', {Bucket:this.bucket}, next);
+  });
+
+  this.Then(/^the bucket should have a location constraint of "([^"]*)"$/, function(loc, next) {
+    var self = this;
+    self.s3.getBucketLocation({Bucket:self.bucket}, function(err, data) {
+      self.assert.equal(data.LocationConstraint, loc);
+      next();
+    });
+  });
+
+  this.Then(/^I delete the bucket$/, function(next) {
+    this.request('s3', 'deleteBucket', {Bucket:this.bucket}, next);
+  });
+
+  this.When(/^I put a transition lifecycle configuration on the bucket with prefix "([^"]*)"$/, function(prefix, callback) {
+    var params = {
+      Bucket: this.bucket,
+      LifecycleConfiguration: {
+        Rules: [{
+          Prefix: prefix,
+          Status: 'Enabled',
+          Transition: {Days: 0, StorageClass: 'GLACIER'}
+        }]
+      }
+    };
+
+    this.request('s3', 'putBucketLifecycle', params, callback);
+  });
+
+  this.When(/^I get the transition lifecycle configuration on the bucket$/, function(callback) {
+    this.eventually(callback, function(next) {
+      this.request('s3', 'getBucketLifecycle', {Bucket: this.bucket}, next);
+    });
+  });
+
+  this.Then(/^the lifecycle configuration should have transition days of (\d+)$/, function(days, callback) {
+    this.assert.equal(this.data.Rules[0].Transition.Days, 0);
+    callback();
+  });
+
+  this.Then(/^the lifecycle configuration should have transition storage class of "([^"]*)"$/, function(value, callback) {
+    this.assert.equal(this.data.Rules[0].Transition.StorageClass, value);
+    callback();
+  });
+
+  this.When(/^I put a bucket CORS configuration$/, function(callback) {
+    var params = {
+      Bucket: this.bucket,
+      CORSConfiguration: {
+        CORSRules: [{
+          AllowedMethods: ['DELETE', 'POST', 'PUT'],
+          AllowedOrigins: ['http://example.com'],
+          AllowedHeaders: ['*'],
+          ExposeHeaders: ['x-amz-server-side-encryption'],
+          MaxAgeSeconds: 5000
+        }]
+      }
+    }
+    this.request('s3', 'putBucketCors', params, callback);
+  });
+
+  this.When(/^I get the bucket CORS configuration$/, function(callback) {
+    this.request('s3', 'getBucketCors', {Bucket: this.bucket}, callback);
+  });
+
+  this.Then(/^the AllowedMethods list should inclue "([^"]*)"$/, function(value, callback) {
+    this.assert.equal(this.data.CORSRules[0].AllowedMethods.sort().join(" "), "DELETE POST PUT");
+    callback();
+  });
+
+  this.Then(/^the AllowedOrigin value should equal "([^"]*)"$/, function(value, callback) {
+    this.assert.equal(this.data.CORSRules[0].AllowedOrigins[0], value);
+    callback();
+  });
+
+  this.Then(/^the AllowedHeader value should equal "([^"]*)"$/, function(value, callback) {
+    this.assert.equal(this.data.CORSRules[0].AllowedHeaders[0], value);
+    callback();
+  });
+
+  this.Then(/^the ExposeHeader value should equal "([^"]*)"$/, function(value, callback) {
+    this.assert.equal(this.data.CORSRules[0].ExposeHeaders[0], value);
+    callback();
+  });
+
+  this.Then(/^the MaxAgeSeconds value should equal (\d+)$/, function(value, callback) {
+    this.assert.equal(this.data.CORSRules[0].MaxAgeSeconds, parseInt(value));
+    callback();
+  });
+
+  this.When(/^I put a bucket tag with key "([^"]*)" and value "([^"]*)"$/, function(key, value, callback) {
+    var params = {
+      Bucket: this.bucket,
+      Tagging: {
+        TagSet: [
+          {Key: key, Value: value}
+        ]
+      }
+    };
+
+    this.request('s3', 'putBucketTagging', params, callback);
+  });
+
+  this.When(/^I get the bucket tagging$/, function(callback) {
+    this.request('s3', 'getBucketTagging', {Bucket: this.bucket}, callback);
+  });
+
+  this.Then(/^the first tag in the tag set should have key and value "([^"]*)", "([^"]*)"$/, function(key, value, callback) {
+    this.assert.equal(this.data.TagSet[0].Key, key);
+    this.assert.equal(this.data.TagSet[0].Value, value);
+    callback();
+  });
+};

package/features/s3/step_definitions/hooks.js

@@ -0,0 +1,39 @@
+module.exports = function () {
+
+  function cleanBucket(world, bucket, callback) {
+    if (!bucket) { callback(); return; }
+
+    var params = {Bucket: bucket};
+    var deleteBucket = function() {
+      delete params.Delete;
+      world.request('s3', 'deleteBucket', params, callback, false);
+    }
+
+    world.s3.listObjects(params, function (err, data) {
+      if (err) { deleteBucket(); return; }
+      if (data.Contents.length > 0) {
+        params.Delete = { Objects: [] };
+        world.AWS.util.arrayEach(data.Contents, function (item) {
+          params.Delete.Objects.push({Key: item.Key});
+        });
+        world.request('s3', 'deleteObjects', params, deleteBucket);
+      } else {
+        deleteBucket();
+      }
+    });
+  }
+
+  this.Before("@s3", function (callback) {
+    this.service = this.s3 = new this.AWS.S3({maxRetries: 100});
+    callback();
+  });
+
+  this.After("@s3", function (callback) {
+    cleanBucket(this, this.bucket, callback);
+  });
+
+  this.AfterAll(function(callback) {
+    cleanBucket(this, this.sharedBucket, callback);
+  });
+
+};

package/features/s3/step_definitions/objects.js

@@ -0,0 +1,204 @@
+module.exports = function () {
+  /**
+   * Create a single bucket that will be shared by all s3 object scenarios.
+   */
+  this.Before("@s3", "@objects", function (callback) {
+
+    // execute only once
+    if (this.sharedBucket) {
+      callback();
+      return;
+    }
+
+    this.sharedBucket = this.uniqueName('aws-sdk-js-integration');
+    this.s3.createBucket({Bucket:this.sharedBucket}, function(err, data) {
+      callback();
+    });
+  });
+
+  this.When(/^I write (buffer )?"([^"]*)" to the key "([^"]*)"$/, function(buffer, contents, key, next) {
+    var params = {Bucket: this.sharedBucket, Key: key, Body: buffer ? new Buffer(contents) : contents};
+    this.request('s3', 'putObject', params, next);
+  });
+
+  this.When(/^I write (buffer )?"([^"]*)" to the invalid key "([^"]*)"$/, function(buffer, contents, key, next) {
+    var params = {Bucket: this.sharedBucket, Key: key, Body: buffer ? new Buffer(contents) : contents};
+    this.request('s3', 'putObject', params, next, false);
+  });
+
+  this.When(/^I write "([^"]*)" to the key "([^"]*)" with ContentLength (\d+)$/, function(contents, key, contentLength, next) {
+    var params = {Bucket: this.sharedBucket, Key: key, Body: contents, ContentLength: parseInt(contentLength)};
+    this.s3nochecksums = new this.AWS.S3({computeChecksums: false});
+    this.request('s3nochecksums', 'putObject', params, next);
+  });
+
+  this.When(/^I write empty buffer to the key "([^"]*)"$/, function (key, next) {
+    var params = {Bucket: this.sharedBucket, Key: key, Body: new Buffer(0)};
+    this.request('s3', 'putObject', params, next);
+  });
+
+  this.Then(/^the object with the key "([^"]*)" should contain "([^"]*)"$/, function(key, contents, next) {
+    this.assert.equal(this.data.Body.toString().replace("\n", ""), contents);
+    next();
+  });
+
+  this.When(/^I copy an object with the key "([^"]*)" to "([^"]*)"$/, function(key1, key2, next) {
+    var params = {
+      Bucket: this.sharedBucket, Key: key2, CopySource: '/' + this.sharedBucket + '/' + key1
+    }
+    this.request('s3', 'copyObject', params, next);
+  });
+
+  this.When(/^I delete the object with the key "([^"]*)"$/, function(key, next) {
+    var params = {Bucket:this.sharedBucket,Key:key};
+    this.request('s3', 'deleteObject', params, next);
+  });
+
+  this.Then(/^the object with the key "([^"]*)" should (not )?exist$/, function(key, shouldNotExist, next) {
+    var params = { Bucket:this.sharedBucket, Key:key };
+    this.eventually(next, function (retry) {
+      retry.condition = function() {
+        if (shouldNotExist) {
+          return this.error && this.error.code == 'NoSuchKey';
+        } else {
+          return !this.error;
+        }
+      };
+      this.request('s3', 'getObject', params, retry, false);
+    });
+  });
+
+  this.When(/^I write file "([^"]*)" to the key "([^"]*)"$/, function(filename, key, next) {
+    var fs = require('fs');
+    var params = {Bucket: this.sharedBucket, Key: key, Body:
+      fs.createReadStream(__dirname + '/../../extra/fixtures/' + filename)};
+    this.request('s3', 'putObject', params, next);
+  });
+
+  this.When(/^I stream key "([^"]*)"$/, function(key, callback) {
+    var params = {Bucket: this.sharedBucket, Key: key};
+    var world = this;
+    this.result = '';
+    this.service.getObject(params).createReadStream().
+      on('end', function() { callback(); }).
+      on('data', function(d) { world.result += d.toString(); });
+  });
+
+  this.When(/^I stream2 key "([^"]*)"$/, function(key, callback) {
+    if (!require('stream').Readable) return callback();
+    var params = {Bucket: this.sharedBucket, Key: key};
+    var world = this;
+    this.result = '';
+    var stream = this.service.getObject(params).createReadStream();
+    stream.on('end', function() { callback(); });
+    stream.on('readable', function() {
+      var v = stream.read(); if (v) world.result += v;
+    });
+  });
+
+  this.Then(/^the streamed data should contain "([^"]*)"$/, function(data, callback) {
+    this.assert.equal(this.result.replace('\n', ''), data);
+    callback();
+  });
+
+  this.When(/^I get a pre\-signed URL to GET the key "([^"]*)"$/, function(key, callback) {
+    this.signedUrl = this.s3.getSignedUrl('getObject', {Bucket: this.sharedBucket, Key: key});
+    callback();
+  });
+
+  this.When(/^I access the URL via HTTP GET$/, function(callback, verb) {
+    var world = this;
+    this.data = '';
+    require('https').get(this.signedUrl, function (res) {
+      res.on('data', function (chunk) {
+        world.data += chunk.toString();
+      }).on('end', callback);
+    }).on('error', callback.fail);
+  });
+
+  this.Given(/^I get a pre\-signed URL to PUT the key "([^"]*)"(?: with data "([^"]*)")?$/, function(key, body, callback) {
+    var params = {Bucket: this.sharedBucket, Key: key};
+    if (body) params.Body = body;
+    this.signedUrl = this.s3.getSignedUrl('putObject', params);
+    callback();
+  });
+
+  this.Given(/^I access the URL via HTTP PUT with data "([^"]*)"$/, function(body, callback) {
+    var world = this;
+    this.data = '';
+
+    var data = body;
+    var options = require('url').parse(this.signedUrl);
+    options.method = 'PUT';
+    options.headers = {'Content-Length': data.length};
+
+    var req = require('https').request(options, function (res) {
+      res.on('data', function (chunk) {
+        world.data += chunk.toString();
+      }).on('end', callback);
+    }).on('error', callback.fail).end(data);
+  });
+
+  this.Then(/^the HTTP response should equal "([^"]*)"$/, function(data, callback) {
+    this.assert.equal(this.data, data);
+    callback();
+  });
+
+  this.Then(/^the HTTP response should contain "([^"]*)"$/, function(data, callback) {
+    this.assert.match(this.data, data);
+    callback();
+  });
+
+  this.Given(/^I setup the listObjects request for the bucket$/, function(callback) {
+    this.params = { Bucket: this.sharedBucket };
+    callback();
+  });
+
+  // progress events
+
+  this.When(/^I write a (\d+)KB buffer to the key "([^"]*)" with progress events$/, function(kb, key, callback) {
+    var self = this;
+    var body = new Buffer(new Array(kb * 1024 + 1).join('x'));
+    this.progress = [];
+    var req = this.s3.putObject({Bucket: this.sharedBucket, Key: key, Body: body});
+    req.on('httpUploadProgress', function (p) { self.progress.push(p) });
+    req.send(callback);
+  });
+
+  this.Then(/^more than (\d+) "([^"]*)" event should fire$/, function(numEvents, eventName, callback) {
+    this.assert.compare(this.progress.length, '>', numEvents);
+    callback();
+  });
+
+  this.Then(/^the "([^"]*)" value of the progress event should equal (\d+)KB$/, function(prop, kb, callback) {
+    this.assert.equal(this.progress[0][prop], kb * 1024);
+    callback();
+  });
+
+  this.Then(/^the "([^"]*)" value of the first progress event should be greater than (\d+) bytes$/, function(prop, bytes, callback) {
+    this.assert.compare(this.progress[0][prop], '>', bytes);
+    callback();
+  });
+
+  this.When(/^I read the key "([^"]*)" with progress events$/, function(key, callback) {
+    var self = this;
+    this.progress = [];
+    var req = this.s3.getObject({Bucket: this.sharedBucket, Key: key});
+    req.on('httpDownloadProgress', function (p) { self.progress.push(p) });
+    req.send(callback);
+  });
+
+  this.When(/^I write "([^"]*)" to the public key "([^"]*)"$/, function(data, key, next) {
+    var params = {Bucket: this.sharedBucket, Key: key, Body: data, ACL: 'public-read'};
+    this.request('s3', 'putObject', params, next);
+  });
+
+  this.Then(/^the unauthenticated request to read key "([^"]*)" should equal "([^"]*)"$/, function(key, body, next) {
+    var params = {Bucket: this.sharedBucket, Key: key};
+    this.s3.makeUnauthenticatedRequest('getObject', params, function (err, data) {
+      if (err) return next(err);
+      this.assert.equal(data.Body.toString(), body);
+      next();
+    }.bind(this));
+  });
+};

package/features/s3/step_definitions/proxy.js

@@ -0,0 +1,44 @@
+var url = require('url');
+var http = require('http');
+
+module.exports = function() {
+  this.Before("@s3", "@proxy", function(callback) {
+    setupProxyServer.call(this);
+
+    this.service = this.s3 = new this.AWS.S3({
+      httpOptions: { proxy: 'http://localhost:' + this.proxyPort }
+    });
+
+    callback();
+  });
+
+  this.Then(/^I teardown the local proxy server$/, function(callback) {
+    this.service = this.s3 = new this.AWS.S3();
+    this.proxyServer.close(callback);
+  });
+
+  function setupProxyServer() {
+    if (this.proxyServer) return;
+    this.proxyPort = 8000 + parseInt(Math.random() * 100);
+    this.proxyServer = http.createServer(function (req, res) {
+      var uri = url.parse(req.url);
+      var options = {
+        host: uri.hostname,
+        port: uri.port || 80,
+        method: req.method,
+        path: uri.path,
+        headers: req.headers
+      };
+      options.headers.host = uri.hostname;
+
+      var s = http.request(options, function (res2) {
+        res.writeHead(res2.statusCode, res2.headers);
+        res2.on('data', function(ch) {
+          res.write(ch);
+        }).on('end', function() { res.end(); });
+      });
+      req.pipe(s);
+    });
+    this.proxyServer.listen(this.proxyPort);
+  }
+};

package/features/ses/ses.feature

@@ -0,0 +1,20 @@
+# language: en
+@ses
+Feature: SES
+
+  I want to use Simple Email Service.
+
+  Scenario: Check quota
+    When I check quota
+    Then the result should include number "SentLast24Hours"
+    And the result should include number "MaxSendRate"
+
+  Scenario: Verify email
+    When I ask to verify the email address "foo@example.com"
+    Then the status code should be 200
+
+  Scenario: Rescue SES InvalidParameterValue
+    When I ask to verify the email address "abc123"
+    Then I should get the error:
+    | code                  | message                        |
+    | InvalidParameterValue | Invalid email address<abc123>. |

package/features/ses/step_definitions/ses.js

@@ -0,0 +1,22 @@
+module.exports = function() {
+  this.Before("@ses", function (callback) {
+    this.service = new this.AWS.SES();
+    callback();
+  });
+
+  this.When(/^I check quota$/, function(next) {
+    this.request(null, 'getSendQuota', {}, next);
+  });
+
+  this.Then(/^the result should include (\S+) "([^"]*)"$/, function(type, attr, next) {
+    if (this.data[attr] === undefined) next.fail("Missing " + attr);
+    if (typeof this.data[attr] !== type) next.fail("Incorrect type " + attr);
+    next();
+  });
+
+  this.When(/^I ask to verify the email address "([^"]*)"$/, function(email, next) {
+    this.request(null, 'verifyEmailAddress', {EmailAddress: email}, next, function() {
+      // do nothing
+    });
+  });
+};

package/features/simpledb/simpledb.feature

@@ -0,0 +1,29 @@
+# language: en
+@simpledb
+Feature: Amazon SimpleDB
+
+  I want to use Amazon SimpleDB
+
+  Scenario: CRUD
+    Given I create a SimpleDB domain
+    And I put an item "key" with attributes:
+    """
+    [{"Name": "attr1", "Value": "value1"}]
+    """
+    And I get the item "key"
+    Then the result should have attribute "attr1" with "value1"
+    And I delete the domain
+
+  Scenario: SELECT * statements
+    Given I create a SimpleDB domain
+    And I put an item "key" with attributes:
+    """
+    [{"Name": "attr1", "Value": "value1"}]
+    """
+    And I select "*" from the domain
+    Then the select result should contain the item
+    And I delete the domain
+
+  Scenario: Error handling
+    Given I create a domain with no name
+    Then the error code should be "InvalidParameterValue"

package/features/simpledb/step_definitions/simpledb.js

@@ -0,0 +1,46 @@
+module.exports = function() {
+  this.Before("@simpledb", function (callback) {
+    this.service = new this.AWS.SimpleDB();
+    this.domainName = 'aws-sdk-js-integration-' + new Date().getTime();
+    callback();
+  });
+
+  this.Given(/^I create a SimpleDB domain$/, function(callback) {
+    this.request(null, 'createDomain', {DomainName: this.domainName}, callback);
+  });
+
+  this.Given(/^I put an item "([^"]*)" with attributes:$/, function(item, string, callback) {
+    this.item = {Name: item, Attributes: JSON.parse(string)};
+    var params = {DomainName: this.domainName, ItemName: item, Attributes: this.item.Attributes};
+    this.request(null, 'putAttributes', params, callback);
+  });
+
+  this.Given(/^I get the item "([^"]*)"$/, function(item, callback) {
+    var params = {DomainName: this.domainName, ItemName: item, ConsistentRead: true};
+    this.request(null, 'getAttributes', params, callback);
+  });
+
+  this.Given(/^I select "([^"]*)" from the domain$/, function(expr, callback) {
+    var params = {SelectExpression: 'SELECT ' + expr + ' FROM `' + this.domainName + '`', ConsistentRead: true};
+    this.request(null, 'select', params, callback);
+  });
+
+  this.Then(/^the select result should contain the item$/, function(callback) {
+    this.assert.deepEqual(this.data.Items, [this.item]);
+    callback();
+  });
+
+  this.Then(/^the result should have attribute "([^"]*)" with "([^"]*)"$/, function(name, value, callback) {
+    this.assert.equal(this.data.Attributes[0].Name, name);
+    this.assert.equal(this.data.Attributes[0].Value, value);
+    callback();
+  });
+
+  this.Then(/^I delete the domain$/, function(callback) {
+    this.request(null, 'deleteDomain', {DomainName: this.domainName}, callback);
+  });
+
+  this.Given(/^I create a domain with no name$/, function(callback) {
+    this.request(null, 'createDomain', {DomainName: ''}, callback, false);
+  });
+};

package/features/sns/sns.feature

@@ -0,0 +1,15 @@
+# language: en
+@sns
+Feature: Simple Notification Service
+
+  I want to use Amazon Simple Notification Service
+
+  Scenario: Topics
+    Given I create an SNS topic with name "aws-js-sdk-integration-topic"
+    And I list the SNS topics
+    Then the list should contain the topic ARN
+    And I delete the SNS topic
+
+  Scenario: Error handling
+    Given I get SNS topic attributes with an invalid ARN
+    Then the error code should be "InvalidParameter"