%PDF-
%PDF-
Mini Shell
Mini Shell
helpers = require('../helpers'); AWS = helpers.AWS
describe 'AWS.XML.Parser', ->
parse = (xml, rules, callback) ->
if rules
shape = AWS.Model.Shape.create(rules, api: {})
else
shape = {}
callback.call(this, new AWS.XML.Parser().parse(xml, shape))
describe 'default behavior', ->
rules = null # no rules, rely on default parsing behavior
it 'returns empty object when string is empty', ->
parse '', null, (data) -> expect(data).toEqual({})
it 'returns an empty object from an empty document', ->
xml = '<xml/>'
parse xml, rules, (data) ->
expect(data).toEqual({})
it 'returns empty elements as empty string', ->
xml = '<xml><element/></xml>'
parse xml, rules, (data) ->
expect(data).toEqual({element:''})
it 'converts string elements to properties', ->
xml = '<xml><foo>abc</foo><bar>xyz</bar></xml>'
parse xml, rules, (data) ->
expect(data).toEqual({foo:'abc', bar:'xyz'})
it 'converts nested elements into objects', ->
xml = '<xml><foo><bar>yuck</bar></foo></xml>'
parse xml, rules, (data) ->
expect(data).toEqual({foo:{bar:'yuck'}})
it 'returns everything as a string (even numbers)', ->
xml = '<xml><count>123</count></xml>'
parse xml, rules, (data) ->
expect(data).toEqual({count:'123'})
it 'ignores xmlns on the root element', ->
xml = '<xml xmlns="http://foo.bar.com"><Abc>xyz</Abc></xml>'
parse xml, rules, (data) ->
expect(data).toEqual({Abc:'xyz'})
describe 'structures', ->
it 'returns empty objects as {}', ->
xml = '<xml><Item/></xml>'
rules =
type: 'structure'
members:
Item:
type: 'structure'
members:
Name:
type: 'string'
parse xml, rules, (data) ->
expect(data).toEqual({Item:{}})
it 'parses attributes from tags', ->
xml = '<xml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Item xsi:name="name"></Item></xml>'
rules =
type: 'structure'
members:
Item:
type: 'structure'
members:
Name:
type: 'string'
xmlAttribute: true
locationName: 'xsi:name'
parse xml, rules, (data) ->
expect(data).toEqual({Item:{Name: 'name'}})
describe 'lists', ->
it 'returns empty lists as []', ->
xml = '<xml><items/></xml>'
rules =
type: 'structure'
members:
items:
type: 'list'
member:
type: 'string'
parse xml, rules, (data) ->
expect(data).toEqual({items:[]})
it 'returns missing lists as []', ->
xml = '<xml></xml>'
rules =
type: 'structure'
members:
items:
type: 'list'
member:
type: 'string'
parse xml, rules, (data) ->
expect(data).toEqual({items:[]})
it 'Converts xml lists of strings into arrays of strings', ->
xml = """
<xml>
<items>
<member>abc</member>
<member>xyz</member>
</items>
</xml>
"""
rules =
type: 'structure'
members:
items:
type: 'list'
member: {}
parse xml, rules, (data) ->
expect(data).toEqual({items:['abc','xyz']})
it 'observes list member names when present', ->
xml = """
<xml>
<items>
<item>abc</item>
<item>xyz</item>
</items>
</xml>
"""
rules =
type: 'structure'
members:
items:
type: 'list'
member:
locationName: 'item'
parse xml, rules, (data) ->
expect(data).toEqual({items:['abc','xyz']})
it 'can parse lists of strucures', ->
xml = """
<xml>
<People>
<member><Name>abc</Name></member>>
<member><Name>xyz</Name></member>>
</People>
</xml>
"""
rules =
type: 'structure'
members:
People:
type: 'list'
member:
type: 'structure'
members:
Name:
type: 'string'
parse xml, rules, (data) ->
expect(data).toEqual({People:[{Name:'abc'},{Name:'xyz'}]})
it 'can parse lists of strucures with renames', ->
xml = """
<xml>
<People>
<Person><Name>abc</Name></Person>>
<Person><Name>xyz</Name></Person>>
</People>
</xml>
"""
rules =
type: 'structure'
members:
People:
type: 'list'
member:
type: 'structure'
locationName: 'Person'
members:
Name:
type: 'string'
parse xml, rules, (data) ->
expect(data).toEqual({People:[{Name:'abc'},{Name:'xyz'}]})
describe 'flattened lists', ->
xml = """
<xml>
<person>
<name>Unknown</name>
<alias>John Doe</alias>
<alias>Jane Doe</alias>
</person>
</xml>
"""
it 'collects sibling elements of the same name', ->
rules =
type: 'structure'
members:
person:
type: 'structure'
members:
name: {}
aka:
type: 'list'
flattened: true
member:
locationName: 'alias'
parse xml, rules, (data) ->
expect(data).toEqual({person:{name:'Unknown',aka:['John Doe', 'Jane Doe']}})
it 'flattened lists can be composed of complex obects', ->
xml = """
<xml>
<name>Name</name>
<complexValue>
<a>1</a>
<b>2</b>
</complexValue>
<complexValue>
<a>3</a>
<b>4</b>
</complexValue>
</xml>
"""
rules =
type: 'structure'
members:
name:
type: 'string'
values:
type: 'list'
flattened: true
member:
locationName: 'complexValue'
type: 'structure'
members:
a: type: 'integer'
b: type: 'integer'
values = {name:'Name',values:[{a:1,b:2},{a:3,b:4}]}
parse xml, rules, (data) ->
expect(data).toEqual(values)
it 'can parse flattened lists of complex objects', ->
xml = """
<xml>
<Count>2</Count>
<Person><Name>abc</Name></Person>
<Person><Name>xyz</Name></Person>
</xml>
"""
rules =
type: 'structure'
members:
Count:
type: 'integer'
People:
type: 'list'
flattened: true
member:
type: 'structure'
locationName: 'Person'
members:
Name: {}
parse xml, rules, (data) ->
expect(data).toEqual({Count:2,People:[{Name:'abc'},{Name:'xyz'}]})
describe 'maps', ->
describe 'non-flattened', ->
it 'expects entry, key, and value elements by default', ->
# example from IAM GetAccountSummary (output)
xml = """
<xml>
<SummaryMap>
<entry>
<key>Groups</key>
<value>31</value>
</entry>
<entry>
<key>GroupsQuota</key>
<value>50</value>
</entry>
<entry>
<key>UsersQuota</key>
<value>150</value>
</entry>
</SummaryMap>
</xml>
"""
rules =
type: 'structure'
members:
SummaryMap:
type: 'map'
value:
type: 'integer'
parse xml, rules, (data) ->
expect(data).toEqual(SummaryMap:{Groups:31,GroupsQuota:50,UsersQuota:150})
it 'can use alternate names for key and value elements', ->
# using Property/Count instead of key/value, also applied a name
# trait to the Summary map to rename it
xml = """
<xml>
<SummaryMap>
<entry>
<Property>Groups</Property>
<Count>31</Count>
</entry>
<entry>
<Property>GroupsQuota</Property>
<Count>50</Count>
</entry>
<entry>
<Property>UsersQuota</Property>
<Count>150</Count>
</entry>
</SummaryMap>
</xml>
"""
rules =
type: 'structure'
members:
Summary:
type: 'map'
locationName: 'SummaryMap',
key:
locationName: 'Property'
value:
type: 'integer'
locationName: 'Count'
parse xml, rules, (data) ->
expect(data).toEqual(Summary:{Groups:31,GroupsQuota:50,UsersQuota:150})
describe 'flattened', ->
it 'expects key and value elements by default', ->
xml = """
<xml>
<Attributes>
<key>color</key>
<value>red</value>
</Attributes>
<Attributes>
<key>size</key>
<value>large</value>
</Attributes>
</xml>
"""
rules =
type: 'structure'
members:
Attributes:
type: 'map'
flattened: true
parse xml, rules, (data) ->
expect(data).toEqual({Attributes:{color:'red',size:'large'}})
it 'can use alternate names for key and value elements', ->
# using AttrName/AttrValue instead of key/value, also applied a name
# trait to the Attributes map
xml = """
<xml>
<Attribute>
<AttrName>age</AttrName>
<AttrValue>35</AttrValue>
</Attribute>
<Attribute>
<AttrName>height</AttrName>
<AttrValue>72</AttrValue>
</Attribute>
</xml>
"""
rules =
type: 'structure'
members:
Attributes:
locationName: 'Attribute'
type: 'map'
flattened: true
key:
locationName: 'AttrName'
value:
locationName: 'AttrValue'
type: 'integer'
parse xml, rules, (data) ->
expect(data).toEqual({Attributes:{age:35,height:72}})
describe 'booleans', ->
rules =
type: 'structure'
members:
enabled:
type: 'boolean'
it 'converts the string "true" in to the boolean value true', ->
xml = "<xml><enabled>true</enabled></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({enabled:true})
it 'converts the string "false" in to the boolean value false', ->
xml = "<xml><enabled>false</enabled></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({enabled:false})
it 'converts the empty elements into null', ->
xml = "<xml><enabled/></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({enabled:null})
describe 'timestamp', ->
rules =
type: 'structure'
members:
CreatedAt:
type: 'timestamp'
it 'returns an empty element as null', ->
xml = "<xml><CreatedAt/></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({CreatedAt:null})
it 'understands unix timestamps', ->
timestamp = 1349908100
date = new Date(timestamp * 1000)
xml = "<xml><CreatedAt>#{timestamp}</CreatedAt></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({CreatedAt:date})
it 'understands basic iso8601 strings', ->
timestamp = '2012-10-10T15:47:10.001Z'
date = new Date(timestamp)
xml = "<xml><CreatedAt>#{timestamp}</CreatedAt></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({CreatedAt:date})
it 'understands basic rfc822 strings', ->
timestamp = 'Wed, 10 Oct 2012 15:59:55 UTC'
date = new Date(timestamp)
xml = "<xml><CreatedAt>#{timestamp}</CreatedAt></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({CreatedAt:date})
it 'throws an error when unable to determine the format', ->
timestamp = 'bad-date-format'
xml = "<xml><CreatedAt>#{timestamp}</CreatedAt></xml>"
message = 'unhandled timestamp format: ' + timestamp
error = {}
try
parse(xml, rules, ->)
catch e
error = e
expect(error.message).toEqual(message)
describe 'numbers', ->
rules =
type: 'structure'
members:
decimal:
type: 'float'
it 'float parses elements types as integer', ->
xml = "<xml><decimal>123.456</decimal></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({decimal:123.456})
it 'returns null for empty elements', ->
xml = "<xml><decimal/></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({decimal:null})
describe 'integers', ->
rules =
type: 'structure'
members:
count:
type: 'integer'
it 'integer parses elements types as integer', ->
xml = "<xml><count>123</count></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({count:123})
it 'returns null for empty elements', ->
xml = "<xml><count/></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({count:null})
describe 'renaming elements', ->
it 'can rename scalar elements', ->
rules =
type: 'structure'
members:
aka:
locationName: 'alias'
xml = "<xml><alias>John Doe</alias></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({aka:'John Doe'})
it 'can rename nested elements', ->
rules =
type: 'structure'
members:
person:
members:
name: {}
aka:
locationName: 'alias'
xml = "<xml><person><name>Joe</name><alias>John Doe</alias></person></xml>"
parse xml, rules, (data) ->
expect(data).toEqual({person:{name:'Joe',aka:'John Doe'}})
describe 'base64 encoded strings', ->
it 'base64 decodes string elements with encoding="base64"', ->
rules =
type: 'structure'
members:
Value:
type: 'string'
xml = """
<xml>
<Value encoding="base64">Zm9v</Value>
</xml>
"""
parse xml, rules, (data) ->
expect(data.Value.toString()).toEqual('foo')
rules =
type: 'structure'
members:
Value: {}
xml = """
<xml>
<Value encoding="base64">Zm9v</Value>
</xml>
"""
parse xml, rules, (data) ->
expect(data.Value.toString()).toEqual('foo')
describe 'elements with XML namespaces', ->
it 'strips the xmlns element', ->
rules =
type: 'structure'
members:
List:
type: 'list'
member:
type: 'structure'
members:
Attr1: {}
Attr2:
type: 'structure'
members:
Foo: {}
xml = """
<xml xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<List>
<member>
<Attr1 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">abc</Attr1>
<Attr2 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser"><Foo>bar</Foo></Attr2>
</member>
</List>
</xml>
"""
parse xml, rules, (data) ->
expect(data).toEqual({List:[{Attr1:'abc',Attr2:{Foo:'bar'}}]})
describe 'parsing errors', ->
it 'throws an error when unable to parse the xml', ->
xml = 'asdf'
rules = {}
error = {}
try
new AWS.XML.Parser().parse(xml, rules)
catch e
error = e
expect(error.code).toEqual('XMLParserError')
Zerion Mini Shell 1.0