aws-sdk 2.0.1 → 2.0.5

package/test/protocol/query.spec.coffee

@@ -0,0 +1,191 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+Buffer = AWS.util.Buffer
+
+svc = AWS.Protocol.Query
+describe 'AWS.Protocol.Query', ->
+  service = null
+  request = null
+  response = null
+
+  beforeEach ->
+    service = new AWS.Service apiConfig:
+      metadata:
+        endpointPrefix: 'mockservice'
+        apiVersion: '2012-01-01'
+      operations:
+        OperationName:
+          name: 'OperationName'
+          input:
+            members:
+              Input:
+                type: 'string'
+              List:
+                type: 'list'
+                members: {}
+          output:
+            type: 'structure'
+            members:
+              Data:
+                type: 'structure'
+                members:
+                  Name:
+                    type: 'string'
+                  Count:
+                    type: 'float'
+
+    request = new AWS.Request(service, 'operationName')
+    response = request.response
+
+  describe 'buildRequest', ->
+    stringify = (params) -> AWS.util.queryParamsToString(params)
+
+    buildRequest = (input, list) ->
+      if input == undefined
+        input = 'foo+bar: yuck/baz=~'
+      request.params = Input: input, List: list
+      svc.buildRequest(request)
+
+    it 'should use POST method requests', ->
+      buildRequest()
+      expect(request.httpRequest.method).toEqual('POST')
+
+    it 'should perform all operations on root (/)', ->
+      buildRequest()
+      expect(request.httpRequest.path).toEqual('/')
+
+    it 'allows mounted path to be specified', ->
+      service.setEndpoint('https://localhost/foo/bar')
+      request = new AWS.Request(service, 'operationName')
+      buildRequest()
+      expect(request.httpRequest.path).toEqual('/foo/bar')
+
+    it 'should set Content-Type header', ->
+      buildRequest()
+      expect(request.httpRequest.headers['Content-Type']).
+        toEqual('application/x-www-form-urlencoded; charset=utf-8')
+
+    it 'should add the api version param', ->
+      buildRequest()
+      expect(stringify(request.httpRequest.params)).
+        toMatch(/Version=2012-01-01/)
+
+    it 'should add the operation name as Action', ->
+      buildRequest()
+      expect(stringify(request.httpRequest.params)).
+        toMatch(/Action=OperationName/)
+
+    it 'should uri encode params properly', ->
+      buildRequest()
+      expect(stringify(request.httpRequest.params)).
+        toMatch(/foo%2Bbar%3A%20yuck%2Fbaz%3D~/);
+
+    it 'encodes empty string values properly', ->
+      buildRequest('')
+      expect(stringify(request.httpRequest.params)).
+        toMatch(/Input=($|&)/);
+
+    it 'serializes empty lists', ->
+      buildRequest(null, [])
+      expect(stringify(request.httpRequest.params)).toMatch(/[?&]List(&|$)/)
+
+  describe 'extractError', ->
+    extractError = (body) ->
+      if body == undefined
+        body = """
+        <Error>
+          <Code>InvalidArgument</Code>
+          <Message>Provided param is bad</Message>
+        </Error>
+        """
+      response.httpResponse.statusCode = 400
+      response.httpResponse.body = new Buffer(body)
+      svc.extractError(response)
+
+    it 'extracts error from UnknownOperationException', ->
+      extractError '<UnknownOperationException/>'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.code).toEqual('UnknownOperation')
+      expect(response.error.message).toEqual('Unknown operation operationName')
+      expect(response.data).toEqual(null)
+
+    it 'extracts the error code and message', ->
+      extractError()
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.code).toEqual('InvalidArgument')
+      expect(response.error.message).toEqual('Provided param is bad')
+      expect(response.data).toEqual(null)
+
+    it 'returns an empty error when the body is blank', ->
+      extractError('')
+      expect(response.error.code).toEqual(400)
+      expect(response.error.message).toEqual(null)
+      expect(response.data).toEqual(null)
+
+    it 'extracts error when inside <Errors>', ->
+      extractError """
+      <SomeResponse>
+        <Errors>
+          <Error>
+            <Code>code</Code><Message>msg</Message>
+          </Error>
+        </Errors>
+      </SomeResponse>"""
+      expect(response.error.code).toEqual('code')
+      expect(response.error.message).toEqual('msg')
+
+    it 'extracts error when <Error> is nested', ->
+      extractError """
+      <SomeResponse>
+        <Error>
+          <Code>code</Code><Message>msg</Message>
+        </Error>
+      </SomeResponse>"""
+      expect(response.error.code).toEqual('code')
+      expect(response.error.message).toEqual('msg')
+
+  describe 'extractData', ->
+    extractData = (body) ->
+      response.httpResponse.statusCode = 200
+      response.httpResponse.body = new Buffer(body)
+      svc.extractData(response)
+
+    it 'parses the response using the operation output rules', ->
+      extractData """
+      <xml>
+        <Data>
+          <Name>abc</Name>
+          <Count>123</Count>
+        </Data>
+      </xml>
+      """
+      expect(response.error).toEqual(null)
+      expect(response.data).toEqual({Data:{Name:'abc',Count:123}})
+
+    it 'performs default xml parsing when output rule is missing', ->
+      delete service.api.operations.operationName.output
+      extractData """
+      <xml>
+        <Data>
+          <Name>abc</Name>
+          <Count>123</Count>
+        </Data>
+      </xml>
+      """
+      expect(response.error).toEqual(null)
+      expect(response.data).toEqual({Data:{Name:'abc',Count:'123'}})
+
+    it 'removes wrapping result element if resultWrapper is set', ->
+      service.api.operations.operationName.output.resultWrapper = 'OperationNameResult'
+      extractData """
+      <xml>
+        <OperationNameResult>
+          <Data>
+            <Name>abc</Name>
+            <Count>12345.5</Count>
+          </Data>
+        </OperationNameResult>
+      </xml>
+      """
+      expect(response.error).toEqual(null)
+      expect(response.data).toEqual({Data:{Name:'abc',Count:12345.5}})

package/test/protocol/rest.spec.coffee

@@ -0,0 +1,237 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+Operation = helpers.AWS.Model.Operation
+Api = helpers.AWS.Model.Api
+
+svc = AWS.Protocol.Rest
+describe 'AWS.Protocol.Rest', ->
+
+  MockRESTService = helpers.util.inherit AWS.Service,
+    endpointPrefix: 'mockservice'
+
+  request = null
+  response = null
+  service = null
+
+  beforeEach ->
+    MockRESTService.prototype.api = new Api operations:
+      SampleOperation:
+        http:
+          method: 'POST'
+          requestUri: '/'
+ 
+
+    AWS.Service.defineMethods(MockRESTService)
+
+    service = new MockRESTService(region: 'region')
+    request = new AWS.Request(service, 'sampleOperation')
+    response = request.response
+
+  defop = (op) ->
+    AWS.util.property(service.api.operations, 'sampleOperation',
+      new Operation('sampleOperation', op, api: service.api))
+
+  describe 'buildRequest', ->
+    input = null
+
+    build = -> svc.buildRequest(request); request
+
+    describe 'method', ->
+      it 'populates method from the operation', ->
+        defop http: method: 'GET'
+        expect(build().httpRequest.method).toEqual('GET')
+
+    describe 'uri', ->
+      beforeEach ->
+        input =
+          type: 'structure'
+          members:
+            Id: location: 'uri', locationName: 'Id'
+
+      it 'populates uri from the operation', ->
+        defop http: requestUri: '/path'
+        expect(build().httpRequest.path).toEqual('/path')
+
+      it 'appends to existing httpRequest endpoint', ->
+        service = new MockRESTService(endpoint: 'https://localhost/foo/bar')
+        request = new AWS.Request(service, 'sampleOperation')
+        request.params = Id: 'abc'
+        defop input: input, http: requestUri: '/Owner/{Id}'
+        expect(build().httpRequest.path).toEqual('/foo/bar/Owner/abc')
+
+      it 'replaces param placeholders', ->
+        request.params = Id: 'abc'
+        defop input: input, http: requestUri: '/Owner/{Id}'
+        expect(build().httpRequest.path).toEqual('/Owner/abc')
+
+      it 'replaces param with empty string', ->
+        request.params = Id: ''
+        defop input: input, http: requestUri: '/Owner/{Id}'
+        expect(build().httpRequest.path).toEqual('/Owner/')
+
+      it 'can replace multiple path placeholders', ->
+        request.params = Id: 'abc', Count: 123
+        input.members.Count = type: 'integer', location: 'uri'
+        defop input: input, http: requestUri: '/{Id}/{Count}'
+        expect(build().httpRequest.path).toEqual('/abc/123')
+
+      it 'performs querystring param replacements', ->
+        request.params = Id: 'abc'
+        defop input: input, http: requestUri: '/path'
+        input.members.Id = location: 'querystring', locationName: 'id-param'
+        expect(build().httpRequest.path).toEqual('/path?id-param=abc')
+
+      it 'omits querystring when param is not provided', ->
+        defop input: input, http: requestUri: '/path'
+        input.members.Id = location: 'querystring', locationName: 'id-param'
+        expect(build().httpRequest.path).toEqual('/path')
+
+      it 'accpets multiple query params with uri params', ->
+        request.params = Abc:'abc', Xyz:'xyz', Bar:'bar'
+        defop input: input, http: requestUri: '/{Abc}/{Xyz}'
+        input.members.Abc = location: 'uri'
+        input.members.Xyz = location: 'uri'
+        input.members.Foo = location: 'querystring', locationName: 'foo'
+        input.members.Bar = location: 'querystring', locationName: 'bar'
+        expect(build().httpRequest.path).toEqual('/abc/xyz?bar=bar')
+
+      it 'uri escapes params in both path and querystring', ->
+        request.params = Path:'a b', Query:'a/b'
+        defop input: input, http: requestUri: '/{Path}'
+        input.members.Path = location: 'uri'
+        input.members.Query = location: 'querystring', locationName: 'query'
+        expect(build().httpRequest.path).toEqual('/a%20b?query=a%2Fb')
+
+    describe 'headers', ->
+      beforeEach ->
+        input =
+          type: 'structure'
+          members:
+            ACL: location: 'header', locationName: 'x-amz-acl'
+
+      it 'populates the headers with present params', ->
+        request.params = ACL: 'public-read'
+        defop input: input
+        expect(build().httpRequest.headers['x-amz-acl']).toEqual('public-read')
+
+      it 'populates the headers type translations', ->
+        request.params = Count: 123
+        defop input: members: Count: locationName: 'count', type: 'integer', location: 'header'
+        expect(build().httpRequest.headers['count']).toEqual('123')
+
+      it 'uses default rule name if locationName property is not present', ->
+        request.params = ACL: 'public-read'
+        delete input.members.ACL.locationName
+        defop input: input
+        expect(build().httpRequest.headers['ACL']).toEqual('public-read')
+
+      it 'works with map types', ->
+        request.params =
+          Metadata:
+            foo: 'bar'
+            abc: 'xyz'
+        input.members.Metadata =
+          type: 'map'
+          location: 'headers'
+          locationName: 'x-amz-meta-'
+        defop input: input
+
+        build()
+        expect(request.httpRequest.headers['x-amz-meta-foo']).toEqual('bar')
+        expect(request.httpRequest.headers['x-amz-meta-abc']).toEqual('xyz')
+
+    describe 'timestamp header with format', ->
+      it 'populates the header with correct timestamp formatting', ->
+        date = new Date(); date.setMilliseconds(0)
+        request.params = IfModifiedSince: date
+        input.members.IfModifiedSince =
+          location: 'header'
+          locationName: 'If-Modified-Since'
+          type: 'timestamp'
+          timestampFormat: 'rfc822'
+        defop input: input
+        expect(build().httpRequest.headers['If-Modified-Since']).toEqual(date.toUTCString())
+
+    describe 'timestamp header without format', ->
+      it 'populates the header using the api formatting', ->
+        service.api.timestampFormat = 'rfc822'
+        date = new Date(); date.setMilliseconds(0)
+        request.params = IfModifiedSince: date
+        input.members.IfModifiedSince =
+          location: 'header'
+          locationName: 'If-Modified-Since'
+          type: 'timestamp'
+        defop input: input
+        expect(build().httpRequest.headers['If-Modified-Since']).toEqual(date.toUTCString())
+
+    describe 'timestamp header with api formatting and parameter formatting', ->
+      it 'populates the header using the parameter formatting', ->
+        service.api.timestampFormat = 'invalid'
+        date = new Date(); date.setMilliseconds(0)
+        request.params = IfModifiedSince: date
+        input.members.IfModifiedSince =
+          location: 'header'
+          locationName: 'If-Modified-Since'
+          type: 'timestamp'
+          timestampFormat: 'rfc822'
+        defop input: input
+        expect(build().httpRequest.headers['If-Modified-Since']).toEqual(date.toUTCString())
+
+    describe 'timestamp header with iso formatting', ->
+      it 'populates the header using the parameter formatting', ->
+        date = new Date(); date.setMilliseconds(0)
+        request.params = IfModifiedSince: date
+        input.members.IfModifiedSince =
+          location: 'header'
+          locationName: 'If-Modified-Since'
+          type: 'timestamp'
+          timestampFormat: 'iso8601'
+        defop input: input
+        expect(build().httpRequest.headers['If-Modified-Since']).toEqual(date.toISOString())
+
+  describe 'extractData', ->
+    output = type: 'structure', members:
+      ContentType:
+        type: 'string'
+        location: 'header'
+        locationName: 'content-type'
+
+    extract = -> defop output: output; svc.extractData(response); response
+
+    describe 'headers', ->
+      it 'extracts header values', ->
+        response.httpResponse.headers['content-type'] = 'text/plain'
+        expect(extract().data.ContentType).toEqual('text/plain')
+
+      it 'extracts headers when the rule name is camel-cased', ->
+        response.httpResponse.headers['content-type'] = 'text/plain'
+        output.members.ContentType.locationName = 'Content-Type'
+        expect(extract().data.ContentType).toEqual('text/plain')
+
+      it 'extracts headers when the header name is camel-cased', ->
+        response.httpResponse.headers['Content-Type'] = 'text/plain'
+        expect(extract().data.ContentType).toEqual('text/plain')
+
+      it 'extracts map types from header', ->
+        output.members.Metadata = type: 'map', location: 'headers', locationName: 'x-amz-meta-'
+        response.httpResponse.headers['X-AMZ-META-FOO'] = 'foo'
+        response.httpResponse.headers['x-amz-meta-bar'] = 'bar'
+
+        extract()
+        expect(response.data.Metadata.FOO).toEqual('foo')
+        expect(response.data.Metadata.bar).toEqual('bar')
+
+      it 'adds empty map if no matching headers are found', ->
+        output.members.Metadata = type: 'map', location: 'headers', locationName: 'x-amz-meta-'
+        expect(extract().data.Metadata).toEqual({})
+
+    describe 'status code', ->
+      it 'extracts the http status when instructed to', ->
+        output.members.Result = type: 'integer', location: 'status'
+        response.httpResponse.statusCode = 200
+        expect(extract().data.Result).toEqual(200)
+
+      it 'casts string status codes to integers', ->
+        output.members.Result = type: 'integer', location: 'status'
+        response.httpResponse.statusCode = '202'
+        expect(extract().data.Result).toEqual(202)

package/test/protocol/rest_json.spec.coffee

@@ -0,0 +1,255 @@
+helpers = require('../helpers'); AWS = helpers.AWS
+Operation = AWS.Model.Operation
+Buffer = helpers.util.Buffer
+
+svc = AWS.Protocol.RestJson
+describe 'AWS.Protocol.RestJson', ->
+
+  MockJSONRESTService = helpers.util.inherit AWS.Service,
+    endpointPrefix: 'mockservice'
+
+  operation = null
+  request = null
+  response = null
+  service = null
+
+  beforeEach ->
+    MockJSONRESTService.prototype.api = new AWS.Model.Api
+      operations:
+        sampleOperation:
+          http:
+            method: 'POST'
+            uri: '/'
+          input:
+            type: 'structure'
+            members: {}
+          output:
+            type: 'structure'
+            members:
+              a: type: 'string'
+              b: type: 'string'
+
+    AWS.Service.defineMethods(MockJSONRESTService)
+
+    operation = MockJSONRESTService.prototype.api.operations.sampleOperation
+    service = new MockJSONRESTService(region: 'region')
+    request = new AWS.Request(service, 'sampleOperation')
+    response = new AWS.Response(request)
+
+  defop = (op) ->
+    helpers.util.property(service.api.operations, 'sampleOperation',
+      new Operation('sampleOperation', op, api: service.api))
+
+  describe 'buildRequest', ->
+    build = -> svc.buildRequest(request); request
+
+    describe 'method', ->
+      it 'populates method from the operation', ->
+        defop http: method: 'GET'
+        expect(build().httpRequest.method).toEqual('GET')
+
+    describe 'uri', ->
+      it 'populates uri from the operation', ->
+        defop http: requestUri: '/path'
+        expect(build().httpRequest.path).toEqual('/path')
+
+      it 'replaces param placeholders', ->
+        request.params = Id: 'abc'
+        defop
+          http: requestUri: '/Owner/{Id}'
+          input: type: 'structure', members: Id: location: 'uri'
+        expect(build().httpRequest.path).toEqual('/Owner/abc')
+
+      it 'can replace multiple path placeholders', ->
+        request.params = Id: 'abc', Count: 123
+        defop
+          http: requestUri: '/{Id}/{Count}'
+          input:
+            type: 'structure'
+            members:
+              Id:
+                location: 'uri'
+                type: 'string'
+              Count:
+                type: 'integer'
+                location: 'uri'
+        expect(build().httpRequest.path).toEqual('/abc/123')
+
+      it 'performs querystring param replacements', ->
+        request.params = Id: 'abc'
+        defop
+          http: requestUri: '/path'
+          input:
+            type: 'structure'
+            members:
+              Id:
+                location: 'querystring'
+                locationName: 'id-param'
+        expect(build().httpRequest.path).toEqual('/path?id-param=abc')
+
+    describe 'headers', ->
+      it 'populates the headers with present params', ->
+        request.params = ACL: 'public-read'
+        defop input:
+          members:
+            ACL:
+              location: 'header'
+              locationName: 'x-amz-acl'
+        expect(build().httpRequest.headers['x-amz-acl']).toEqual('public-read')
+
+      it 'uses default rule name if .n property is not present', ->
+        request.params = ACL: 'public-read'
+        defop input:
+          members:
+            ACL:
+              location: 'header'
+        expect(build().httpRequest.headers['ACL']).toEqual('public-read')
+
+      it 'works with map types', ->
+        request.params =
+          Metadata:
+            foo: 'bar'
+            abc: 'xyz'
+        defop input:
+          members:
+            Metadata:
+              type: 'map'
+              location: 'headers'
+              locationName: 'x-amz-meta-'
+
+        build()
+        expect(request.httpRequest.headers['x-amz-meta-foo']).toEqual('bar')
+        expect(request.httpRequest.headers['x-amz-meta-abc']).toEqual('xyz')
+
+    describe 'body', ->
+      it 'builds root element if rules contains root', ->
+        request.params =
+          Config:
+            Name: 'foo'
+            Type: 'bar'
+        defop input:
+          payload: 'Config'
+          members:
+            Config:
+              type: 'structure'
+              members:
+                Name: type: 'string'
+                Type: type: 'string'
+        expect(build().httpRequest.body.toString()).toEqual(
+          '{"Name":"foo","Type":"bar"}')
+
+      it 'builds payload element as non JSON data if rules contains payload', ->
+        request.params = Body: 'foobar'
+        defop input:
+          payload: 'Body'
+          members:
+            Body:
+              type: 'binary'
+        expect(build().httpRequest.body).toEqual('foobar')
+
+  describe 'extractError', ->
+    extractError = (body) ->
+      response.httpResponse.statusCode = 500
+      response.httpResponse.body = new Buffer(body)
+      svc.extractError(response)
+
+    it 'removes prefixes from the error code', ->
+      extractError '{"__type":"com.amazon.coral.service#ErrorCode" }'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.code).toEqual('ErrorCode')
+      expect(response.data).toEqual(null)
+
+    it 'returns the full code when a # is not present', ->
+      extractError '{"__type":"ErrorCode" }'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.code).toEqual('ErrorCode')
+      expect(response.data).toEqual(null)
+
+    it 'returns the status code when the body is blank', ->
+      extractError ''
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.code).toEqual(500)
+      expect(response.error.message).toEqual(null)
+      expect(response.data).toEqual(null)
+
+    it 'returns null for the message when not present', ->
+      extractError '{"__type":"ErrorCode" }'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.message).toEqual(null)
+      expect(response.data).toEqual(null)
+
+    it 'returns the message when present', ->
+      extractError '{"__type":"ErrorCode", "message":"Error Message" }'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.message).toEqual('Error Message')
+      expect(response.data).toEqual(null)
+
+    # DynamoDB and SWF return error message properties with different case
+    it 'returns the message when the message property is upper-cased', ->
+      extractError '{"__type":"ErrorCode", "Message":"Error Message" }'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.message).toEqual('Error Message')
+      expect(response.data).toEqual(null)
+
+    it 'returns a special message for RequestEntityToLarge errors', ->
+      extractError '{"__type":"RequestEntityTooLarge" }'
+      expect(response.error instanceof Error).toBeTruthy()
+      expect(response.error.message).toEqual('Request body must be less than 1 MB')
+      expect(response.data).toEqual(null)
+
+  describe 'extractData', ->
+    extractData = (body) ->
+      response.httpResponse.statusCode = 200
+      response.httpResponse.body = new Buffer(body)
+      svc.extractData(response)
+
+    it 'JSON parses http response bodies', ->
+      extractData '{"a":1, "b":"xyz"}'
+      expect(response.error).toEqual(null)
+      expect(response.data).toEqual({a:1, b:'xyz'})
+
+    it 'pulls header data out of response', ->
+      response.httpResponse.headers['x-title'] = 'The title'
+      defop output:
+        type: 'structure'
+        members:
+          Title:
+            location: 'header'
+            locationName: 'x-title'
+
+      extractData '{}'
+      expect(response.error).toEqual(null)
+      expect(response.data.Title).toEqual('The title')
+
+    it 'pulls body out into data key if body is payload', ->
+      defop output:
+        type: 'structure'
+        payload: 'Body'
+        members:
+          Body: location: 'body', type: 'binary'
+
+      extractData 'foobar'
+      expect(response.error).toEqual(null)
+      expect(response.data.Body).toEqual('foobar')
+
+    it 'pulls body out as Buffer if body is streaming payload', ->
+      defop output:
+        type: 'structure'
+        payload: 'Body'
+        members:
+          Body: location: 'body', type: 'binary', streaming: true
+
+      extractData 'foobar'
+      expect(response.error).toEqual(null)
+      expect(Buffer.isBuffer(response.data.Body)).toEqual(true)
+      expect(response.data.Body.toString()).toEqual('foobar')
+
+    it 'returns an empty object when the body is an empty string', ->
+      extractData ''
+      expect(response.error).toEqual(null)
+      expect(response.data).toEqual({})
+
+    it 'returns an empty object when the body is null', ->
+      extractData ''
+      expect(response.error).toEqual(null)
+      expect(response.data).toEqual({})