aws-sdk 2.0.1 → 2.0.5

package/test/services/s3.spec.coffee

@@ -0,0 +1,538 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+Stream = require('stream').Stream
+Buffer = AWS.util.Buffer
+
+describe 'AWS.S3', ->
+
+  s3 = null
+  request = (operation, params) -> s3.makeRequest(operation, params)
+
+  beforeEach ->
+    s3 = new AWS.S3(region: undefined)
+
+  describe 'dnsCompatibleBucketName', ->
+
+    it 'must be at least 3 characters', ->
+      expect(s3.dnsCompatibleBucketName('aa')).toBe(false)
+
+    it 'must not be longer than 63 characters', ->
+      b = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+      expect(s3.dnsCompatibleBucketName(b)).toBe(false)
+
+    it 'must start with a lower-cased letter or number', ->
+      expect(s3.dnsCompatibleBucketName('Abc')).toBe(false)
+      expect(s3.dnsCompatibleBucketName('-bc')).toBe(false)
+      expect(s3.dnsCompatibleBucketName('abc')).toBe(true)
+
+    it 'must end with a lower-cased letter or number', ->
+      expect(s3.dnsCompatibleBucketName('abC')).toBe(false)
+      expect(s3.dnsCompatibleBucketName('ab-')).toBe(false)
+      expect(s3.dnsCompatibleBucketName('abc')).toBe(true)
+
+    it 'may not contain multiple contiguous dots', ->
+      expect(s3.dnsCompatibleBucketName('abc.123')).toBe(true)
+      expect(s3.dnsCompatibleBucketName('abc..123')).toBe(false)
+
+    it 'may only contain letters numbers and dots', ->
+      expect(s3.dnsCompatibleBucketName('abc123')).toBe(true)
+      expect(s3.dnsCompatibleBucketName('abc_123')).toBe(false)
+
+    it 'must not look like an ip address', ->
+      expect(s3.dnsCompatibleBucketName('1.2.3.4')).toBe(false)
+      expect(s3.dnsCompatibleBucketName('a.b.c.d')).toBe(true)
+
+  describe 'endpoint', ->
+
+    it 'sets hostname to s3.amazonaws.com when region is un-specified', ->
+      s3 = new AWS.S3(region: undefined)
+      expect(s3.endpoint.hostname).toEqual('s3.amazonaws.com')
+
+    it 'sets hostname to s3.amazonaws.com when region is us-east-1', ->
+      s3 = new AWS.S3(region: 'us-east-1')
+      expect(s3.endpoint.hostname).toEqual('s3.amazonaws.com')
+
+    it 'sets region to us-east-1 when unspecified', ->
+      s3 = new AWS.S3(region: 'us-east-1')
+      expect(s3.config.region).toEqual('us-east-1')
+
+    it 'combines the region with s3 in the endpoint using a - instead of .', ->
+      s3 = new AWS.S3(region: 'us-west-1')
+      expect(s3.endpoint.hostname).toEqual('s3-us-west-1.amazonaws.com')
+
+  describe 'building a request', ->
+    build = (operation, params) ->
+      request(operation, params).build().httpRequest
+
+    it 'obeys the configuration for s3ForcePathStyle', ->
+      config = new AWS.Config(s3ForcePathStyle: true, accessKeyId: 'AKID', secretAccessKey: 'SECRET')
+      s3 = new AWS.S3(config)
+      expect(s3.config.s3ForcePathStyle).toEqual(true)
+      req = build('headObject', {Bucket:'bucket', Key:'key'})
+      expect(req.endpoint.hostname).toEqual('s3.amazonaws.com')
+      expect(req.path).toEqual('/bucket/key')
+
+    describe 'uri escaped params', ->
+      it 'uri-escapes path and querystring params', ->
+        # bucket param ends up as part of the hostname
+        params = { Bucket: 'bucket', Key: 'a b c', VersionId: 'a&b' }
+        req = build('headObject', params)
+        expect(req.path).toEqual('/a%20b%20c?versionId=a%26b')
+
+      it 'does not uri-escape forward slashes in the path', ->
+        params = { Bucket: 'bucket', Key: 'k e/y' }
+        req = build('headObject', params)
+        expect(req.path).toEqual('/k%20e/y')
+
+      it 'ensures a single forward slash exists', ->
+        req = build('listObjects', { Bucket: 'bucket' })
+        expect(req.path).toEqual('/')
+
+        req = build('listObjects', { Bucket: 'bucket', MaxKeys:123 })
+        expect(req.path).toEqual('/?max-keys=123')
+
+    describe 'adding Content-Type', ->
+      beforeEach -> spyOn(AWS.util, 'isBrowser').andReturn(true)
+
+      it 'adds default content-type when not supplied', ->
+        req = build('putObject', Bucket: 'bucket', Key: 'key', Body: 'body')
+        expect(req.headers['Content-Type']).toEqual('application/octet-stream; charset=UTF-8')
+
+      it 'adds charset to existing content-type if not supplied', ->
+        req = build('putObject', Bucket: 'bucket', Key: 'key', Body: 'body', ContentType: 'text/html')
+        expect(req.headers['Content-Type']).toEqual('text/html; charset=UTF-8')
+
+      it 'normalized charset to uppercase', ->
+        req = build('putObject', Bucket: 'bucket', Key: 'key', Body: 'body', ContentType: 'text/html; charset=utf-8')
+        expect(req.headers['Content-Type']).toEqual('text/html; charset=UTF-8')
+
+      it 'does not add charset to non-string data', ->
+        req = build('putObject', Bucket: 'bucket', Key: 'key', Body: new Buffer('body'), ContentType: 'image/png')
+        expect(req.headers['Content-Type']).toEqual('image/png')
+
+    describe 'virtual-hosted vs path-style bucket requests', ->
+
+      describe 'HTTPS', ->
+
+        beforeEach ->
+          s3 = new AWS.S3(sslEnabled: true, region: undefined)
+
+        it 'puts dns-compat bucket names in the hostname', ->
+          req = build('headObject', {Bucket:'bucket-name',Key:'abc'})
+          expect(req.method).toEqual('HEAD')
+          expect(req.endpoint.hostname).toEqual('bucket-name.s3.amazonaws.com')
+          expect(req.path).toEqual('/abc')
+
+        it 'ensures the path contains / at a minimum when moving bucket', ->
+          req = build('listObjects', {Bucket:'bucket-name'})
+          expect(req.endpoint.hostname).toEqual('bucket-name.s3.amazonaws.com')
+          expect(req.path).toEqual('/')
+
+        it 'puts dns-compat bucket names in path if they contain a dot', ->
+          req = build('listObjects', {Bucket:'bucket.name'})
+          expect(req.endpoint.hostname).toEqual('s3.amazonaws.com')
+          expect(req.path).toEqual('/bucket.name')
+
+        it 'puts dns-compat bucket names in path if configured to do so', ->
+          s3 = new AWS.S3(sslEnabled: true, s3ForcePathStyle: true, region: undefined)
+          req = build('listObjects', {Bucket:'bucket-name'})
+          expect(req.endpoint.hostname).toEqual('s3.amazonaws.com')
+          expect(req.path).toEqual('/bucket-name')
+
+        it 'puts dns-incompat bucket names in path', ->
+          req = build('listObjects', {Bucket:'bucket_name'})
+          expect(req.endpoint.hostname).toEqual('s3.amazonaws.com')
+          expect(req.path).toEqual('/bucket_name')
+
+      describe 'HTTP', ->
+
+        beforeEach ->
+          s3 = new AWS.S3(sslEnabled: false, region: undefined)
+
+        it 'puts dns-compat bucket names in the hostname', ->
+          req = build('listObjects', {Bucket:'bucket-name'})
+          expect(req.endpoint.hostname).toEqual('bucket-name.s3.amazonaws.com')
+          expect(req.path).toEqual('/')
+
+        it 'puts dns-compat bucket names in the hostname if they contain a dot', ->
+          req = build('listObjects', {Bucket:'bucket.name'})
+          expect(req.endpoint.hostname).toEqual('bucket.name.s3.amazonaws.com')
+          expect(req.path).toEqual('/')
+
+        it 'puts dns-incompat bucket names in path', ->
+          req = build('listObjects', {Bucket:'bucket_name'})
+          expect(req.endpoint.hostname).toEqual('s3.amazonaws.com')
+          expect(req.path).toEqual('/bucket_name')
+
+  describe 'SSE support', ->
+    beforeEach -> s3 = new AWS.S3
+
+    it 'encodes SSECustomerKey and fills in MD5', ->
+      req = s3.putObject
+        Bucket: 'bucket', Key: 'key', Body: 'data'
+        SSECustomerKey: 'KEY', SSECustomerAlgorithm: 'AES256'
+      req.build()
+      expect(req.httpRequest.headers['x-amz-server-side-encryption-customer-key']).
+        toEqual('S0VZ')
+      expect(req.httpRequest.headers['x-amz-server-side-encryption-customer-key-MD5']).
+        toEqual('TzFsSjRNSnJoM1o2UjFLaWR0NlZjQT09')
+
+    it 'encodes CopySourceSSECustomerKey and fills in MD5', ->
+      req = s3.copyObject
+        Bucket: 'bucket', Key: 'key', CopySource: 'bucket/oldkey', Body: 'data'
+        CopySourceSSECustomerKey: 'KEY', CopySourceSSECustomerAlgorithm: 'AES256'
+      req.build()
+      expect(req.httpRequest.headers['x-amz-copy-source-server-side-encryption-customer-key']).
+        toEqual('S0VZ')
+      expect(req.httpRequest.headers['x-amz-copy-source-server-side-encryption-customer-key-MD5']).
+        toEqual('TzFsSjRNSnJoM1o2UjFLaWR0NlZjQT09')
+
+  describe 'retry behavior', ->
+    it 'retries RequestTimeout errors', ->
+      s3.config.maxRetries = 3
+      helpers.mockHttpResponse 400, {},
+        '<xml><Code>RequestTimeout</Code><Message>message</Message></xml>'
+      s3.putObject (err, data) ->
+        expect(@retryCount).toEqual(s3.config.maxRetries)
+
+  # S3 returns a handful of errors without xml bodies (to match the
+  # http spec) these tests ensure we give meaningful codes/messages for these.
+  describe 'errors with no XML body', ->
+
+    extractError = (statusCode, body) ->
+      req = request('operation')
+      resp = new AWS.Response(req)
+      resp.httpResponse.body = new Buffer(body || '')
+      resp.httpResponse.statusCode = statusCode
+      req.emit('extractError', [resp])
+      resp.error
+
+    it 'handles 304 errors', ->
+      error = extractError(304)
+      expect(error.code).toEqual('NotModified')
+      expect(error.message).toEqual(null)
+
+    it 'handles 400 errors', ->
+      error = extractError(400)
+      expect(error.code).toEqual('BadRequest')
+      expect(error.message).toEqual(null)
+
+    it 'handles 403 errors', ->
+      error = extractError(403)
+      expect(error.code).toEqual('Forbidden')
+      expect(error.message).toEqual(null)
+
+    it 'handles 404 errors', ->
+      error = extractError(404)
+      expect(error.code).toEqual('NotFound')
+      expect(error.message).toEqual(null)
+
+    it 'misc errors not known to return an empty body', ->
+      error = extractError(412) # made up
+      expect(error.code).toEqual(412)
+      expect(error.message).toEqual(null)
+
+    it 'uses canned errors only when the body is empty', ->
+      body = """
+      <xml>
+        <Code>ErrorCode</Code>
+        <Message>ErrorMessage</Message>
+      </xml>
+      """
+      error = extractError(403, body)
+      expect(error.code).toEqual('ErrorCode')
+      expect(error.message).toEqual('ErrorMessage')
+
+  # tests from this point on are "special cases" for specific aws operations
+
+  describe 'getBucketAcl', ->
+    it 'correctly parses the ACL XML document', ->
+      headers = { 'x-amz-request-id' : 'request-id' }
+      body =
+        """
+        <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+          <AccessControlList>
+            <Grant>
+              <Grantee xsi:type="CanonicalUser" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+                <DisplayName>aws-sdk</DisplayName>
+                <ID>id</ID>
+              </Grantee>
+              <Permission>FULL_CONTROL</Permission>
+            </Grant>
+            <Grant>
+              <Grantee xsi:type="Group" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+                <URI>uri</URI>
+              </Grantee>
+              <Permission>READ</Permission>
+            </Grant>
+          </AccessControlList>
+          <Owner>
+            <DisplayName>aws-sdk</DisplayName>
+            <ID>id</ID>
+          </Owner>
+        </AccessControlPolicy>
+        """
+      helpers.mockHttpResponse 200, headers, body
+      s3.getBucketAcl (error, data) ->
+        expect(error).toBe(null)
+        expect(data).toEqual({
+          Owner:
+            DisplayName: 'aws-sdk',
+            ID: 'id'
+          Grants: [
+            {
+              Permission: 'FULL_CONTROL'
+              Grantee:
+                Type: 'CanonicalUser'
+                DisplayName: 'aws-sdk'
+                ID: 'id'
+            },
+            {
+              Permission : 'READ'
+              Grantee:
+                Type: 'Group'
+                URI: 'uri'
+            }
+          ]
+        })
+
+  describe 'putBucketAcl', ->
+    it 'correctly builds the ACL XML document', ->
+      xml =
+        """
+        <AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+          <AccessControlList>
+            <Grant>
+              <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
+                <DisplayName>aws-sdk</DisplayName>
+                <ID>id</ID>
+              </Grantee>
+              <Permission>FULL_CONTROL</Permission>
+            </Grant>
+            <Grant>
+              <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="Group">
+                <URI>uri</URI>
+              </Grantee>
+              <Permission>READ</Permission>
+            </Grant>
+          </AccessControlList>
+          <Owner>
+            <DisplayName>aws-sdk</DisplayName>
+            <ID>id</ID>
+          </Owner>
+        </AccessControlPolicy>
+        """
+      helpers.mockHttpResponse 200, {}, ''
+      params =
+        AccessControlPolicy:
+          Owner:
+            DisplayName: 'aws-sdk',
+            ID: 'id'
+          Grants: [
+            {
+              Permission: 'FULL_CONTROL'
+              Grantee:
+                Type: 'CanonicalUser',
+                DisplayName: 'aws-sdk'
+                ID: 'id'
+            },
+            {
+              Permission : 'READ'
+              Grantee:
+                Type: 'Group',
+                URI: 'uri'
+            }
+          ]
+      s3.putBucketAcl params, (err, data) ->
+        helpers.matchXML(this.request.httpRequest.body, xml)
+
+  describe 'completeMultipartUpload', ->
+
+    it 'returns data when the resp is 200 with valid response', ->
+      headers =
+        'x-amz-id-2': 'Uuag1LuByRx9e6j5Onimru9pO4ZVKnJ2Qz7/C1NPcfTWAtRPfTaOFg=='
+        'x-amz-request-id': '656c76696e6727732072657175657374'
+      body =
+        """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <CompleteMultipartUploadResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+          <Location>http://Example-Bucket.s3.amazonaws.com/Example-Object</Location>
+          <Bucket>Example-Bucket</Bucket>
+          <Key>Example-Object</Key>
+          <ETag>"3858f62230ac3c915f300c664312c11f-9"</ETag>
+        </CompleteMultipartUploadResult>
+        """
+
+      helpers.mockHttpResponse 200, headers, body
+      s3.completeMultipartUpload (error, data) ->
+        expect(error).toBe(null)
+        expect(data).toEqual({
+          Location: 'http://Example-Bucket.s3.amazonaws.com/Example-Object'
+          Bucket: 'Example-Bucket'
+          Key: 'Example-Object'
+          ETag: '"3858f62230ac3c915f300c664312c11f-9"'
+        })
+        expect(this.requestId).toEqual('656c76696e6727732072657175657374')
+
+    it 'returns an error when the resp is 200 with an error xml document', ->
+      body =
+      """
+      <?xml version="1.0" encoding="UTF-8"?>
+      <Error>
+        <Code>InternalError</Code>
+        <Message>We encountered an internal error. Please try again.</Message>
+        <RequestId>656c76696e6727732072657175657374</RequestId>
+        <HostId>Uuag1LuByRx9e6j5Onimru9pO4ZVKnJ2Qz7/C1NPcfTWAtRPfTaOFg==</HostId>
+      </Error>
+      """
+
+      helpers.mockHttpResponse 200, {}, body
+      s3.completeMultipartUpload (error, data) ->
+        expect(error instanceof Error).toBeTruthy()
+        expect(error.code).toEqual('InternalError')
+        expect(error.message).toEqual('We encountered an internal error. Please try again.')
+        expect(error.statusCode).toEqual(200)
+        expect(error.retryable).toEqual(true)
+        expect(data).toEqual(null)
+
+  describe 'getBucketLocation', ->
+
+    it 'returns null for the location constraint when not present', ->
+      body = '<?xml version="1.0" encoding="UTF-8"?>\n<LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/"/>'
+      helpers.mockHttpResponse 200, {}, body
+      s3.getBucketLocation (error, data) ->
+        expect(error).toBe(null)
+        expect(data).toEqual({})
+
+    it 'parses the location constraint from the root xml', ->
+      headers = { 'x-amz-request-id': 'abcxyz' }
+      body = '<?xml version="1.0" encoding="UTF-8"?>\n<LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/">EU</LocationConstraint>'
+      helpers.mockHttpResponse 200, headers, body
+      s3.getBucketLocation (error, data) ->
+        expect(error).toBe(null)
+        expect(data).toEqual(LocationConstraint: 'EU')
+        expect(this.requestId).toEqual('abcxyz')
+
+  describe 'createBucket', ->
+    it 'auto-populates the LocationConstraint based on the region', ->
+      loc = null
+      s3 = new AWS.S3(region:'eu-west-1')
+      s3.makeRequest = (op, params) ->
+        loc = params.CreateBucketConfiguration.LocationConstraint
+      s3.createBucket(Bucket:'name')
+      expect(loc).toEqual('eu-west-1')
+
+    it 'correctly builds the xml', ->
+
+  AWS.util.each AWS.S3.prototype.computableChecksumOperations, (operation) ->
+    describe operation, ->
+      it 'forces Content-MD5 header parameter', ->
+        req = s3[operation](Bucket: 'bucket', ContentMD5: '000').build()
+        hash = AWS.util.crypto.md5(req.httpRequest.body, 'base64')
+        expect(req.httpRequest.headers['Content-MD5']).toEqual(hash)
+
+  describe 'willComputeChecksums', ->
+    willCompute = (operation, opts) ->
+      compute = opts.computeChecksums
+      s3 = new AWS.S3(computeChecksums: compute)
+      req = s3.makeRequest(operation, Bucket: 'example', ContentMD5: opts.hash).build()
+      checksum = req.httpRequest.headers['Content-MD5']
+      if opts.hash != undefined
+        expect(checksum).toEqual(opts.hash)
+      else
+        realChecksum = AWS.util.crypto.md5(req.httpRequest.body, 'base64')
+        expect(checksum).toEqual(realChecksum)
+
+    it 'computes checksums if the operation requires it', ->
+      willCompute 'deleteObjects', computeChecksums: true
+      willCompute 'putBucketCors', computeChecksums: true
+      willCompute 'putBucketLifecycle', computeChecksums: true
+      willCompute 'putBucketTagging', computeChecksums: true
+
+    it 'computes checksums if computeChecksums is off and operation requires it', ->
+      willCompute 'deleteObjects', computeChecksums: false
+      willCompute 'putBucketCors', computeChecksums: false
+      willCompute 'putBucketLifecycle', computeChecksums: false
+      willCompute 'putBucketTagging', computeChecksums: false
+
+    it 'does not compute checksums if computeChecksums is off', ->
+      willCompute 'putObject', computeChecksums: false, hash: null
+
+    it 'does not compute checksums if computeChecksums is on and ContentMD5 is provided', ->
+      willCompute 'putBucketAcl', computeChecksums: true, hash: '000'
+
+    it 'does not compute checksums for Stream objects', ->
+      s3 = new AWS.S3(computeChecksums: true)
+      req = s3.putObject(Bucket: 'example', Key: 'foo', Body: new Stream)
+      expect(req.build(->).httpRequest.headers['Content-MD5']).toEqual(undefined)
+
+    it 'computes checksums if computeChecksums is on and ContentMD5 is not provided',->
+      willCompute 'putBucketAcl', computeChecksums: true
+
+  describe 'getSignedUrl', ->
+    date = null
+    beforeEach ->
+      date = AWS.util.date.getDate
+      AWS.util.date.getDate = -> new Date(0)
+    afterEach ->
+      AWS.util.date.getDate = date
+
+    it 'gets a signed URL for getObject', ->
+      url = s3.getSignedUrl('getObject', Bucket: 'bucket', Key: 'key')
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/key?AWSAccessKeyId=akid&Expires=900&Signature=4mlYnRmz%2BBFEPrgYz5tXcl9Wc4w%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL with Expires time', ->
+      url = s3.getSignedUrl('getObject', Bucket: 'bucket', Key: 'key', Expires: 60)
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/key?AWSAccessKeyId=akid&Expires=60&Signature=kH2pMK%2Fgm7cCZKVG8GHVTRGXKzY%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL with expiration and bound bucket parameters', ->
+      s3 = new AWS.S3(paramValidation: true, region: undefined, params: Bucket: 'bucket')
+      url = s3.getSignedUrl('getObject', Key: 'key', Expires: 60)
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/key?AWSAccessKeyId=akid&Expires=60&Signature=kH2pMK%2Fgm7cCZKVG8GHVTRGXKzY%3D&x-amz-security-token=session')
+
+    it 'generates the right URL with a custom endpoint', ->
+      s3 = new AWS.S3(endpoint: 'https://foo.bar.baz:555/prefix', params: Bucket: 'bucket')
+      url = s3.getSignedUrl('getObject', Key: 'key', Expires: 60)
+      expect(url).toEqual('https://bucket.foo.bar.baz:555/prefix/key?AWSAccessKeyId=akid&Expires=60&Signature=zA6k0cQqDkTZgLamfoYLOd%2Bqfg8%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL with callback', ->
+      url = null
+      runs ->
+        s3.getSignedUrl 'getObject', Bucket: 'bucket', Key: 'key', (err, value) -> url = value
+      waitsFor -> url
+      runs ->
+        expect(url).toEqual('https://bucket.s3.amazonaws.com/key?AWSAccessKeyId=akid&Expires=900&Signature=4mlYnRmz%2BBFEPrgYz5tXcl9Wc4w%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL for putObject with no body', ->
+      url = s3.getSignedUrl('putObject', Bucket: 'bucket', Key: 'key')
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/key?AWSAccessKeyId=akid&Expires=900&Signature=J%2BnWZ0lPUfLV0kio8ONhJmAttGc%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL for putObject with special characters', ->
+      url = s3.getSignedUrl('putObject', Bucket: 'bucket', Key: '!@#$%^&*();\':"{}[],./?`~')
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/%21%40%23%24%25%5E%26%2A%28%29%3B%27%3A%22%7B%7D%5B%5D%2C./%3F%60~?AWSAccessKeyId=akid&Expires=900&Signature=9nEltJACZKsriZqU2cmRel6g8LQ%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL for putObject with a body (and checksum)', ->
+      url = s3.getSignedUrl('putObject', Bucket: 'bucket', Key: 'key', Body: 'body')
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/key?AWSAccessKeyId=akid&Content-MD5=hBotaJrYa9FhFEdFPCLG%2FA%3D%3D&Expires=900&Signature=4ycA2tpHKxfFnNCdqnK1d5BG8gc%3D&x-amz-security-token=session')
+
+    it 'gets a signed URL and appends to existing query parameters', ->
+      url = s3.getSignedUrl('listObjects', Bucket: 'bucket', Prefix: 'prefix')
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/?AWSAccessKeyId=akid&Expires=900&Signature=8W3pwZPfgucCyPNg1MsoYq8h5zw%3D&prefix=prefix&x-amz-security-token=session')
+
+    it 'gets a signed URL for getObject using SigV4', ->
+      s3 = new AWS.S3(signatureVersion: 'v4', region: undefined)
+      url = s3.getSignedUrl('getObject', Bucket: 'bucket', Key: 'object')
+      expect(url).toEqual('https://bucket.s3.amazonaws.com/object?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=akid%2F19700101%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=19700101T000000Z&X-Amz-Expires=900&X-Amz-Security-Token=session&X-Amz-Signature=05ae40d2d22c93549a1de0686232ff56baf556876ec497d0d8349431f98b8dfe&X-Amz-SignedHeaders=host')
+
+    it 'errors when expiry time is greater than a week out on SigV4', ->
+      err = null; data = null
+      s3 = new AWS.S3(signatureVersion: 'v4', region: undefined)
+      params = Bucket: 'bucket', Key: 'object', Expires: 60 * 60 * 24 * 7 + 120
+      error = 'Presigning does not support expiry time greater than a week with SigV4 signing.'
+      runs ->
+        s3.getSignedUrl 'getObject', params, (e, d) -> data = d; err = e
+      waitsFor -> err || data
+      runs ->
+        expect(err).not.toEqual(null)
+        expect(err.message).toEqual(error)
+        #expect(-> s3.getSignedUrl('getObject', params)).toThrow(error) # sync mode

package/test/services/simpledb.spec.coffee

@@ -0,0 +1,12 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.SimpleDB', ->
+  describe 'setEndpoint', ->
+    it 'uses global endpoint if region is us-east-1', ->
+      service = new AWS.SimpleDB(region: 'us-east-1')
+      expect(service.endpoint.host).toEqual('sdb.amazonaws.com')
+
+    it 'uses normal setEndpoint functionality if region is not us-east-1', ->
+      service = new AWS.SimpleDB(region: 'us-west-2')
+      expect(service.endpoint.host).toEqual('sdb.us-west-2.amazonaws.com')

package/test/services/sqs.spec.coffee

@@ -0,0 +1,130 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.SQS', ->
+  sqs = null
+  beforeEach ->
+    sqs = new AWS.SQS params: QueueUrl: 'http://url'
+
+  checksumValidate = (operation, input, response, shouldPass, cb) ->
+    output = null
+    helpers.mockHttpResponse 200, {}, response
+    runs ->
+      sqs[operation](input, (e, d) -> output = error: e, data: d)
+    waitsFor -> output
+    runs ->
+      if shouldPass
+        expect(output.error).toEqual(null)
+      else
+        expect(output.error).not.toEqual(null)
+      if cb
+        cb(output.error, output.data)
+
+  describe 'buildEndpoint', ->
+    it 'should detect correct region from QueueUrl', ->
+      sqs = new AWS.SQS
+        computeChecksums: false
+        params: QueueUrl: 'http://sqs.region-1.amazonaws.com/queue'
+      helpers.mockHttpResponse 200, {}, ''
+      req = sqs.sendMessage(MessageBody: 'foo')
+      req.build()
+      expect(req.httpRequest.region).toEqual('region-1')
+
+  describe 'sendMessage', ->
+    input = MessageBody: 'foo'
+    md5 = 'acbd18db4cc2f85cedef654fccc4a4d8'
+    payload = (md5) ->
+      """
+      <SendMessageResponse><SendMessageResult>
+        <MD5OfMessageBody>#{md5}</MD5OfMessageBody>
+        <MessageId>MSGID</MessageId>
+      </SendMessageResult></SendMessageResponse>
+      """
+
+    it 'correctly validates MD5 of message input', ->
+      checksumValidate 'sendMessage', input, payload(md5), true, (err, data) ->
+        expect(data.MD5OfMessageBody).toEqual(md5)
+
+    it 'raises InvalidChecksum if MD5 does not match message input', ->
+      checksumValidate 'sendMessage', input, payload('000'), false, (err) ->
+        expect(err.message).toMatch('Got "000", expecting "acbd18db4cc2f85cedef654fccc4a4d8"')
+        expect(err.messageIds).toEqual(['MSGID'])
+
+    it 'ignores checksum errors if computeChecksums is false', ->
+      sqs.config.computeChecksums = false
+      checksumValidate 'sendMessage', input, payload('000'), true
+
+  describe 'sendMessageBatch', ->
+    input = Entries: [
+      { Id: 'a', MessageBody: 'foo' },
+      { Id: 'b', MessageBody: 'bar' },
+      { Id: 'c', MessageBody: 'bar' }
+    ]
+    md5foo = 'acbd18db4cc2f85cedef654fccc4a4d8'
+    md5bar = '37b51d194a7513e45b56f6524f2d51f2'
+    payload = (md5a, md5b, md5c) ->
+      """
+      <SendMessageBatchResponse><SendMessageBatchResult>
+        <SendMessageBatchResultEntry>
+          <Id>a</Id>
+          <MessageId>MSGID1</MessageId>
+          <MD5OfMessageBody>#{md5a}</MD5OfMessageBody>
+        </SendMessageBatchResultEntry>
+        <SendMessageBatchResultEntry>
+          <Id>b</Id>
+          <MessageId>MSGID2</MessageId>
+          <MD5OfMessageBody>#{md5b}</MD5OfMessageBody>
+        </SendMessageBatchResultEntry>
+        <SendMessageBatchResultEntry>
+          <Id>c</Id>
+          <MessageId>MSGID3</MessageId>
+          <MD5OfMessageBody>#{md5c}</MD5OfMessageBody>
+        </SendMessageBatchResultEntry>
+      </SendMessageBatchResult></SendMessageBatchResponse>
+      """
+
+    it 'correctly validates MD5 of operation', ->
+      output = payload(md5foo, md5bar, md5bar)
+      checksumValidate 'sendMessageBatch', input, output, true, (err, data) ->
+        expect(data.Successful[0].MD5OfMessageBody).toEqual(md5foo)
+        expect(data.Successful[1].MD5OfMessageBody).toEqual(md5bar)
+        expect(data.Successful[2].MD5OfMessageBody).toEqual(md5bar)
+
+    it 'raises InvalidChecksum with relevent message IDs', ->
+      output = payload('000', md5bar, '000')
+      checksumValidate 'sendMessageBatch', input, output, false, (err, data) ->
+        expect(err.message).toMatch('Invalid messages: a, c')
+        expect(err.messageIds).toEqual(['MSGID1', 'MSGID3'])
+
+    it 'ignores checksum errors if computeChecksums is false', ->
+      output = payload(md5foo, '000', md5bar)
+      sqs.config.computeChecksums = false
+      checksumValidate 'sendMessageBatch', input, output, true
+
+  describe 'receiveMessage', ->
+    md5 = 'acbd18db4cc2f85cedef654fccc4a4d8'
+    payload = (body, md5, id) ->
+      """
+      <ReceiveMessageResponse><ReceiveMessageResult><Message>
+        <Body>#{body}</Body>
+        <MD5OfBody>#{md5}</MD5OfBody>
+        <MessageId>#{id}</MessageId>
+      </Message></ReceiveMessageResult></ReceiveMessageResponse>
+      """
+
+    it 'correctly validates MD5 of operation', ->
+      output = payload('foo', md5, 'MSGID')
+      checksumValidate 'receiveMessage', {}, output, true, (err, data) ->
+        expect(data.Messages[0].MD5OfBody).toEqual(md5)
+
+    it 'raises InvalidChecksum with relevent message IDs', ->
+      output = payload('foo', '000', 'MSGID')
+      checksumValidate 'receiveMessage', {}, output, false, (err, data) ->
+        expect(err.message).toMatch('Invalid messages: MSGID')
+        expect(err.messageIds).toEqual(['MSGID'])
+
+    it 'ignores checksum errors if computeChecksums is false', ->
+      output = payload('foo', '000', 'MSGID')
+      sqs.config.computeChecksums = false
+      checksumValidate 'receiveMessage', {}, output, true, (err, data) ->
+        expect(data.Messages[0].MD5OfBody).not.toEqual(md5)