aws-sdk 2.0.1 → 2.0.5

package/test/json/builder.spec.coffee

@@ -0,0 +1,129 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.JSON.Builder', ->
+
+  builder = new AWS.JSON.Builder()
+  timestampFormat = 'iso8601'
+  api = null
+
+  beforeEach ->
+    api = new AWS.Model.Api
+      metadata:
+        timestampFormat: timestampFormat
+        protocol: 'json'
+
+  build = (rules, params) ->
+    shape = AWS.Model.Shape.create(rules, api: api)
+    builder.build(params, shape)
+
+  describe 'build', ->
+
+    it 'returns an empty document when there are no params', ->
+      expect(build({}, {})).toEqual("{}")
+
+    describe 'structures', ->
+      rules =
+        type: 'structure'
+        members:
+          Items:
+            type: 'structure'
+            members:
+              A: type: 'string'
+              B: type: 'string'
+
+      it 'translates input', ->
+        params = { Items: { A: 'a', B: 'b' } }
+        expect(build(rules, params)).toEqual('{"Items":{"A":"a","B":"b"}}')
+
+      it 'ignores null', ->
+        expect(build(rules, Items: null)).toEqual('{}')
+
+      it 'ignores undefined', ->
+        expect(build(rules, Items: undefined)).toEqual('{}')
+
+    describe 'lists', ->
+      rules =
+        type: 'structure'
+        members:
+          Items:
+            type: 'list'
+            member:
+              type: 'string'
+
+      it 'translates input', ->
+        params = Items: ['a', 'b', 'c']
+        expect(build(rules, params)).toEqual('{"Items":["a","b","c"]}')
+
+      it 'ignores null', ->
+        expect(build(rules, Items: null)).toEqual('{}')
+
+      it 'ignores undefined', ->
+        expect(build(rules, Items: undefined)).toEqual('{}')
+
+    describe 'maps', ->
+      rules =
+        type: 'structure'
+        members:
+          Items:
+            type: 'map'
+            key: type: 'string'
+            value: type: 'string'
+
+      it 'translates maps', ->
+        params = { Items: { A: 'a', B: 'b' } }
+        expect(build(rules, params)).toEqual('{"Items":{"A":"a","B":"b"}}')
+
+      it 'ignores null', ->
+        expect(build(rules, Items: null)).toEqual('{}')
+
+      it 'ignores undefined', ->
+        expect(build(rules, Items: undefined)).toEqual('{}')
+
+    it 'translates nested maps', ->
+      rules =
+        type: 'structure'
+        members:
+          Items: type: 'map', value: type: 'integer'
+      now = new Date()
+      now.setMilliseconds(100)
+      params = Items: MyKey: "5", MyOtherKey: "10"
+      str = '{"Items":{"MyKey":5,"MyOtherKey":10}}'
+      expect(build(rules, params)).toEqual(str)
+
+    it 'traslates nested timestamps', ->
+      rules =
+        type: 'structure'
+        members:
+          Build:
+            type: 'structure'
+            members:
+              When:
+                type: 'timestamp'
+      now = new Date()
+      now.setMilliseconds(100)
+      params = Build: When: now
+      formatted = AWS.util.date.iso8601(now).replace(/\.\d+Z$/, '')
+      expect(build(rules, params)).toMatch('\\{"Build":\\{"When":"'+formatted+'\\.\\d+Z"\\}\\}')
+
+    it 'translates integers formatted as strings', ->
+      rules =
+        type: 'structure'
+        members:
+          Integer: type: 'integer'
+      expect(build(rules, Integer: '20')).toEqual('{"Integer":20}')
+
+    it 'translates floats formatted as strings', ->
+      rules =
+        type: 'structure'
+        members:
+          Float: type: 'float'
+      expect(build(rules, Float: '20.1')).toEqual('{"Float":20.1}')
+
+    it 'ignores nulls null as null', ->
+      rules =
+        type: 'structure'
+        members:
+          Float: type: 'float'
+          Other: type: 'string'
+      expect(build(rules, Float: null, Other: 'foo')).toEqual('{"Other":"foo"}')

package/test/json/parser.spec.coffee

@@ -0,0 +1,108 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.JSON.Parser', ->
+
+  parser = new AWS.JSON.Parser()
+  timestampFormat = 'iso8601'
+  api = null
+
+  beforeEach ->
+    api = new AWS.Model.Api metadata: timestampFormat: timestampFormat
+
+  parse = (rules, params) ->
+    shape = AWS.Model.Shape.create(rules, api: api)
+    parser.parse(params, shape)
+
+  describe 'parse', ->
+
+    it 'returns an empty document when there are no params', ->
+      expect(parse({}, '{}')).toEqual({})
+
+    describe 'structures', ->
+      rules =
+        type: 'structure'
+        members:
+          Items:
+            type: 'structure'
+            members:
+              A: type: 'string'
+              B: type: 'string'
+
+      it 'translates input', ->
+        params = '{ "Items": { "A": "a", "B": "b" } }'
+        expect(parse(rules, params)).toEqual({"Items":{"A":"a","B":"b"}})
+
+      it 'ignores null', ->
+        expect(parse(rules, '{"Items": null}')).toEqual({})
+
+    describe 'lists', ->
+      rules =
+        type: 'structure'
+        members:
+          Items:
+            type: 'list'
+            member:
+              type: 'string'
+
+      it 'translates input', ->
+        params = '{"Items":["a","b","c"]}'
+        expect(parse(rules, params)).toEqual(Items: ['a', 'b', 'c'])
+
+      it 'ignores null', ->
+        expect(parse(rules, '{"Items": null}')).toEqual({})
+
+    describe 'maps', ->
+      rules =
+        type: 'structure'
+        members:
+          Items:
+            type: 'map'
+            key: type: 'string'
+            value: type: 'string'
+
+      it 'translates maps', ->
+        params = '{"Items":{"A":"a","B":"b"}}'
+        expect(parse(rules, params)).toEqual({ Items: { A: 'a', B: 'b' } })
+
+      it 'ignores null', ->
+        expect(parse(rules, '{"Items": null}')).toEqual({})
+
+    it 'translates nested maps', ->
+      rules =
+        type: 'structure'
+        members:
+          Items: type: 'map', value: type: 'integer'
+      now = new Date()
+      now.setMilliseconds(100)
+      params = Items: MyKey: 5, MyOtherKey: 10
+      str = '{"Items":{"MyKey":5,"MyOtherKey":10}}'
+      expect(parse(rules, str)).toEqual(params)
+
+    it 'traslates nested timestamps', ->
+      rules =
+        type: 'structure'
+        members:
+          Build:
+            type: 'structure'
+            members:
+              When:
+                type: 'timestamp'
+      time = new Date(0)
+      params = Build: When: time
+      formatted = AWS.util.date.iso8601(time)
+      expect(parse(rules, '{"Build":{"When":"'+formatted+'"}}')).toEqual(params)
+
+    it 'translates binary types', ->
+      rules =
+        type: 'structure'
+        members:
+          Binary1:
+            type: 'binary'
+          Binary2:
+            type: 'base64'
+      data = parse(rules, '{"Binary1":"AQID","Binary2":"AQID"}')
+      expect(AWS.util.Buffer.isBuffer(data.Binary1))
+      expect(AWS.util.Buffer.isBuffer(data.Binary2))
+      expect(data.Binary1.toString()).toEqual('\u0001\u0002\u0003')
+      expect(data.Binary2.toString()).toEqual('\u0001\u0002\u0003')

package/test/metadata_service.spec.coffee

@@ -0,0 +1,54 @@
+helpers = require('./helpers')
+url = require('url')
+http = require('http')
+AWS = helpers.AWS
+
+if AWS.util.isNode()
+  describe 'AWS.MetadataService', ->
+    describe 'loadCredentials', ->
+      [server, port, service] = [null, 1024 + parseInt(Math.random() * 100), null]
+
+      beforeEach ->
+        service = new AWS.MetadataService(host: '127.0.0.1:' + port)
+        server = http.createServer (req, res) ->
+          re = new RegExp('^/latest/meta-data/iam/security-credentials/(.*)$')
+          match = url.parse(req.url).pathname.match(re)
+          if match
+            res.writeHead(200, 'Content-Type': 'text/plain')
+            if match[1] == ''
+              res.write('TestingRole\n')
+              res.write('TestingRole2\n')
+            else
+              data = '{"Code":"Success","AccessKeyId":"KEY","SecretAccessKey":"SECRET","Token":"TOKEN"}'
+              res.write(data)
+          else
+            res.writeHead(404, {})
+          res.end()
+
+        server.listen(port)
+
+      afterEach -> server.close() if server
+
+      it 'should load credentials from metadata service', ->
+        [err, data] = [null, null]
+        runs ->
+          service.loadCredentials (e, d) -> [err, data] = [e, d]
+        waitsFor -> err || data
+        runs ->
+          expect(err).toBe(null)
+          expect(data.Code).toEqual('Success')
+          expect(data.AccessKeyId).toEqual('KEY')
+          expect(data.SecretAccessKey).toEqual('SECRET')
+          expect(data.Token).toEqual('TOKEN')
+
+      it 'should fail if server is not up', ->
+        server.close(); server = null
+        service = new AWS.MetadataService(host: '255.255.255.255')
+        service.httpOptions.timeout = 10
+        [err, data] = [null, null]
+        runs ->
+          service.loadCredentials (e, d) -> [err, data] = [e, d]
+        waitsFor -> err || data
+        runs ->
+          expect(err instanceof Error).toBe(true)
+          expect(data).toEqual(null)

package/test/model/api.spec.coffee

@@ -0,0 +1,67 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+make = (obj, opts) -> new AWS.Model.Api(obj, opts)
+
+describe 'AWS.Model.Api', ->
+  describe 'loading', ->
+    it 'loads properties from metadata', ->
+      api = make metadata:
+        apiVersion: '1.0', endpointPrefix: 'endpoint', globalEndpoint: 'global'
+        signatureVersion: 'v4', protocol: 'json', timestampFormat: 'rfc822'
+        xmlNamespace: 'URI', serviceAbbreviation: 'abbr', serviceFullName: 'name'
+
+      expect(api.apiVersion).toEqual('1.0')
+      expect(api.endpointPrefix).toEqual('endpoint')
+      expect(api.globalEndpoint).toEqual('global')
+      expect(api.signatureVersion).toEqual('v4')
+      expect(api.protocol).toEqual('json')
+      expect(api.timestampFormat).toEqual('rfc822')
+      expect(api.xmlNamespaceUri).toEqual('URI')
+      expect(api.abbreviation).toEqual('abbr')
+      expect(api.fullName).toEqual('name')
+
+  describe 'isApi', ->
+    it 'is an API', ->
+      expect(make().isApi).toBe(true)
+
+  describe 'className', ->
+    it 'generates the correct class name from fullName', ->
+      api = make metadata: serviceFullName: 'Amazon Service Name HeRE'
+      expect(api.className).toEqual('ServiceNameHeRE')
+
+    it 'uses abbreviation if supplied', ->
+      api = make metadata: serviceAbbreviation: 'Amazon SNH'
+      expect(api.className).toEqual('SNH')
+
+    it 'special cases ELB', ->
+      api = make metadata: serviceFullName: 'AWS Elastic Load Balancing'
+      expect(api.className).toEqual('ELB')
+
+    it 'handles lack of service name', ->
+      expect(make().className).toEqual(null)
+
+  describe 'documentation', ->
+    it 'does not provide documentation by default', ->
+      api = make documentation: 'foo'
+      expect(api.documentation).toEqual(null)
+
+    it 'can attach documentation if option is enabled', ->
+      api = make {documentation: 'foo'}, documentation: true
+      expect(api.documentation).toEqual('foo')
+
+  describe 'shapes', ->
+    it 'creates a set of shapes', ->
+      api = make
+        shapes:
+          Shape1:
+            type: 'structure'
+            members:
+              Member1:
+                shape: 'MemberShape'
+                timestampFormat: 'rfc822'
+          MemberShape:
+            type: 'timestamp'
+            timestampFormat: 'iso8601'
+
+      expect(api.shapes.Shape1.members.Member1.type).toEqual('timestamp')

package/test/model/shape.spec.coffee

@@ -0,0 +1,23 @@
+helpers = require('../helpers')
+AWS = helpers.AWS
+
+describe 'AWS.Model.Shape', ->
+  describe 'TimestampShape', ->
+    describe 'toType()', ->
+      it 'converts unix timestamps', ->
+        api = new AWS.Model.Api metadata: timestampFormat: 'unixTimestamp'
+        shape = AWS.Model.Shape.create { type: 'timestamp' }, { api: api }
+        date = shape.toType(12300)
+        expect(date).toEqual(new Date(12300000))
+
+      it 'converts iso8601 timestamps', ->
+        api = new AWS.Model.Api metadata: timestampFormat: 'iso8601'
+        shape = AWS.Model.Shape.create { type: 'timestamp' }, { api: api }
+        date = shape.toType('1970-01-01T00:00:00.000Z')
+        expect(date).toEqual(new Date(0))
+
+      it 'converts rfc822 timestamps', ->
+        api = new AWS.Model.Api metadata: timestampFormat: 'rfc822'
+        shape = AWS.Model.Shape.create { type: 'timestamp' }, { api: api }
+        date = shape.toType('Thu, 01 Jan 1970 00:00:00 GMT')
+        expect(date).toEqual(new Date(0))

package/test/node_http_client.spec.coffee

@@ -0,0 +1,40 @@
+helpers = require('./helpers')
+AWS = helpers.AWS
+
+if AWS.util.isNode()
+  describe 'AWS.NodeHttpClient', ->
+    http = new AWS.NodeHttpClient()
+
+    describe 'maxSockets delegation', ->
+      it 'delegates maxSockets from agent to globalAgent', ->
+        https = require('https')
+        agent = http.sslAgent()
+        expect(https.globalAgent.maxSockets).toEqual(agent.maxSockets)
+        https.globalAgent.maxSockets += 1
+        expect(https.globalAgent.maxSockets).toEqual(agent.maxSockets)
+
+    describe 'handleRequest', ->
+      it 'emits error event', ->
+        error = null
+        req = new AWS.HttpRequest 'http://invalid'
+        runs ->
+          http.handleRequest req, {}, null, (err) ->
+            error = err
+        waitsFor -> error
+        runs ->
+          expect(error.code).toEqual 'ENOTFOUND'
+
+      it 'supports timeout in httpOptions', ->
+        error = null
+        numCalls = 0
+        req = new AWS.HttpRequest 'http://1.1.1.1'
+        runs ->
+          http.handleRequest req, {timeout: 1}, null, (err) ->
+            error = err
+            numCalls += 1
+
+        waitsFor((-> error), 'Timed out', 100)
+        runs ->
+          expect(error.code).toEqual 'TimeoutError'
+          expect(error.message).toEqual 'Connection timed out after 1ms'
+          expect(numCalls).toEqual 1