aws-sdk 2.0.1 → 2.0.5

package/test/request.spec.coffee

@@ -0,0 +1,316 @@
+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)

package/test/resource_waiter.spec.coffee

@@ -0,0 +1,89 @@
+helpers = require('./helpers')
+AWS = helpers.AWS
+
+describe 'AWS.ResourceWaiter', ->
+  describe 'wait', ->
+    it 'waits until a given state is met', ->
+      err = null; data = null; resp = null
+      db = new AWS.DynamoDB
+      helpers.mockResponses db, [
+        {data: {Table: TableStatus: 'LOADING'}},
+        {data: {Table: TableStatus: 'LOADING'}},
+        {data: {Table: TableStatus: 'ACTIVE'}}
+      ]
+
+      waiter = new AWS.ResourceWaiter(db, 'tableExists')
+      waiter.wait (e, d) -> resp = this; err = e; data = d
+      expect(err).toEqual(null)
+      expect(data.Table.TableStatus).toEqual('ACTIVE')
+      expect(resp.retryCount).toEqual(2)
+
+    it 'can override the final state', ->
+      err = null; data = null; resp = null
+      db = new AWS.DynamoDB
+      helpers.mockResponses db, [
+        {data: {Table: TableStatus: 'LOADING'}},
+        {data: {Table: TableStatus: 'LOADING'}},
+        {data: {Table: TableStatus: 'ACTIVE'}},
+        {data: {Table: TableStatus: 'FOO'}}
+      ]
+
+      waiter = new AWS.ResourceWaiter(db, {tableExists: 'FOO'})
+      waiter.wait (e, d) -> resp = this; err = e; data = d
+      expect(err).toEqual(null)
+      expect(data.Table.TableStatus).toEqual('FOO')
+      expect(resp.retryCount).toEqual(3)
+
+    it 'throws an error if terminal state is not configured', ->
+      try
+        new AWS.ResourceWaiter(new AWS.DynamoDB, 'invalidState')
+      catch e
+        err = e
+      expect(err.message).toEqual('State invalidState not found.')
+
+    it 'gives up after a maximum number of retries', ->
+      err = null; data = null; resp = null
+      db = new AWS.DynamoDB
+      resps = ({data: {Table: {TableStatus: 'LOADING'}}} for _ in [1..26])
+      resps.push({data: {Table: {TableStatus: 'ACTIVE'}}})
+      helpers.mockResponses db, resps
+
+      waiter = new AWS.ResourceWaiter(db, 'tableExists')
+      waiter.wait (e, d) -> resp = this; err = e; data = d
+      expect(data).toEqual(null)
+      expect(err.code).toEqual('ResourceNotReady')
+      expect(resp.retryCount).toEqual(25)          # 25 max retries
+      expect(resp.error.retryDelay).toEqual(20000) # 20s delay
+
+    it 'accepts error state as a terminal state', ->
+      err = null; data = null; resp = null
+      s3 = new AWS.S3
+      helpers.mockResponses s3, [
+        {httpResponse: {statusCode: 200}},
+        {httpResponse: {statusCode: 200}},
+        {httpResponse: {statusCode: 404}}
+      ]
+
+      waiter = new AWS.ResourceWaiter(s3, 'bucketNotExists')
+      waiter.wait Bucket: 'bucket', (e, d) -> resp = this; err = e; data = d
+      expect(err).toEqual(null)
+      expect(resp.httpResponse.statusCode).toEqual(404)
+      expect(resp.retryCount).toEqual(3)
+
+    it 'fails fast if failure value is found', ->
+      err = null; data = null; resp = null
+      ec2 = new AWS.EC2
+      helpers.mockResponses ec2, [
+        {data: {Reservations: [{Instances: [{State: {Name: 'pending'}}]}]}},
+        {data: {Reservations: [{Instances: [{State: {Name: 'pending'}}]}]}},
+        {data: {Reservations: [{Instances: [{State: {Name: 'pending'}}]}]}},
+        {data: {Reservations: [{Instances: [{State: {Name: 'terminated'}}]}]}},
+        {data: {Reservations: [{Instances: [{State: {Name: 'pending'}}]}]}},
+        {data: {Reservations: [{Instances: [{State: {Name: 'running'}}]}]}}
+      ]
+
+      waiter = new AWS.ResourceWaiter(ec2, 'instanceRunning')
+      waiter.wait InstanceIds: ['id-123456'], (e, d) -> resp = this; err = e; data = d
+      expect(data).toEqual(null)
+      expect(err.code).toEqual('ResourceNotReady')
+      expect(resp.retryCount).toEqual(3)

package/test/response.spec.coffee

@@ -0,0 +1,81 @@
+helpers = require('./helpers')
+EventEmitter = require('events').EventEmitter
+AWS = helpers.AWS
+
+describe 'AWS.Response', ->
+  service = null; response = null
+
+  beforeEach ->
+    service = new AWS.Service apiConfig: new AWS.Model.Api operations: op: {}
+    response = new AWS.Response(service.makeRequest('op'))
+
+  makePageable = ->
+    service.api.paginators.op = new AWS.Model.Paginator 'op',
+      limit_key: 'Limit'
+      input_token: 'Marker'
+      output_token: 'Marker'
+      result_key: 'Result'
+
+  fill = (err, data, pageable) ->
+    makePageable() if pageable
+    response.error = err
+    response.data = data
+
+  describe 'hasNextPage', ->
+    it 'returns undefined if the request is not pageable', ->
+      fill(null, Marker: 'next_page')
+      expect(response.hasNextPage()).toEqual(undefined)
+
+    it 'returns false if there is no marker in the response', ->
+      fill(null, {}, true)
+      expect(response.hasNextPage()).toEqual(false)
+
+    it 'returns false if the response returned an error', ->
+      fill(new Error, null, true)
+      expect(response.hasNextPage()).toEqual(false)
+
+    it 'returns true if there is a marker in the response', ->
+      fill(null, Marker: 'next_page', true)
+      expect(response.hasNextPage()).toEqual(true)
+
+  describe 'nextPage', ->
+    it 'throws an exception if the operation has no pagination information', ->
+      service.api.pagination = {}
+      expect(-> response.nextPage()).toThrow('No pagination configuration for op')
+
+    it 'returns null if there are no more pages', ->
+      fill(null, {}, true)
+      expect(response.nextPage()).toEqual(null)
+
+    it 'returns a request object with the next page marker filled in params', ->
+      fill(null, Marker: 'next_page', true)
+      req = response.nextPage()
+      expect(req.params.Marker).toEqual('next_page')
+      expect(req.operation).toEqual(response.request.operation)
+
+    it 'throws error if response returned an error and there is no callback', ->
+      fill(new Error('error!'), null, true)
+      expect(-> response.nextPage()).toThrow('error!')
+
+    it 'sends the request if passed with a callback', ->
+      err = null; data = null
+      helpers.mockHttpResponse 200, {}, ['']
+      fill(null, Marker: 'next_page', true)
+      runs ->
+        response.nextPage (e, d) -> err = e; data = d
+      waitsFor -> err || data
+      runs ->
+        expect(err).toEqual(null)
+        expect(data).toEqual({})
+
+    it 'passes null to callback if there are no more pages', ->
+      fill(null, {}, true)
+      response.nextPage (err, data) ->
+        expect(err).toEqual(null)
+        expect(data).toEqual(null)
+
+    it 'passes error through if original response returned an error', ->
+      fill('error!', null, true)
+      response.nextPage (err, data) ->
+        expect(err).toEqual('error!')
+        expect(data).toEqual(null)

package/test/sequential_executor.spec.coffee

@@ -0,0 +1,118 @@
+helpers = require('./helpers')
+AWS = helpers.AWS
+
+describe 'AWS.SequentialExecutor', ->
+  beforeEach -> @emitter = new AWS.SequentialExecutor()
+
+  describe 'addListeners', ->
+    it 'accepts a hash of events and functions', ->
+      triggers = [0, 0, 0]
+      listeners =
+        eventName:
+          ConstantName1: -> triggers[0] = 1
+          ConstantName2: -> triggers[1] = 1
+        otherEventName:
+          ConstantName3: -> triggers[2] = 1
+
+      @emitter.addListeners(listeners)
+      expect(triggers).toEqual([0, 0, 0])
+
+      @emitter.emit('eventName')
+      expect(triggers).toEqual([1, 1, 0])
+
+      @emitter.emit('otherEventName')
+      expect(triggers).toEqual([1, 1, 1])
+
+    it 'accepts a SequentialExecutor object', ->
+      triggers = [0, 0, 0]
+      listeners = new AWS.SequentialExecutor()
+      listeners.on 'eventName', -> triggers[0] = 1
+      listeners.on 'eventName', -> triggers[1] = 1
+      listeners.on 'otherEventName', -> triggers[2] = 1
+
+      @emitter.addListeners(listeners)
+      expect(triggers).toEqual([0, 0, 0])
+
+      @emitter.emit('eventName')
+      expect(triggers).toEqual([1, 1, 0])
+
+      @emitter.emit('otherEventName')
+      expect(triggers).toEqual([1, 1, 1])
+
+  describe 'addNamedListener', ->
+    it 'defines a constant with the callback', ->
+      spy = jasmine.createSpy()
+      @emitter.addNamedListener('CONSTNAME', 'eventName', spy)
+      expect(@emitter.CONSTNAME).toBe(spy)
+
+      # also verify that event is hooked up like normal
+      @emitter.emit('eventName', ['argument'])
+      expect(spy).toHaveBeenCalledWith('argument')
+
+    it 'is chainable', ->
+      r = @emitter.addNamedListener('CONSTNAME', 'eventName', ->)
+      expect(r).toBe(@emitter)
+
+  describe 'addNamedListeners', ->
+    it 'is chainable', ->
+      r = @emitter.addNamedListeners(->)
+      expect(r).toBe(@emitter)
+
+    it 'provides an add function in callback to call addNamedListener', ->
+      spy1 = jasmine.createSpy(); spy2 = jasmine.createSpy()
+      @emitter.addNamedListeners (add) ->
+        add('CONST1', 'event1', spy1)
+        add('CONST2', 'event2', spy2)
+
+      expect(@emitter.CONST1).toBe(spy1)
+      expect(@emitter.CONST2).toBe(spy2)
+
+      @emitter.emit('event1', ['arg1'])
+      @emitter.emit('event2', ['arg2'])
+
+      expect(spy1).toHaveBeenCalledWith('arg1')
+      expect(spy2).toHaveBeenCalledWith('arg2')
+
+  describe 'emit', ->
+    it 'emits to all listeners', ->
+      list = []
+      @emitter.on 'event1', -> list.push(1)
+      @emitter.on 'event1', -> list.push(2)
+      @emitter.on 'event1', -> list.push(3)
+      @emitter.emit('event1')
+      expect(list).toEqual([1,2,3])
+
+    it 'stops emitting if error is returned', ->
+      list = []
+      @emitter.on 'event1', -> list.push(1)
+      @emitter.on 'event1', -> list.push(2); throw new Error('error')
+      @emitter.on 'event1', -> list.push(3)
+      expect(=> @emitter.emit 'event1').toThrow('error')
+      expect(list).toEqual([1,2])
+
+    it 'stops emitting if error is returned (async)', ->
+      list = []
+      @emitter.on 'event1', -> list.push(1)
+      @emitter.onAsync 'event1', (err, done) -> list.push(2); done('ERROR')
+      @emitter.on 'event1', -> list.push(3)
+      @emitter.emit 'event1', [null], (err) ->
+        expect(err).toEqual('ERROR')
+        expect(list).toEqual([1,2])
+
+  if AWS.util.isNode()
+    describe 'domain support', ->
+      domain = null
+      beforeEach -> domain = require('domain').create()
+      afterEach -> domain.dispose()
+
+      it 'supports domains', ->
+        helpers.mockHttpResponse 200, {}, 'Success!'
+
+        thrown = null
+        domain.on 'error', (err) -> thrown = err
+        domain.run ->
+          service = new MockService()
+          service.makeRequest 'operationName', ->
+            invalidCode
+
+        expect(thrown.name).toEqual('ReferenceError')