%PDF-
%PDF-
Mini Shell
Mini Shell
helpers = require('./helpers')
EventEmitter = require('events').EventEmitter
AWS = helpers.AWS
MockService = helpers.MockService
Buffer = AWS.util.Buffer
describe 'AWS.Request', ->
service = null
beforeEach ->
service = new MockService
describe 'error handling', ->
it 'throws errors out of callback', ->
helpers.mockHttpResponse 200, {}, ''
expect(->
service.makeRequest 'mockMethod', ->
throw new Error('error')
).toThrow('error')
for evt in ['error', 'success', 'complete']
it 'throws errors out of terminal ' + evt + ' event', ->
helpers.mockHttpResponse 200, {}, ''
expect(->
req = service.makeRequest('mockMethod')
req.on evt, -> throw new Error('error')
req.send()
).toThrow('error')
it 'propagates errors to error event', ->
helpers.mockHttpResponse 200, {}, ''
err = null
expect(->
req = service.makeRequest('mockMethod')
req.on 'extractData', -> throw new Error('error')
req.send((e) -> err = e)
).not.toThrow('error')
expect(err.message).toEqual('error')
describe 'isPageable', ->
beforeEach ->
service = new AWS.Service apiConfig: new AWS.Model.Api
operations: mockMethod: {}
it 'is pageable if it has a pagination config for the operation', ->
service.api.paginators['mockMethod'] = new AWS.Model.Paginator('mockMethod', limit_key: 'Marker')
request = service.makeRequest('mockMethod')
expect(request.isPageable()).toEqual(true)
it 'is not pageable if the pagination config does not exist for the operation', ->
expect(service.makeRequest('mockMethod').isPageable()).toEqual(false)
describe 'eachPage', ->
beforeEach ->
service = new AWS.Service apiConfig: new AWS.Model.Api
operations:
mockMethod:
input:
type: 'structure'
members:
NextToken: type: 'string'
output:
type: 'structure'
members:
NextToken: type: 'string'
Value: type: 'integer'
paginators:
mockMethod:
input_token: 'NextToken'
output_token: 'NextToken'
helpers.mockResponses service, [
{data: {Value: 1, NextToken: 'a'}},
{data: {Value: 2, NextToken: 'b'}},
{data: {Value: 3, NextToken: 'c'}},
{data: {Value: 4}}
]
it 'can page multiple responses', ->
resps = []
runs ->
service.mockMethod().eachPage (err, data) ->
resps.push([err, data])
waitsFor -> resps.length > 3
runs ->
expect(resps).toEqual [
[null, {Value: 1, NextToken: 'a'}],
[null, {Value: 2, NextToken: 'b'}],
[null, {Value: 3, NextToken: 'c'}],
[null, {Value: 4}],
[null, null]
]
it 'supports stopping responses if false is returned', ->
resps = []
runs ->
service.mockMethod().eachPage (err, data) ->
if resps.length == 2
return false
resps.push([err, data])
true
waitsFor -> resps.length == 2
runs ->
expect(resps).toEqual [
[null, {Value: 1, NextToken: 'a'}],
[null, {Value: 2, NextToken: 'b'}]
]
it 'supports asynchronous eachPage calls', ->
resps = []
runs ->
service.mockMethod().eachPage (err, data, done) ->
process.nextTick ->
resps.push([err, data])
done()
waitsFor -> resps.length > 3
runs ->
expect(resps).toEqual [
[null, {Value: 1, NextToken: 'a'}],
[null, {Value: 2, NextToken: 'b'}],
[null, {Value: 3, NextToken: 'c'}],
[null, {Value: 4}],
[null, null]
]
it 'throws error from eachPage callback', ->
try
service.mockMethod().eachPage -> invalidCode
catch e
expect(e.name).toEqual('ReferenceError')
describe 'waitFor', ->
it 'creates a ResourceWaiter object', ->
service.api.waiters = state: operation: 'mockMethod'
service.waitFor('state')
describe 'send', ->
it 'accepts an optional callback', ->
error = null; data = null
helpers.mockHttpResponse 200, {}, ['FOO', 'BAR', 'BAZ', 'QUX']
runs ->
service.makeRequest('mockMethod').send (e, d) -> data = d
waitsFor -> data
runs ->
expect(data).toEqual('FOOBARBAZQUX')
describe 'abort', ->
it 'allows aborting requests', ->
error = null; data = null; done = null
helpers.mockHttpResponse 200, {}, ['FOO', 'BAR', 'BAZ', 'QUX']
runs ->
req = service.makeRequest('mockMethod')
req.on 'send', (resp) -> req.abort()
req.send (e, d) -> done = true; error = e; data = d
waitsFor -> done
runs ->
expect(data).toEqual(null)
expect(error.code).toEqual('RequestAbortedError')
expect(error.message).toMatch(/aborted by user/)
if AWS.util.isNode()
describe 'createReadStream', ->
it 'streams data', ->
data = ''; done = false
helpers.mockHttpResponse 200, {}, ['FOO', 'BAR', 'BAZ', 'QUX']
runs ->
request = service.makeRequest('mockMethod')
s = request.createReadStream()
s.on 'end', -> done = true
s.on 'data', (c) -> data += c.toString()
waitsFor -> done == true
runs ->
expect(data).toEqual('FOOBARBAZQUX')
it 'streams2 data (readable event)', ->
if AWS.HttpClient.streamsApiVersion < 2
return
data = ''; done = false
helpers.mockHttpResponse 200, {}, ['FOO', 'BAR', 'BAZ', 'QUX']
runs ->
request = service.makeRequest('mockMethod')
s = request.createReadStream()
s.on 'end', -> done = true
s.on 'readable', ->
try
chunk = s.read()
if chunk
data += chunk
catch e
console.log(e.stack)
waitsFor -> done == true
runs ->
expect(data).toEqual('FOOBARBAZQUX')
it 'streams2 data does not hang out while waiting response', ->
if AWS.HttpClient.streamsApiVersion < 2
return
data = ''; done = false
helpers.mockHttpResponse 200, {}, ['FOO', 'BAR', null, null, 'BAZ', 'QUX']
runs ->
request = service.makeRequest('mockMethod')
s = request.createReadStream()
s.on 'end', -> done = true
s.on 'readable', ->
try
chunk = s.read()
if chunk
data += chunk
catch e
console.log(e.stack)
waitsFor -> done == true
runs ->
expect(data).toEqual('FOOBARBAZQUX')
it 'does not stream data on failures', ->
data = ''; error = null; done = false
helpers.mockHttpResponse 404, {}, ['No such file']
runs ->
request = service.makeRequest('mockMethod')
s = request.createReadStream()
s.on 'end', -> done = true
s.on 'error', (e) -> error = e; done = true
s.on 'data', (c) -> data += c.toString()
waitsFor -> done == true
runs ->
expect(data).toEqual('')
expect(error.statusCode).toEqual(404)
it 'retries temporal errors and streams resulting successful response', ->
data = ''; error = null; done = false
helpers.mockIntermittentFailureResponse 2, 200, {}, ['FOO', 'BAR', 'BAZ', 'QUX']
runs ->
request = service.makeRequest('mockMethod')
s = request.createReadStream()
s.on 'end', -> done = true
s.on 'error', (e) -> error = e; done = true
s.on 'data', (c) -> data += c.toString()
waitsFor -> done == true
runs ->
expect(data).toEqual('FOOBARBAZQUX')
expect(error).toEqual(null)
it 'streams partial data and raises an error', ->
data = ''; error = null; reqError = null; done = false
spyOn(AWS.HttpClient, 'getInstance')
AWS.HttpClient.getInstance.andReturn handleRequest: (req, opts, cb, errCb) ->
req = new EventEmitter()
req.statusCode = 200
req.headers = {}
cb(req)
req.emit('headers', 200, {})
AWS.util.arrayEach ['FOO', 'BAR', 'BAZ'], (str) ->
req.emit 'data', new Buffer(str)
errCb new Error('fail')
req
runs ->
request = service.makeRequest('mockMethod')
request.on 'error', (e) -> reqError = e
request.on 'complete', -> done = true
s = request.createReadStream()
s.on 'error', (e) -> error = e
s.on 'data', (c) -> data += c.toString()
waitsFor -> done == true
runs ->
expect(data).toEqual('FOOBARBAZ')
expect(error.message).toEqual('fail')
expect(reqError.message).toEqual('fail')
it 'fails if retry occurs in the middle of a failing stream', ->
data = ''; error = null; reqError = null; resp = null
retryCount = 0
spyOn(AWS.HttpClient, 'getInstance')
AWS.HttpClient.getInstance.andReturn handleRequest: (req, opts, cb, errCb) ->
req = new EventEmitter()
req.statusCode = 200
req.headers = {}
process.nextTick ->
cb(req)
req.emit('headers', 200, {})
AWS.util.arrayEach ['FOO', 'BAR', 'BAZ', 'QUX'], (str) ->
if str == 'BAZ' and retryCount < 1
process.nextTick ->
retryCount += 1
errCb code: 'NetworkingError', message: 'FAIL!', retryable: true
return AWS.util.abort
else
process.nextTick -> req.emit 'data', new Buffer(str)
if retryCount >= 1
process.nextTick -> req.emit('end')
req
runs ->
request = service.makeRequest('mockMethod')
request.on 'error', (e) -> reqError = e
request.on 'complete', (r) -> resp = r
s = request.createReadStream()
s.on 'error', (e) -> error = e
s.on 'data', (c) -> data += c.toString()
waitsFor -> resp != null
runs ->
expect(data).toEqual('FOOBAR')
expect(error.code).toEqual('NetworkingError')
expect(reqError.code).toEqual('NetworkingError')
expect(reqError.hostname).toEqual('mockservice.mock-region.amazonaws.com')
expect(reqError.region).toEqual('mock-region')
expect(resp.retryCount).toEqual(0)
Zerion Mini Shell 1.0