aws-sdk 2.0.1 → 2.0.5

package/test/protocol/rest_xml.spec.coffee

@@ -0,0 +1,329 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+Buffer = AWS.util.Buffer
+
+svc = AWS.Protocol.RestXml
+describe 'AWS.Protocol.RestXml', ->
+
+  MockRESTXMLService = AWS.util.inherit AWS.Service,
+    endpointPrefix: 'mockservice'
+
+  xmlns = 'http://mockservice.com/xmlns'
+  request = null
+  response = null
+  service = null
+
+  beforeEach ->
+    MockRESTXMLService.prototype.api = new AWS.Model.Api
+      metadata:
+        xmlNamespace: xmlns
+      operations:
+        SampleOperation:
+          http:
+            method: 'POST'
+            requestUri: '/'
+
+    AWS.Service.defineMethods(MockRESTXMLService)
+    service = new MockRESTXMLService(region: 'region')
+    request = new AWS.Request(service, 'sampleOperation')
+    response = request.response
+
+  defop = (op) ->
+    AWS.util.property(service.api.operations, 'sampleOperation',
+      new AWS.Model.Operation('sampleOperation', op, api: service.api))
+
+  describe 'buildRequest', ->
+    build = -> svc.buildRequest(request); request
+
+    describe 'empty bodies', ->
+      it 'defaults body to empty string when there are no inputs', ->
+        defop input: type: 'structure', members: {}
+        expect(build().httpRequest.body).toEqual('')
+
+      it 'defaults body to empty string when no body params are present', ->
+        request.params = Bucket: 'abc', ACL: 'canned-acl'
+        defop
+          http: requestUri: '/{Bucket}'
+          input:
+            type: 'structure'
+            members:
+              Bucket:
+                location: 'uri'
+              ACL:
+                locationName: 'x-amz-acl'
+                location: 'header'
+
+        build()
+        expect(request.httpRequest.body).toEqual('')
+        expect(request.httpRequest.path).toEqual('/abc')
+        expect(request.httpRequest.headers['x-amz-acl']).toEqual('canned-acl')
+
+    describe 'string bodies', ->
+      it 'populates the body with string types directly', ->
+        request.params = Bucket: 'bucket-name', Data: 'abc'
+        defop
+          http: requestUri: '/{Bucket}'
+          input:
+            payload: 'Data'
+            members:
+              Bucket:
+                location: 'uri'
+              Data:
+                type: 'string'
+        expect(build().httpRequest.body).toEqual('abc')
+
+    describe 'xml bodies', ->
+      it 'populates the body with XML from the params', ->
+        request.params =
+          ACL: 'canned-acl'
+          Config:
+            Abc: 'abc'
+            Locations: ['a', 'b', 'c']
+            Data: [
+              { Foo:'foo1', Bar:'bar1' },
+              { Foo:'foo2', Bar:'bar2' },
+            ]
+          Bucket: 'bucket-name'
+          Marker: 'marker'
+          Limit: 123
+          Metadata:
+            abc: 'xyz'
+            mno: 'hjk'
+        defop
+          http: requestUri: '/{Bucket}'
+          input:
+            payload: 'Config'
+            members:
+              Bucket: # uri path param
+                type: 'string'
+                location: 'uri'
+              Marker: # uri querystring param
+                type: 'string'
+                location: 'querystring'
+                locationName: 'next-marker'
+              Limit: # uri querystring integer param
+                type: 'integer'
+                location: 'querystring'
+                locationName: 'limit'
+              ACL: # header string param
+                type: 'string'
+                location: 'header'
+                locationName: 'x-amz-acl'
+              Metadata: # header map param
+                type: 'map'
+                location: 'headers'
+                locationName: 'x-amz-meta-'
+              Config: # structure of mixed tpyes
+                type: 'structure'
+                members:
+                  Abc: type: 'string'
+                  Locations: # array of strings
+                    type: 'list'
+                    member:
+                      type: 'string'
+                      locationName: 'Location'
+                  Data: # array of structures
+                    type: 'list'
+                    member:
+                      type: 'structure'
+                      members:
+                        Foo: type: 'string'
+                        Bar: type: 'string'
+        xml = """
+        <Config xmlns="http://mockservice.com/xmlns">
+          <Abc>abc</Abc>
+          <Locations>
+            <Location>a</Location>
+            <Location>b</Location>
+            <Location>c</Location>
+          </Locations>
+          <Data>
+            <member>
+              <Foo>foo1</Foo>
+              <Bar>bar1</Bar>
+            </member>
+            <member>
+              <Foo>foo2</Foo>
+              <Bar>bar2</Bar>
+            </member>
+          </Data>
+        </Config>
+        """
+
+        build()
+        expect(request.httpRequest.method).toEqual('POST')
+        expect(request.httpRequest.path).
+          toEqual('/bucket-name?limit=123&next-marker=marker')
+        expect(request.httpRequest.headers['x-amz-acl']).toEqual('canned-acl')
+        expect(request.httpRequest.headers['x-amz-meta-abc']).toEqual('xyz')
+        expect(request.httpRequest.headers['x-amz-meta-mno']).toEqual('hjk')
+        helpers.matchXML(request.httpRequest.body, xml)
+
+      it 'omits the body xml when body params are not present', ->
+        request.params = Bucket:'abc' # omitting Config purposefully
+        defop
+          http: requestUri: '/{Bucket}'
+          input:
+            members:
+              Bucket:
+                location: 'uri'
+              Config: {}
+
+        build()
+        expect(request.httpRequest.body).toEqual('')
+        expect(request.httpRequest.path).toEqual('/abc')
+
+    it 'uses payload member name for payloads', ->
+      request.params =
+        Data:
+          Member1: 'member1'
+          Member2: 'member2'
+      defop
+        input:
+          payload: 'Data'
+          members:
+            Data:
+              type: 'structure'
+              locationName: 'RootElement'
+              members:
+                Member1: type: 'string'
+                Member2: type: 'string'
+      helpers.matchXML build().httpRequest.body, """
+        <RootElement xmlns="http://mockservice.com/xmlns">
+          <Member1>member1</Member1>
+          <Member2>member2</Member2>
+        </RootElement>
+      """
+
+  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 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 instanceof Error).toBeTruthy()
+      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 xml body', ->
+      defop output:
+        type: 'structure'
+        members:
+          Foo: {}
+          Bar:
+            type: 'list'
+            member:
+              locationName: 'Item'
+      extractData """
+      <xml>
+        <Foo>foo</Foo>
+        <Bar>
+          <Item>a</Item>
+          <Item>b</Item>
+          <Item>c</Item>
+        </Bar>
+      </xml>
+      """
+      expect(response.data).toEqual({Foo:'foo', Bar:['a', 'b', 'c']})
+
+    it 'sets payload element to a Buffer object when it streams', ->
+      defop output:
+        type: 'structure'
+        payload: 'Body'
+        members:
+          Body:
+            streaming: true
+      extractData 'Buffer data'
+      expect(Buffer.isBuffer(response.data.Body)).toBeTruthy()
+      expect(response.data.Body.toString()).toEqual('Buffer data')
+
+    it 'sets payload element to String when it does not stream', ->
+      defop output:
+        type: 'structure'
+        payload: 'Body'
+        members:
+          Body: type: 'string'
+      extractData 'Buffer data'
+      expect(typeof response.data.Body).toEqual('string')
+      expect(response.data.Body).toEqual('Buffer data')
+
+    it 'sets payload element along with other outputs', ->
+      response.httpResponse.headers['x-amz-foo'] = 'foo'
+      response.httpResponse.headers['x-amz-bar'] = 'bar'
+      defop output:
+        type: 'structure'
+        payload: 'Baz'
+        members:
+          Foo:
+            location: 'header'
+            locationName: 'x-amz-foo'
+          Bar:
+            location: 'header'
+            locationName: 'x-amz-bar'
+          Baz: {}
+      extractData 'Buffer data'
+      expect(response.data.Foo).toEqual('foo')
+      expect(response.data.Bar).toEqual('bar')
+      expect(response.data.Baz).toEqual('Buffer data')
+
+    it 'parses headers when a payload is provided', ->
+      response.httpResponse.headers['x-amz-foo'] = 'foo'
+      defop output:
+        type: 'structure'
+        payload: 'Bar'
+        members:
+          Foo:
+            location: 'header'
+            locationName: 'x-amz-foo'
+          Bar:
+            type: 'structure'
+            members:
+              Baz: type: 'string'
+      extractData '<Bar><Baz>Buffer data</Baz></Bar>'
+      expect(response.data.Foo).toEqual('foo')
+      expect(response.data.Baz).toEqual('Buffer data')

package/test/query/query_param_serializer.spec.coffee

@@ -0,0 +1,327 @@
+helpers = require('../helpers')
+QueryParamSerializer = require('../../lib/query/query_param_serializer')
+Shape = helpers.AWS.Model.Shape
+
+describe 'QueryParamSerializer', ->
+
+  serialize = (requestParams, rules) ->
+    params = []
+    serializer = new QueryParamSerializer()
+    shape = Shape.create type: 'structure', members: rules
+    serializer.serialize requestParams, shape, (name, value) ->
+      params.push([name, value])
+    params
+
+  describe 'scalar params', ->
+
+    it 'can serialize simple strings', ->
+      rules = {Name1:{type:'string'},Name2:{type:'string'}}
+      params = serialize({Name1:'abc',Name2:'xyz'}, rules)
+      expect(params).toEqual([
+        ['Name1', 'abc']
+        ['Name2', 'xyz']
+      ])
+
+    it 'stringifies values', ->
+      rules = {Count: {type:'string'}}
+      params = serialize({ Count:1 }, rules)
+      expect(params).toEqual([['Count', '1']])
+
+    it 'defaults params to strings when type not specified', ->
+      rules = {ParamName: {}}
+      params = serialize({ ParamName:'abc' }, rules)
+      expect(params).toEqual([['ParamName', 'abc']])
+
+    it 'ignores null values', ->
+      rules = {ParamName: {}}
+      params = serialize({ ParamName:null }, rules)
+      expect(params).toEqual([])
+
+  describe 'structures', ->
+
+    it 'works with deeply nested objects', ->
+      rules =
+        Aa:
+          type: 'structure'
+          members:
+            Bb:
+              type: 'structure'
+              members:
+                Cc:
+                  type: 'structure'
+                  members:
+                    Dd: {}
+      params = serialize({Aa:Bb:Cc:Dd:'value'}, rules)
+      expect(params).toEqual([
+        ['Aa.Bb.Cc.Dd', 'value']
+      ])
+
+    it 'works with nested objects that have multiple properties', ->
+      rules =
+        Root:
+          type: 'structure'
+          members:
+            Abc: {}
+            Xyz: {}
+        Root2: {}
+      params = serialize({Root:{Abc:'1',Xyz:'2'},Root2:'3'}, rules)
+      expect(params).toEqual([
+        ['Root.Abc', '1']
+        ['Root.Xyz', '2']
+        ['Root2', '3']
+      ])
+
+    it 'applies structure member names', ->
+      rules =
+        Root:
+          type: 'structure'
+          locationName: 'ROOT'
+          members:
+            Leaf:
+              locationName: 'lEAF'
+      params = serialize({Root:{Leaf:'value'}}, rules)
+      expect(params).toEqual([
+        ['ROOT.lEAF', 'value']
+      ])
+
+    it 'ignores null', ->
+      rules =
+        Root:
+          type: 'structure'
+          locationName: 'ROOT'
+          members:
+            Leaf:
+              locationName: 'lEAF'
+      params = serialize({Root:null}, rules)
+      expect(params).toEqual([])
+
+
+  describe 'lists', ->
+
+    describe 'flattened', ->
+
+      it 'numbers list members starting at 1', ->
+        rules =
+          Name:
+            type: 'list'
+            flattened: true
+            member: type: 'string'
+        params = serialize({Name:['a','b','c']}, rules)
+        expect(params).toEqual([
+          ['Name.1', 'a'],
+          ['Name.2', 'b'],
+          ['Name.3', 'c'],
+        ])
+
+      it 'supports queryFlattened key', ->
+        rules =
+          Name:
+            type: 'list'
+            queryFlattened: true
+            member: type: 'string'
+        params = serialize({Name:['a','b','c']}, rules)
+        expect(params).toEqual([
+          ['Name.1', 'a'],
+          ['Name.2', 'b'],
+          ['Name.3', 'c'],
+        ])
+
+      it 'Uses list-member names instead of the list name', ->
+        rules =
+          Root:
+            type: 'structure'
+            members:
+              Items:
+                type: 'list'
+                flattened: true
+                member:
+                  locationName: 'ListItem'
+        params = serialize({Root:{Items:['a', 'b', 'c']}}, rules)
+        expect(params).toEqual([
+          ['Root.ListItem.1', 'a'],
+          ['Root.ListItem.2', 'b'],
+          ['Root.ListItem.3', 'c'],
+        ])
+
+      it 'accepts nested arrays', ->
+        rules =
+          Person:
+            type: 'structure'
+            members:
+              Name:
+                type: 'list'
+                flattened: true
+                member: type: 'string'
+        params = serialize({Person:{Name:['a','b','c']}}, rules)
+        expect(params).toEqual([
+          ['Person.Name.1', 'a'],
+          ['Person.Name.2', 'b'],
+          ['Person.Name.3', 'c'],
+        ])
+
+      it 'supports lists of complex types', ->
+        rules =
+          Root:
+            type: 'list'
+            flattened: true
+            member:
+              type: 'structure'
+              members:
+                Aa: {}
+                Bb: {}
+        params = serialize({Root:[{Aa:'a1',Bb:'b1'},{Aa:'a2',Bb:'b2'}]},rules)
+        expect(params.sort()).toEqual([
+          ['Root.1.Aa', 'a1'],
+          ['Root.1.Bb', 'b1'],
+          ['Root.2.Aa', 'a2'],
+          ['Root.2.Bb', 'b2'],
+        ])
+
+      it 'serializes list members as strings when member rule not present', ->
+        rules =
+          Root:
+            type: 'list'
+            flattened: true
+            member: type: 'string'
+        params = serialize({Root:['a', 'b', 'c']}, rules)
+        expect(params).toEqual([
+          ['Root.1', 'a'],
+          ['Root.2', 'b'],
+          ['Root.3', 'c'],
+        ])
+
+    describe 'non-flat', ->
+      it 'adds a `.member` prefix to each list member', ->
+        rules =
+          Person:
+            type: 'list'
+            member: type: 'string'
+        params = serialize({Person:['a','b','c']}, rules)
+        expect(params).toEqual([
+          ['Person.member.1', 'a'],
+          ['Person.member.2', 'b'],
+          ['Person.member.3', 'c'],
+        ])
+
+      it 'ignores the list-member name', ->
+        rules =
+          Person:
+            type: 'list'
+            member:
+              locationName: 'Name'
+        params = serialize({Person:['a','b','c']}, rules)
+        expect(params).toEqual([
+          ['Person.member.1', 'a'],
+          ['Person.member.2', 'b'],
+          ['Person.member.3', 'c'],
+        ])
+
+      it 'observes both list name and list member name', ->
+        rules =
+          People:
+            type: 'list'
+            locationName: 'Person',
+            member:
+              locationName: 'Name'
+        params = serialize({People:['a','b','c']}, rules)
+        expect(params).toEqual([
+          ['Person.member.1', 'a'],
+          ['Person.member.2', 'b'],
+          ['Person.member.3', 'c'],
+        ])
+
+  describe 'maps', -> # maps are hashes with user defined keys
+
+    it 'accepts a hash (object) of arbitrary key/value pairs', ->
+      rules =
+        Attributes:
+          type: 'map'
+          flattened: true
+          key: {}
+          value: {}
+      data = {Attributes:{Color:'red',Size:'large',Value:'low'}}
+      params = serialize(data, rules)
+      expect(params).toEqual([
+        ['Attributes.1.key', 'Color'],
+        ['Attributes.1.value', 'red'],
+        ['Attributes.2.key', 'Size'],
+        ['Attributes.2.value', 'large'],
+        ['Attributes.3.key', 'Value'],
+        ['Attributes.3.value', 'low'],
+      ])
+
+    it 'supports queryFlattened key', ->
+      rules =
+        Attributes:
+          type: 'map'
+          queryFlattened: true
+          key: {}
+          value: {}
+      data = {Attributes:{Color:'red',Size:'large',Value:'low'}}
+      params = serialize(data, rules)
+      expect(params).toEqual([
+        ['Attributes.1.key', 'Color'],
+        ['Attributes.1.value', 'red'],
+        ['Attributes.2.key', 'Size'],
+        ['Attributes.2.value', 'large'],
+        ['Attributes.3.key', 'Value'],
+        ['Attributes.3.value', 'low'],
+      ])
+
+    describe 'non-flat', ->
+      it 'adds .entry. to name', ->
+        rules =
+          Attributes:
+            type: 'map'
+            key: {}
+            value: {}
+        data = Attributes: Color: 'red', Size: 'large', Value: 'low'
+        params = serialize(data, rules)
+        expect(params).toEqual([
+          ['Attributes.entry.1.key', 'Color'],
+          ['Attributes.entry.1.value', 'red'],
+          ['Attributes.entry.2.key', 'Size'],
+          ['Attributes.entry.2.value', 'large'],
+          ['Attributes.entry.3.key', 'Value'],
+          ['Attributes.entry.3.value', 'low'],
+        ])
+
+  describe 'maps with member names', ->
+
+    it 'applies member name traits', ->
+      rules =
+        Attributes:
+          type: 'map'
+          flattened: true
+          key:
+            locationName: 'Name'
+          value:
+            locationName: 'Value'
+      data = {Attributes:{Color:'red',Size:'large',Value:'low'}}
+      params = serialize(data, rules)
+      expect(params).toEqual([
+        ['Attributes.1.Name', 'Color'],
+        ['Attributes.1.Value', 'red'],
+        ['Attributes.2.Name', 'Size'],
+        ['Attributes.2.Value', 'large'],
+        ['Attributes.3.Name', 'Value'],
+        ['Attributes.3.Value', 'low'],
+      ])
+
+  describe 'timestamps', ->
+
+    it 'serializes timestamp to iso8601 strings by default', ->
+      date = new Date(); date.setMilliseconds(0)
+      rules = { Date: { type: 'timestamp' } }
+      params = serialize({ Date: date }, rules)
+      expect(params).toEqual([
+        ['Date', helpers.util.date.iso8601(date)],
+      ])
+
+    it 'obeys format options in the rules', ->
+      date = new Date(); date.setMilliseconds(0)
+      rules = { Date: { type: 'timestamp', timestampFormat: 'rfc822' } }
+      params = serialize({ Date: date }, rules)
+      expect(params).toEqual([
+        ['Date', helpers.util.date.rfc822(date)],
+      ])

package/test/region_config.spec.coffee

@@ -0,0 +1,50 @@
+helpers = require('./helpers')
+EventEmitter = require('events').EventEmitter
+AWS = helpers.AWS
+MockService = helpers.MockService
+Buffer = AWS.util.Buffer
+
+describe 'region_config.js', ->
+  it 'sets endpoint configuration option for default regions', ->
+    service = new MockService
+    expect(service.isGlobalEndpoint).toEqual(false)
+    expect(service.endpoint.host).toEqual('mockservice.mock-region.amazonaws.com')
+
+  [AWS.CloudFront, AWS.IAM, AWS.ImportExport, AWS.Route53, AWS.STS].forEach (svcClass) ->
+    it 'uses a global endpoint for ' + svcClass.serviceIdentifier, ->
+      service = new svcClass
+      expect(service.endpoint.host).toEqual(service.serviceIdentifier + '.amazonaws.com')
+      expect(service.isGlobalEndpoint).toEqual(true)
+
+  it 'always enables SSL for Route53', ->
+    service = new AWS.Route53
+    expect(service.config.sslEnabled).toEqual(true)
+
+  it 'uses "global" endpoint for SimpleDB in us-east-1', ->
+    service = new AWS.SimpleDB(region: 'us-east-1')
+    expect(service.isGlobalEndpoint).toEqual(false)
+    expect(service.endpoint.host).toEqual('sdb.amazonaws.com')
+
+  it 'uses "global" endpoint for SimpleDB in us-east-1', ->
+    service = new AWS.S3(region: 'us-east-1')
+    expect(service.isGlobalEndpoint).toEqual(false)
+    expect(service.endpoint.host).toEqual('s3.amazonaws.com')
+
+  it 'does not use any global endpoints in cn-*', ->
+    service = new AWS.IAM(region: 'cn-north-1')
+    expect(service.isGlobalEndpoint).toEqual(false)
+    expect(service.endpoint.host).toEqual('iam.cn-north-1.amazonaws.com.cn')
+
+  it 'enables signature version 4 signing in cn-*', ->
+    service = new AWS.IAM(region: 'cn-north-1')
+    expect(service.config.signatureVersion).toEqual('v4')
+
+  it 'uses - as separator for S3 in public regions', ->
+    service = new AWS.S3(region: 'us-west-2')
+    expect(service.isGlobalEndpoint).toEqual(false)
+    expect(service.endpoint.host).toEqual('s3-us-west-2.amazonaws.com')
+
+  it 'uses . as separator for S3 in cn-*', ->
+    service = new AWS.S3(region: 'cn-north-1')
+    expect(service.isGlobalEndpoint).toEqual(false)
+    expect(service.endpoint.host).toEqual('s3.cn-north-1.amazonaws.com.cn')