/node_modules/nodemailer/node_modules/aws-sdk/test/protocol/rest_xml.spec.coffee
CoffeeScript | 329 lines | 302 code | 27 blank | 0 comment | 2 complexity | 16e93b2c3e9ffce679786ec2e28c2968 MD5 | raw file
- 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')