mirror of
https://github.com/sstent/node_app.git
synced 2026-01-26 15:13:02 +00:00
194 lines
9.0 KiB
CoffeeScript
194 lines
9.0 KiB
CoffeeScript
# use zap to run tests, it also detects CoffeeScript files
|
|
xml2js = require '../lib/xml2js'
|
|
fs = require 'fs'
|
|
util = require 'util'
|
|
assert = require 'assert'
|
|
path = require 'path'
|
|
|
|
fileName = path.join __dirname, '/fixtures/sample.xml'
|
|
|
|
skeleton = (options, checks) ->
|
|
(test) ->
|
|
xmlString = options?.__xmlString
|
|
delete options?.__xmlString
|
|
x2js = new xml2js.Parser options
|
|
x2js.addListener 'end', (r) ->
|
|
checks r
|
|
test.finish()
|
|
if not xmlString
|
|
fs.readFile fileName, (err, data) ->
|
|
x2js.parseString data
|
|
else
|
|
x2js.parseString xmlString
|
|
###
|
|
The `validator` function validates the value at the XPath. It also transforms the value
|
|
if necessary to conform to the schema or other validation information being used. If there
|
|
is an existing value at this path it is supplied in `currentValue` (e.g. this is the second or
|
|
later item in an array).
|
|
If the validation fails it should throw a `ValidationError`.
|
|
###
|
|
validator = (xpath, currentValue, newValue) ->
|
|
if xpath == '/sample/validatortest/numbertest'
|
|
return Number(newValue)
|
|
else if xpath in ['/sample/arraytest', '/sample/validatortest/emptyarray', '/sample/validatortest/oneitemarray']
|
|
if not ('item' of newValue)
|
|
return {'item': []}
|
|
else if xpath in ['/sample/arraytest/item', '/sample/validatortest/emptyarray/item', '/sample/validatortest/oneitemarray/item']
|
|
if not currentValue
|
|
return [newValue]
|
|
else if xpath == '/validationerror'
|
|
throw new xml2js.ValidationError("Validation error!")
|
|
return newValue
|
|
|
|
module.exports =
|
|
'test parse with defaults': skeleton(undefined, (r) ->
|
|
console.log 'Result object: ' + util.inspect(r, false, 10)
|
|
assert.equal r['chartest']['@']['desc'], 'Test for CHARs'
|
|
assert.equal r['chartest']['#'], 'Character data here!'
|
|
assert.equal r['cdatatest']['@']['desc'], 'Test for CDATA'
|
|
assert.equal r['cdatatest']['@']['misc'], 'true'
|
|
assert.equal r['cdatatest']['#'], 'CDATA here!'
|
|
assert.equal r['nochartest']['@']['desc'], 'No data'
|
|
assert.equal r['nochartest']['@']['misc'], 'false'
|
|
assert.equal r['listtest']['item'][0]['#'], 'This is character data!'
|
|
assert.equal r['listtest']['item'][0]['subitem'][0], 'Foo(1)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][1], 'Foo(2)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][2], 'Foo(3)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][3], 'Foo(4)'
|
|
assert.equal r['listtest']['item'][1], 'Qux.'
|
|
assert.equal r['listtest']['item'][2], 'Quux.')
|
|
|
|
'test parse with explicitCharkey': skeleton(explicitCharkey: true, (r) ->
|
|
assert.equal r['chartest']['@']['desc'], 'Test for CHARs'
|
|
assert.equal r['chartest']['#'], 'Character data here!'
|
|
assert.equal r['cdatatest']['@']['desc'], 'Test for CDATA'
|
|
assert.equal r['cdatatest']['@']['misc'], 'true'
|
|
assert.equal r['cdatatest']['#'], 'CDATA here!'
|
|
assert.equal r['nochartest']['@']['desc'], 'No data'
|
|
assert.equal r['nochartest']['@']['misc'], 'false'
|
|
assert.equal r['listtest']['item'][0]['#'], 'This is character data!'
|
|
assert.equal r['listtest']['item'][0]['subitem'][0]['#'], 'Foo(1)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][1]['#'], 'Foo(2)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][2]['#'], 'Foo(3)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][3]['#'], 'Foo(4)'
|
|
assert.equal r['listtest']['item'][1]['#'], 'Qux.'
|
|
assert.equal r['listtest']['item'][2]['#'], 'Quux.')
|
|
|
|
'test parse with mergeAttrs': skeleton(mergeAttrs: true, (r) ->
|
|
console.log 'Result object: ' + util.inspect(r, false, 10)
|
|
assert.equal r['chartest']['desc'], 'Test for CHARs'
|
|
assert.equal r['chartest']['#'], 'Character data here!'
|
|
assert.equal r['cdatatest']['desc'], 'Test for CDATA'
|
|
assert.equal r['cdatatest']['misc'], 'true'
|
|
assert.equal r['cdatatest']['#'], 'CDATA here!'
|
|
assert.equal r['nochartest']['desc'], 'No data'
|
|
assert.equal r['nochartest']['misc'], 'false'
|
|
assert.equal r['listtest']['item'][0]['#'], 'This is character data!'
|
|
assert.equal r['listtest']['item'][0]['subitem'][0], 'Foo(1)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][1], 'Foo(2)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][2], 'Foo(3)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][3], 'Foo(4)'
|
|
assert.equal r['listtest']['item'][1], 'Qux.'
|
|
assert.equal r['listtest']['item'][2], 'Quux.')
|
|
|
|
'test default text handling': skeleton(undefined, (r) ->
|
|
assert.equal r['whitespacetest']['#'], 'Line One Line Two')
|
|
|
|
'test disable trimming': skeleton(trim: false, (r) ->
|
|
assert.equal r['whitespacetest']['#'], 'Line One Line Two')
|
|
|
|
'test disable normalize': skeleton(normalize: false, (r) ->
|
|
assert.equal r['whitespacetest']['#'], 'Line One\n Line Two')
|
|
|
|
'test disable normalize and trim': skeleton(normalize: false, trim: false, (r) ->
|
|
assert.equal r['whitespacetest']['#'], '\n Line One\n Line Two\n ')
|
|
|
|
'test default root node elimination': skeleton(__xmlString: '<root></root>', (r) ->
|
|
assert.deepEqual r, {})
|
|
|
|
'test disabled root node elimination': skeleton(__xmlString: '<root></root>', explicitRoot: true, (r) ->
|
|
assert.deepEqual r, {root: {}})
|
|
|
|
'test default empty tag result': skeleton(undefined, (r) ->
|
|
assert.deepEqual r['emptytest'], {})
|
|
|
|
'test empty tag result specified null': skeleton(emptyTag: null, (r) ->
|
|
assert.equal r['emptytest'], null)
|
|
|
|
'test empty string result specified null': skeleton(__xmlString: ' ', (r) ->
|
|
assert.equal r, null)
|
|
|
|
'test parse with custom char and attribute object keys': skeleton(attrkey: 'attrobj', charkey: 'charobj', (r) ->
|
|
assert.equal r['chartest']['attrobj']['desc'], 'Test for CHARs'
|
|
assert.equal r['chartest']['charobj'], 'Character data here!'
|
|
assert.equal r['cdatatest']['attrobj']['desc'], 'Test for CDATA'
|
|
assert.equal r['cdatatest']['attrobj']['misc'], 'true'
|
|
assert.equal r['cdatatest']['charobj'], 'CDATA here!'
|
|
assert.equal r['nochartest']['attrobj']['desc'], 'No data'
|
|
assert.equal r['nochartest']['attrobj']['misc'], 'false')
|
|
|
|
'test child node without explicitArray': skeleton(explicitArray: false, (r) ->
|
|
assert.equal r['arraytest']['item'][0]['subitem'], 'Baz.'
|
|
assert.equal r['arraytest']['item'][1]['subitem'][0], 'Foo.'
|
|
assert.equal r['arraytest']['item'][1]['subitem'][1], 'Bar.')
|
|
|
|
'test child node with explicitArray': skeleton(explicitArray: true, (r) ->
|
|
assert.equal r['arraytest'][0]['item'][0]['subitem'][0], 'Baz.'
|
|
assert.equal r['arraytest'][0]['item'][1]['subitem'][0], 'Foo.'
|
|
assert.equal r['arraytest'][0]['item'][1]['subitem'][1], 'Bar.')
|
|
|
|
'test ignore attributes': skeleton(ignoreAttrs: true, (r) ->
|
|
assert.equal r['chartest'], 'Character data here!'
|
|
assert.equal r['cdatatest'], 'CDATA here!'
|
|
assert.deepEqual r['nochartest'], {}
|
|
assert.equal r['listtest']['item'][0]['#'], 'This is character data!'
|
|
assert.equal r['listtest']['item'][0]['subitem'][0], 'Foo(1)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][1], 'Foo(2)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][2], 'Foo(3)'
|
|
assert.equal r['listtest']['item'][0]['subitem'][3], 'Foo(4)'
|
|
assert.equal r['listtest']['item'][1], 'Qux.'
|
|
assert.equal r['listtest']['item'][2], 'Quux.')
|
|
|
|
'test simple callback mode': (test) ->
|
|
x2js = new xml2js.Parser()
|
|
fs.readFile fileName, (err, data) ->
|
|
assert.equal err, null
|
|
x2js.parseString data, (err, r) ->
|
|
assert.equal err, null
|
|
# just a single test to check whether we parsed anything
|
|
assert.equal r['chartest']['#'], 'Character data here!'
|
|
test.finish()
|
|
|
|
'test double parse': (test) ->
|
|
x2js = new xml2js.Parser()
|
|
fs.readFile fileName, (err, data) ->
|
|
assert.equal err, null
|
|
x2js.parseString data, (err, r) ->
|
|
assert.equal err, null
|
|
# make sure we parsed anything
|
|
assert.equal r['chartest']['#'], 'Character data here!'
|
|
x2js.parseString data, (err, r) ->
|
|
assert.equal err, null
|
|
assert.equal r['chartest']['#'], 'Character data here!'
|
|
test.finish()
|
|
|
|
'test validator': skeleton(validator: validator, (r) ->
|
|
assert.equal typeof r['validatortest']['stringtest'], 'string'
|
|
assert.equal typeof r['validatortest']['numbertest'], 'number'
|
|
assert.ok r['validatortest']['emptyarray']['item'] instanceof Array
|
|
assert.equal r['validatortest']['emptyarray']['item'].length, 0
|
|
assert.ok r['validatortest']['oneitemarray']['item'] instanceof Array
|
|
assert.equal r['validatortest']['oneitemarray']['item'].length, 1
|
|
assert.equal r['validatortest']['oneitemarray']['item'], 'Bar.'
|
|
assert.ok r['arraytest']['item'] instanceof Array
|
|
assert.equal r['arraytest']['item'].length, 2
|
|
assert.equal r['arraytest']['item'][0]['subitem'], 'Baz.'
|
|
assert.equal r['arraytest']['item'][1]['subitem'][0], 'Foo.'
|
|
assert.equal r['arraytest']['item'][1]['subitem'][1], 'Bar.')
|
|
|
|
'test validation error': (test) ->
|
|
x2js = new xml2js.Parser({validator: validator})
|
|
x2js.parseString '<validationerror/>', (err, r) ->
|
|
assert.equal err, 'Validation error!'
|
|
test.finish()
|