aws-sdk 2.0.1 → 2.0.5

package/test/service.spec.coffee

@@ -0,0 +1,230 @@
+helpers = require('./helpers')
+AWS = helpers.AWS
+MockService = helpers.MockService
+
+describe 'AWS.Service', ->
+
+  config = null; service = null
+  retryableError = (error, result) ->
+    expect(service.retryableError(error)).toEqual(result)
+
+  beforeEach ->
+    config = new AWS.Config()
+    service = new AWS.Service(config)
+
+  describe 'apiVersions', ->
+    it 'should set apiVersions property', ->
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      expect(CustomService.apiVersions).toEqual(['1999-05-05', '2001-01-01'])
+
+  describe 'constructor', ->
+    it 'should use AWS.config copy if no config is provided', ->
+      service = new AWS.Service()
+      expect(service.config).not.toBe(AWS.config)
+      expect(service.config.sslEnabled).toEqual(true)
+
+    it 'should merge custom options on top of global defaults if config provided', ->
+      service = new AWS.Service(maxRetries: 5)
+      expect(service.config.sslEnabled).toEqual(true)
+      expect(service.config.maxRetries).toEqual(5)
+
+    it 'merges credential data into config', ->
+      service = new AWS.Service(accessKeyId: 'foo', secretAccessKey: 'bar')
+      expect(service.config.credentials.accessKeyId).toEqual('foo')
+      expect(service.config.credentials.secretAccessKey).toEqual('bar')
+
+    it 'should allow AWS.config to be object literal', ->
+      cfg = AWS.config
+      AWS.config = maxRetries: 20
+      service = new AWS.Service({})
+      expect(service.config.maxRetries).toEqual(20)
+      expect(service.config.sslEnabled).toEqual(true)
+      AWS.config = cfg
+
+    it 'tries to construct service with latest API version', ->
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-2001-01-01"
+      expect(-> new CustomService()).toThrow(errmsg)
+
+    it 'tries to construct service with exact API version match', ->
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-1999-05-05"
+      expect(-> new CustomService(apiVersion: '1999-05-05')).toThrow(errmsg)
+
+
+    it 'skips any API versions with a * and uses next (future) service', ->
+      CustomService = AWS.Service.defineService('custom', ['1998-01-01', '1999-05-05*', '2001-01-01'])
+      errmsg = "Could not find API configuration custom-2001-01-01"
+      expect(-> new CustomService(apiVersion: '2000-01-01')).toThrow(errmsg)
+
+    it 'skips multiple API versions with a * and uses next (future) service', ->
+      CustomService = AWS.Service.defineService('custom', ['1998-01-01', '1999-05-05*', '1999-07-07*', '2001-01-01'])
+      errmsg = "Could not find API configuration custom-2001-01-01"
+      expect(-> new CustomService(apiVersion: '1999-05-05')).toThrow(errmsg)
+
+    it 'tries to construct service with fuzzy API version match', ->
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-1999-05-05"
+      expect(-> new CustomService(apiVersion: '2000-01-01')).toThrow(errmsg)
+
+    it 'uses global apiVersion value when constructing versioned services', ->
+      AWS.config.apiVersion = '2002-03-04'
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-2001-01-01"
+      expect(-> new CustomService).toThrow(errmsg)
+      AWS.config.apiVersion = null
+
+    it 'uses global apiVersions value when constructing versioned services', ->
+      AWS.config.apiVersions = {custom: '2002-03-04'}
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-2001-01-01"
+      expect(-> new CustomService).toThrow(errmsg)
+      AWS.config.apiVersions = {}
+
+    it 'uses service specific apiVersions before apiVersion', ->
+      AWS.config.apiVersions = {custom: '2000-01-01'}
+      AWS.config.apiVersion = '2002-03-04'
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-1999-05-05"
+      expect(-> new CustomService).toThrow(errmsg)
+      AWS.config.apiVersion = null
+      AWS.config.apiVersions = {}
+
+    it 'tries to construct service with fuzzy API version match', ->
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find API configuration custom-1999-05-05"
+      expect(-> new CustomService(apiVersion: '2000-01-01')).toThrow(errmsg)
+
+    it 'fails if apiVersion matches nothing', ->
+      CustomService = AWS.Service.defineService('custom', ['2001-01-01', '1999-05-05'])
+      errmsg = "Could not find custom API to satisfy version constraint `1998-01-01'"
+      expect(-> new CustomService(apiVersion: '1998-01-01')).toThrow(errmsg)
+
+    it 'allows construction of services from one-off apiConfig properties', ->
+      service = new AWS.Service apiConfig:
+        operations:
+          operationName: input: {}, output: {}
+
+      expect(typeof service.operationName).toEqual('function')
+      expect(service.operationName() instanceof AWS.Request).toEqual(true)
+
+    it 'interpolates endpoint when reading from configuration', ->
+      service = new MockService(endpoint: '{scheme}://{service}.{region}.domain.tld')
+      expect(service.config.endpoint).toEqual('https://mockservice.mock-region.domain.tld')
+      service = new MockService(sslEnabled: false, endpoint: '{scheme}://{service}.{region}.domain.tld')
+      expect(service.config.endpoint).toEqual('http://mockservice.mock-region.domain.tld')
+
+  describe 'setEndpoint', ->
+    FooService = null
+
+    beforeEach ->
+      FooService = AWS.util.inherit AWS.Service, api:
+        endpointPrefix: 'fooservice'
+
+    it 'uses specified endpoint if provided', ->
+      service = new FooService()
+      service.setEndpoint('notfooservice.amazonaws.com')
+      expect(service.endpoint.host).toEqual('notfooservice.amazonaws.com')
+
+  describe 'makeRequest', ->
+
+    it 'it treats params as an optinal parameter', ->
+      helpers.mockHttpResponse(200, {}, ['FOO', 'BAR'])
+      service = new MockService()
+      service.makeRequest 'operationName', (err, data) ->
+        expect(data).toEqual('FOOBAR')
+
+    it 'yields data to the callback', ->
+      helpers.mockHttpResponse(200, {}, ['FOO', 'BAR'])
+      service = new MockService()
+      req = service.makeRequest 'operation', (err, data) ->
+        expect(err).toEqual(null)
+        expect(data).toEqual('FOOBAR')
+
+    it 'yields service errors to the callback', ->
+      helpers.mockHttpResponse(500, {}, ['ServiceError'])
+      service = new MockService(maxRetries: 0)
+      req = service.makeRequest 'operation', {}, (err, data) ->
+        expect(err.code).toEqual('ServiceError')
+        expect(err.message).toEqual(null)
+        expect(err.statusCode).toEqual(500)
+        expect(err.retryable).toEqual(true)
+        expect(data).toEqual(null)
+
+    it 'yields network errors to the callback', ->
+      error = { code: 'NetworkingError' }
+      helpers.mockHttpResponse(error)
+      service = new MockService(maxRetries: 0)
+      req = service.makeRequest 'operation', {}, (err, data) ->
+        expect(err).toEqual(error)
+        expect(data).toEqual(null)
+
+    it 'does not send the request if a callback function is omitted', ->
+      helpers.mockHttpResponse(200, {}, ['FOO', 'BAR'])
+      httpClient = AWS.HttpClient.getInstance()
+      spyOn(httpClient, 'handleRequest')
+      new MockService().makeRequest('operation')
+      expect(httpClient.handleRequest).not.toHaveBeenCalled()
+
+    it 'allows parameter validation to be disabled in config', ->
+      helpers.mockHttpResponse(200, {}, ['FOO', 'BAR'])
+      service = new MockService(paramValidation: false)
+      req = service.makeRequest 'operation', {}, (err, data) ->
+        expect(err).toEqual(null)
+        expect(data).toEqual('FOOBAR')
+
+    describe 'bound parameters', ->
+      it 'accepts toplevel bound parameters on the service', ->
+        service = new AWS.S3(params: {Bucket: 'bucket', Key: 'key'})
+        req = service.makeRequest 'getObject'
+        expect(req.params).toEqual(Bucket: 'bucket', Key: 'key')
+
+      it 'ignores bound parameters not in input members', ->
+        service = new AWS.S3(params: {Bucket: 'bucket', Key: 'key'})
+        req = service.makeRequest 'listObjects'
+        expect(req.params).toEqual(Bucket: 'bucket')
+
+      it 'can override bound parameters', ->
+        service = new AWS.S3(params: {Bucket: 'bucket', Key: 'key'})
+        params = Bucket: 'notBucket'
+
+        req = service.makeRequest('listObjects', params)
+        expect(params).not.toBe(req.params)
+        expect(req.params).toEqual(Bucket: 'notBucket')
+
+    describe 'global events', ->
+      it 'adds AWS.events listeners to requests', ->
+        helpers.mockHttpResponse(200, {}, ['FOO', 'BAR'])
+
+        event = jasmine.createSpy()
+        AWS.events.on('complete', event)
+
+        new MockService().makeRequest('operation').send()
+        expect(event).toHaveBeenCalled()
+
+  describe 'retryableError', ->
+
+    it 'should retry on throttle error', ->
+      retryableError({code: 'ProvisionedThroughputExceededException', statusCode:400}, true)
+
+    it 'should retry on expired credentials error', ->
+      retryableError({code: 'ExpiredTokenException', statusCode:400}, true)
+
+    it 'should retry on 500 or above regardless of error', ->
+      retryableError({code: 'Error', statusCode:500 }, true)
+      retryableError({code: 'RandomError', statusCode:505 }, true)
+
+    it 'should not retry when error is < 500 level status code', ->
+      retryableError({code: 'Error', statusCode:200 }, false)
+      retryableError({code: 'Error', statusCode:302 }, false)
+      retryableError({code: 'Error', statusCode:404 }, false)
+
+  describe 'numRetries', ->
+    it 'should use config max retry value if defined', ->
+      service.config.maxRetries = 30
+      expect(service.numRetries()).toEqual(30)
+
+    it 'should use defaultRetries defined on object if undefined on config', ->
+      service.defaultRetryCount = 13
+      service.config.maxRetries = undefined
+      expect(service.numRetries()).toEqual(13)

package/test/services/cloudfront.spec.coffee

@@ -0,0 +1,44 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.CloudFront', ->
+
+  cf = null
+  beforeEach ->
+    cf = new AWS.CloudFront()
+
+  describe 'signing', ->
+    it 'signs with us-east-1 region', ->
+      helpers.mockHttpResponse 200, {}, ''
+      cf.listDistributions ->
+        auth = @request.httpRequest.headers['Authorization']
+        expect(auth).toMatch(/\/us-east-1\/cloudfront\/aws4_request/)
+
+  describe 'createInvalidation', ->
+    it 'correctly builds the request', ->
+      helpers.mockHttpResponse 200, {}, ''
+      api = cf.api.apiVersion
+      xml =
+        """
+        <InvalidationBatch xmlns="http://cloudfront.amazonaws.com/doc/#{api}/">
+          <Paths>
+            <Quantity>2</Quantity>
+            <Items>
+              <Path>path1</Path>
+              <Path>path2</Path>
+            </Items>
+          </Paths>
+          <CallerReference>abc</CallerReference>
+        </InvalidationBatch>
+        """
+      params =
+        DistributionId: 'ID'
+        InvalidationBatch:
+          Paths:
+            Quantity: 2
+            Items: ['path1', 'path2']
+          CallerReference: 'abc'
+      cf.createInvalidation params, (err, data) ->
+        req = this.request.httpRequest
+        expect(req.path).toEqual("/#{api}/distribution/ID/invalidation")
+        helpers.matchXML(req.body, xml)

package/test/services/cloudsearchdomain.spec.coffee

@@ -0,0 +1,23 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.CloudSearchDomain', ->
+  describe 'constructor', ->
+    it 'fails if there is no provided endpoint', ->
+      err = {}
+      try
+        new AWS.CloudSearchDomain
+      catch e
+        err = e
+      expect(err.name).toEqual('InvalidEndpoint')
+
+    it 'fails if the endpoint is a template', ->
+      err = {}
+      try
+        new AWS.CloudSearchDomain endpoint: '{region}.domain'
+      catch e
+        err = e
+      expect(err.name).toEqual('InvalidEndpoint')
+
+    it 'allows explicit endpoint', ->
+      expect(-> new AWS.CloudSearchDomain endpoint: 'host.domain').not.toThrow()

package/test/services/dynamodb.spec.coffee

@@ -0,0 +1,32 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.DynamoDB', ->
+
+  configure = (options) ->
+    new AWS.Config(options)
+
+  ddb = (options) ->
+    new AWS.DynamoDB(configure(options))
+
+  describe 'config', ->
+
+    it 'returns the configuration object it was constructed with', ->
+      config = configure(endpoint: 'localhost')
+      dynamo = new AWS.DynamoDB(config)
+      expect(dynamo.config).toEqual(config)
+
+  describe 'numRetries', ->
+
+    it 'defaults to 10', ->
+      expect(ddb().numRetries()).toEqual(10)
+
+    it 'can be overridden in the config', ->
+      expect(ddb({ maxRetries: 2 }).numRetries()).toEqual(2)
+
+  describe 'retryDelays', ->
+
+    it 'has a custom backoff function', ->
+      delays = [ 0, 50, 100, 200, 400, 800, 1600, 3200, 6400, 12800 ]
+      expect(ddb().retryDelays()).toEqual(delays)
+

package/test/services/ec2.spec.coffee

@@ -0,0 +1,78 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.EC2', ->
+
+  ec2 = new AWS.EC2()
+
+  describe 'proxy support', ->
+    it 'always sets Host header to correct endpoint', ->
+      helpers.mockHttpResponse 200, {}, ''
+      ec2 = new AWS.EC2(httpOptions: proxy: 'http://__INVALID_HOSTNAME__:9999')
+      ec2.makeRequest 'describeInstances', ->
+        expect(@request.httpRequest.headers.Host).
+          toEqual('ec2.mock-region.amazonaws.com')
+
+  describe 'copySnapshot', ->
+    it 'generates PresignedUrl and DestinationRegion parameters', ->
+      spyOn(AWS.util.date, 'getDate').andReturn(new Date(0))
+      helpers.mockHttpResponse 200, {}, ''
+      params = SourceRegion: 'src-region', SourceSnapshotId: 'snap-123456789'
+      ec2.copySnapshot params, ->
+        parts = @request.httpRequest.body.split('&').sort()
+        [
+          'AWSAccessKeyId=akid',
+          'Action=CopySnapshot',
+          'DestinationRegion=mock-region',
+          'PresignedUrl=https%3A%2F%2Fec2.src-region.amazonaws.com%2F%3F' +
+            "Action%3DCopySnapshot%26DestinationRegion%3Dmock-region%26SourceRegion%3Dsrc-region" +
+            "%26SourceSnapshotId%3Dsnap-123456789%26Version%3D#{ec2.api.apiVersion}" +
+            "%26X-Amz-Algorithm%3DAWS4-HMAC-SHA256%26X-Amz-Credential%3Dakid%252F19700101" +
+            "%252Fsrc-region%252Fec2%252Faws4_request%26X-Amz-Date%3D19700101T000000Z" +
+            "%26X-Amz-Expires%3D3600%26X-Amz-Security-Token%3Dsession" +
+            "%26X-Amz-Signature%3D014459362191e87b3b175e1e16d007c0c9aaa1fdb2743f8cebdfd8dea0fb0cc2" +
+            "%26X-Amz-SignedHeaders%3Dhost",
+          'SourceRegion=src-region',
+          'SourceSnapshotId=snap-123456789'
+        ].forEach (i) ->
+          expect(parts).toContain(i)
+
+  describe 'parseResponse', ->
+    body = ''
+    parse = (callback) ->
+      helpers.mockHttpResponse 400, {}, body
+      ec2.makeRequest 'describeInstances', (error, data) ->
+        callback.call(this, error, data)
+
+    describe 'with error', ->
+      beforeEach ->
+        body =
+          """
+          <Response>
+            <Errors>
+              <Error>
+                <Code>InvalidInstanceID.Malformed</Code>
+                <Message>Invalid id: "i-12345678"</Message>
+              </Error>
+            </Errors>
+            <RequestID>ab123mno-6432-dceb-asdf-123mno543123</RequestID>
+          </Response>
+          """
+
+      it 'extracts the error code', ->
+        parse (error, data) ->
+          expect(error.code).toEqual('InvalidInstanceID.Malformed')
+          expect(data).toEqual(null)
+
+      it 'extracts the error message', ->
+        parse (error, data) ->
+          expect(error.message).toEqual('Invalid id: "i-12345678"')
+          expect(data).toEqual(null)
+
+      it 'returns an empty error when the body is blank', ->
+        body = ''
+        parse (error, data) ->
+          expect(error.code).toEqual(400)
+          expect(error.message).toEqual(null)
+          expect(data).toEqual(null)
+

package/test/services/elastictranscoder.spec.coffee

@@ -0,0 +1,43 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.ElasticTranscoder', ->
+
+  et = null
+  beforeEach ->
+    et = new AWS.ElasticTranscoder()
+
+  describe 'error handling', ->
+    it 'should generate the correct error name', ->
+      helpers.mockHttpResponse 400, {'x-amzn-errortype': 'ErrorName:'}, ''
+      et.listPipelines (err, data) ->
+        expect(err.code).toEqual('ErrorName')
+
+    it 'generates generic error name if header is not present', ->
+      helpers.mockHttpResponse 400, {}, ''
+      et.listPipelines (err, data) ->
+        expect(err.code).toEqual('UnknownError')
+
+  describe 'cancelJob', ->
+    it 'omits the body', ->
+      helpers.mockHttpResponse 200, {}, ''
+      params = { Id: 'job-id' }
+      et.cancelJob { Id: 'job-id' }, (err, data) ->
+        req = this.request.httpRequest
+        expect(req.path).toEqual('/2012-09-25/jobs/job-id')
+        expect(req.body).toEqual('{}')
+
+  describe 'updatePipelineNotifications', ->
+    it 'only populates the body with non-uri and non-header params', ->
+      helpers.mockHttpResponse 200, {}, ''
+      params =
+        Id: 'pipeline-id'
+        Notifications:
+          Progressing: 'arn1'
+          Completed: 'arn2'
+          Warning: 'arn3'
+          Error: 'arn4'
+      et.updatePipelineNotifications params, (err, data) ->
+        req = this.request.httpRequest
+        expect(req.path).toEqual('/2012-09-25/pipelines/pipeline-id/notifications')
+        expect(req.body).toEqual('{"Notifications":{"Progressing":"arn1","Completed":"arn2","Warning":"arn3","Error":"arn4"}}')

package/test/services/glacier.spec.coffee

@@ -0,0 +1,61 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+Buffer = AWS.util.Buffer
+
+if AWS.util.isNode()
+  describe 'AWS.Glacier', ->
+
+    glacier = null
+    beforeEach ->
+      glacier = new AWS.Glacier()
+
+    describe 'building requests', ->
+      it 'sets accountId to "-" if not set', ->
+        req = glacier.listVaults()
+        req.emit('validate', [req])
+        req.emit('build', [req])
+        expect(req.httpRequest.path).toEqual('/-/vaults')
+
+      it 'will not override accountId if set', ->
+        req = glacier.listVaults(accountId: 'ABC123')
+        req.emit('validate', [req])
+        req.emit('build', [req])
+        expect(req.httpRequest.path).toEqual('/ABC123/vaults')
+
+    describe 'computeChecksums', ->
+      it 'returns correct linear and tree hash for buffer data', ->
+        # compute a 5.5 megabyte chunk of data filled with '0' string (0 byte)
+        # expected values taken from AWS SDK for Ruby
+        data = new Buffer(1024 * 1024 * 5.5)
+        data.fill('0')
+
+        expected =
+          linearHash: '68aff0c5a91aa0491752bfb96e3fef33eb74953804f6a2f7b708d5bcefa8ff6b',
+          treeHash: '154e26c78fd74d0c2c9b3cc4644191619dc4f2cd539ae2a74d5fd07957a3ee6a'
+
+        expect(glacier.computeChecksums(data)).toEqual(expected)
+
+    describe 'initiateJob', ->
+      it 'correctly builds the request', ->
+        helpers.mockHttpResponse 200, {}, ''
+        params =
+          vaultName: 'vault-name'
+          jobParameters:
+            Format: 'foo'
+            Type: 'bar'
+        glacier.initiateJob params, (err, data) ->
+          req = this.request.httpRequest
+          expect(req.path).toEqual('/-/vaults/vault-name/jobs')
+          expect(req.body).toEqual('{"Format":"foo","Type":"bar"}')
+
+    describe 'uploadArchive', ->
+      it 'passes the body along', ->
+        helpers.mockHttpResponse 200, {}, ''
+        params =
+          vaultName: 'vault-name'
+          body: 'abc'
+        glacier.uploadArchive params, (err, data) ->
+          req = this.request.httpRequest
+          expect(req.method).toEqual('POST')
+          expect(req.path).toEqual('/-/vaults/vault-name/archives')
+          expect(req.body).toEqual('abc')

package/test/services/rds.spec.coffee

@@ -0,0 +1,38 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.RDS', ->
+  describe 'createDBSecurityGroup', ->
+    it 'properly parses XML response', ->
+      rds = new AWS.RDS()
+      body =
+        """
+        <CreateDBSecurityGroupResponse xmlns="http://rds.amazonaws.com/doc/2013-09-09/">
+          <CreateDBSecurityGroupResult>
+            <DBSecurityGroup>
+              <EC2SecurityGroups/>
+              <DBSecurityGroupDescription>foo</DBSecurityGroupDescription>
+              <IPRanges/>
+              <OwnerId>1234567890</OwnerId>
+              <DBSecurityGroupName>foo</DBSecurityGroupName>
+            </DBSecurityGroup>
+          </CreateDBSecurityGroupResult>
+          <ResponseMetadata>
+            <RequestId>1234567890</RequestId>
+          </ResponseMetadata>
+        </CreateDBSecurityGroupResponse>
+        """
+      helpers.mockHttpResponse 200, {}, body
+      params = DBSecurityGroupName:'foo', DBSecurityGroupDescription:'foo'
+      rds.createDBSecurityGroup params, (error, data) ->
+        expect(error).toBe(null)
+        expect(this.requestId).toEqual('1234567890')
+        expect(data).toEqual
+          DBSecurityGroup:
+            DBSecurityGroupDescription: 'foo'
+            DBSecurityGroupName: 'foo'
+            EC2SecurityGroups: []
+            IPRanges: []
+            OwnerId: '1234567890'
+          ResponseMetadata:
+            RequestId: '1234567890'

package/test/services/route53.spec.coffee

@@ -0,0 +1,77 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.Route53', ->
+
+  service = null
+  api = null
+  beforeEach ->
+    service = new AWS.Route53()
+    api = service.api.apiVersion
+
+  describe 'setEndpoint', ->
+    it 'always enables SSL if no endpoint is set', ->
+      service = new AWS.Route53(sslEnabled: false)
+      expect(service.endpoint.protocol).toEqual('https:')
+
+    it 'allows overriding SSL if custom endpoint is set', ->
+      service = new AWS.Route53(endpoint: 'http://example.com')
+      expect(service.endpoint.protocol).toEqual('http:')
+
+  describe 'building requests', ->
+    service = new AWS.Route53
+
+    it 'should fix hosted zone ID on input', ->
+      req = service.getHostedZone(Id: '/hostedzone/ABCDEFG')
+      req.emit('build', [req])
+      expect(req.httpRequest.path).toMatch('/hostedzone/ABCDEFG$')
+
+    it 'should fix health check ID on input', ->
+      req = service.getHealthCheck(HealthCheckId: '/healthcheck/ABCDEFG')
+      req.emit('build', [req])
+      expect(req.httpRequest.path).toMatch('/healthcheck/ABCDEFG$')
+
+  describe 'changeResourceRecordSets', ->
+    it 'correctly builds the XML document', ->
+      xml =
+        """
+        <ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/#{api}/">
+          <ChangeBatch>
+            <Comment>comment</Comment>
+            <Changes>
+              <Change>
+                <Action>CREATE</Action>
+                <ResourceRecordSet>
+                  <Name>name</Name>
+                  <Type>type</Type>
+                  <ResourceRecords>
+                    <ResourceRecord>
+                      <Value>foo.com</Value>
+                    </ResourceRecord>
+                  </ResourceRecords>
+                </ResourceRecordSet>
+              </Change>
+            </Changes>
+          </ChangeBatch>
+        </ChangeResourceRecordSetsRequest>
+        """
+      helpers.mockHttpResponse 200, {}, ''
+      # params purposefully ordered differently than api to test ordering of
+      # xml elements
+      params =
+        HostedZoneId: 'zone-id'
+        ChangeBatch:
+          Changes: [
+            {
+              ResourceRecordSet:
+                Name: 'name'
+                Type: 'type'
+                ResourceRecords: [
+                  { Value: 'foo.com' }
+                ]
+              Action: 'CREATE',
+            }
+          ]
+          Comment: 'comment'
+      service.changeResourceRecordSets params, (err, data) ->
+        helpers.matchXML(this.request.httpRequest.body, xml)