forked from enviPath/enviPy
994 lines
35 KiB
JavaScript
Executable File
994 lines
35 KiB
JavaScript
Executable File
var VarStream = require('../src/VarStream')
|
|
, fs = require('fs')
|
|
, assert = require('assert')
|
|
, StringDecoder = require('string_decoder').StringDecoder;
|
|
|
|
// Tests
|
|
describe('Parsing VarStream', function() {
|
|
|
|
var scope = {};
|
|
var myVarStream=new VarStream(scope,'vars');
|
|
it("should work for simple datas", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/1-simple.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
// Numbers
|
|
assert.equal(typeof scope.vars.aSimpleIntValue, 'number');
|
|
assert.equal(scope.vars.aSimpleIntValue,1898);
|
|
assert.equal(typeof scope.vars.aSimpleIntNegativeValue, 'number');
|
|
assert.equal(scope.vars.aSimpleIntNegativeValue,-1669);
|
|
assert.equal(typeof scope.vars.aSimpleFloatValue, 'number');
|
|
assert.equal(scope.vars.aSimpleFloatValue,1.0025);
|
|
assert.equal(typeof scope.vars.aSimpleFloatNegativeValue, 'number');
|
|
assert.equal(scope.vars.aSimpleFloatNegativeValue,-1191.0025);
|
|
// Booleans
|
|
assert.equal(typeof scope.vars.aSimpleBoolValueTrue, 'boolean');
|
|
assert.equal(scope.vars.aSimpleBoolValueTrue,true);
|
|
assert.equal(typeof scope.vars.aSimpleBoolValueFalse, 'boolean');
|
|
assert.equal(scope.vars.aSimpleBoolValueFalse,false);
|
|
// Strings
|
|
assert.equal(typeof scope.vars.aSimpleStringValue, 'string');
|
|
assert.equal(scope.vars.aSimpleStringValue,"I'm the king of the world!");
|
|
assert.equal(typeof scope.vars.aSimpleStringMultilineValue, 'string');
|
|
assert.equal(scope.vars.aSimpleStringMultilineValue,
|
|
"I'm the king of the world!\nYou know!\nIt's true.");
|
|
done();
|
|
});
|
|
});
|
|
/*
|
|
it("should work for other text", function(done) {
|
|
fs.createReadStream(__dirname+'/fixtures/9-othertext.dat').pipe(myVarStream)
|
|
.once('end', function () {
|
|
// Strings
|
|
assert.equal(typeof scope.vars.aSimpleWellDeclaredStringValue, 'string');
|
|
assert.equal(scope.vars.aSimpleWellDeclaredStringValue,
|
|
"I'm the king of the world!");
|
|
assert.equal(typeof scope.vars.aSimpleWellDeclaredStringMultilineValue,
|
|
'string');
|
|
assert.equal(scope.vars.aSimpleWellDeclaredStringMultilineValue,
|
|
"I'm the king of the world!\nYou \"know\"!\nIt's true.");
|
|
done();
|
|
});
|
|
});*/
|
|
|
|
|
|
it("should work for data trees", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/2-trees.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
assert.equal(typeof scope.vars.treeRoot.branch1,'object');
|
|
assert.equal(scope.vars.treeRoot.branch1.aSimpleIntValue,1898);
|
|
assert.equal(scope.vars.treeRoot.branch1.aSimpleIntNegativeValue,-1669);
|
|
assert.equal(typeof scope.vars.treeRoot.branch2,'object');
|
|
assert.equal(scope.vars.treeRoot.branch2.aSimpleFloatValue,1.0025);
|
|
assert.equal(scope.vars.treeRoot.branch2.aSimpleFloatNegativeValue,
|
|
-1191.0025);
|
|
assert.equal(typeof scope.vars.treeRoot.branch3,'object');
|
|
assert.equal(scope.vars.treeRoot.branch3.aSimpleBoolValueTrue,true);
|
|
assert.equal(scope.vars.treeRoot.branch3.aSimpleBoolValueFalse,false);
|
|
assert.equal(typeof scope.vars.treeRoot.branch3.branch1,'object');
|
|
assert.equal(scope.vars.treeRoot.branch3.branch1.aSimpleNullValue,null);
|
|
assert.equal(scope.vars.treeRoot.branch3.branch1.aSimpleStringValue,
|
|
"I'm the king of the world!");
|
|
assert.equal(typeof scope.vars.treeRoot.branch3.branch2,'object');
|
|
assert.equal(scope.vars.treeRoot.branch3.branch2.aSimpleStringMultilineValue,
|
|
"I'm the king of the world!\r\nYou know!\r\nIt's true.");
|
|
//assert.equal(scope.vars.treeRoot.branch3.branch2.aSimpleWellDeclaredStringValue,
|
|
// "I'm the king of the world!");
|
|
//assert.equal(typeof scope.vars.treeRoot.branch3.branch2.branch1,'object');
|
|
//assert.equal(
|
|
// scope.vars.treeRoot.branch3.branch2.branch1.aSimpleWellDeclaredStringMultilineValue,
|
|
// "I'm the king of the world!\nYou \"know\"!\nIt's true.");
|
|
done();
|
|
});
|
|
});
|
|
|
|
|
|
it("should deleted empty datas", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/3-delete.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
assert.equal(typeof scope.vars.treeRoot.branch1.aSimpleIntNegativeValue,'undefined');
|
|
assert.equal(typeof scope.vars.treeRoot.branch2,'undefined');
|
|
assert.equal(typeof scope.vars.treeRoot.branch3.aSimpleBoolValueTrue,'undefined');
|
|
assert.equal(typeof scope.vars.treeRoot.branch3.branch1.aSimpleStringValue,'string');
|
|
assert.equal(scope.vars.treeRoot.branch3.branch1.aSimpleStringValue,'');
|
|
done();
|
|
});
|
|
});
|
|
|
|
|
|
it("should take backward references in count", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/4-backward.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
assert.equal(typeof scope.vars.treeRoot.branch1,'object');
|
|
assert.strictEqual(scope.vars.treeRoot.branch1.aSimpleIntValue,2000);
|
|
assert.strictEqual(scope.vars.treeRoot.branch1.aSimpleIntNegativeValue,-2000);
|
|
assert.equal(typeof scope.vars.treeRoot.branch2,'object');
|
|
assert.strictEqual(scope.vars.treeRoot.branch2.aSimpleFloatValue,2.0001);
|
|
assert.strictEqual(scope.vars.treeRoot.branch2.aSimpleFloatNegativeValue,-1000.0002);
|
|
assert.equal(typeof scope.vars.treeRoot.branch3,'object');
|
|
assert.strictEqual(scope.vars.treeRoot.branch3.aSimpleBoolValueTrue,true);
|
|
assert.strictEqual(scope.vars.treeRoot.branch3.aSimpleBoolValueFalse,false);
|
|
assert.equal(typeof scope.vars.treeRoot.branch3.branch1,'object');
|
|
assert.strictEqual(scope.vars.treeRoot.branch3.branch1.aSimpleNullValue,null);
|
|
assert.strictEqual(scope.vars.treeRoot.branch3.branch1.aSimpleStringValue,
|
|
"I'm not the king of the world!");
|
|
//assert.equal(typeof scope.vars.treeRoot.branch3.branch2,'object');
|
|
//assert.equal(scope.vars.treeRoot.branch3.branch2.aSimpleStringMultilineValue,
|
|
// "I'm not the king of the world!\nYou know!\nIt's true.");
|
|
//assert.equal(scope.vars.treeRoot.branch3.branch2.aSimpleWellDeclaredStringValue,
|
|
// "I'm not the king of the world!");
|
|
//assert.equal(typeof scope.vars.treeRoot.branch3.branch2.branch1,'object');
|
|
//assert.equal(
|
|
// scope.vars.treeRoot.branch3.branch2.branch1.aSimpleWellDeclaredStringMultilineValue,
|
|
// "I'm not the king of the world!\nYou \"know\"!\nIt's true.");
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should work with operators", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/5-operators.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
// Numbers
|
|
assert.equal(typeof scope.vars.aSimpleIntValue, 'number');
|
|
assert.equal(scope.vars.aSimpleIntValue,(((1898+5)*2)-15)%8);
|
|
assert.equal(typeof scope.vars.aSimpleIntNegativeValue, 'number');
|
|
assert.equal(scope.vars.aSimpleIntNegativeValue,(((-1669)+6)*-3)-1);
|
|
assert.equal(typeof scope.vars.aSimpleFloatValue, 'number');
|
|
assert.equal(scope.vars.aSimpleFloatValue,(1.0025+0.0025)/0.0025);
|
|
assert.equal(typeof scope.vars.aSimpleFloatNegativeValue, 'number');
|
|
assert.equal(scope.vars.aSimpleFloatNegativeValue,((-1191.0025)-(-0.0025))/-0.0025);
|
|
// Booleans
|
|
assert.equal(typeof scope.vars.aSimpleBoolValueTrue, 'boolean');
|
|
assert.equal(scope.vars.aSimpleBoolValueTrue,true);
|
|
assert.equal(typeof scope.vars.aSimpleBoolValueFalse, 'boolean');
|
|
assert.equal(scope.vars.aSimpleBoolValueFalse,false);
|
|
// Strings
|
|
assert.equal(typeof scope.vars.aSimpleStringValue, 'string');
|
|
assert.equal(scope.vars.aSimpleStringValue,"I'm the king of the world! Yep!");
|
|
assert.equal(typeof scope.vars.aSimpleStringMultilineValue, 'string');
|
|
assert.equal(scope.vars.aSimpleStringMultilineValue,
|
|
"I'm the king of the world!\nYou know!\nIt's true.\r\nYep.");
|
|
/*assert.equal(typeof scope.vars.aSimpleWellDeclaredStringValue, 'string');
|
|
assert.equal(scope.vars.aSimpleWellDeclaredStringValue,
|
|
"I'm the king of the world! Yep!");
|
|
assert.equal(typeof scope.vars.aSimpleWellDeclaredStringMultilineValue,
|
|
'string');
|
|
assert.equal(scope.vars.aSimpleWellDeclaredStringMultilineValue,
|
|
"I'm the king of the world!\nYou \"know\"!\nIt's true.\nYep.");
|
|
assert.equal(scope.vars.treeRoot.branch3.branch4,
|
|
scope.vars.treeRoot.branch3.branch2);*/
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("should work with arrays", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/6-arrays.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
// First array
|
|
assert.equal(typeof scope.vars.aSimpleArray,'object');
|
|
assert.equal(scope.vars.aSimpleArray instanceof Array,true);
|
|
assert.equal(scope.vars.aSimpleArray.length,9);
|
|
assert.equal(scope.vars.aSimpleArray[0],0);
|
|
assert.equal(scope.vars.aSimpleArray[1],1);
|
|
assert.equal(scope.vars.aSimpleArray[2],2);
|
|
assert.equal(scope.vars.aSimpleArray[3],3);
|
|
assert.equal(scope.vars.aSimpleArray[4],4);
|
|
assert.equal(scope.vars.aSimpleArray[5],5);
|
|
assert.equal(scope.vars.aSimpleArray[6],6);
|
|
assert.equal(scope.vars.aSimpleArray[7],9);
|
|
assert.equal(scope.vars.aSimpleArray[8],8);
|
|
// Second array
|
|
assert.equal(typeof scope.vars.aSimpleArray2,'object');
|
|
assert.equal(scope.vars.aSimpleArray2 instanceof Array,true);
|
|
assert.equal(scope.vars.aSimpleArray2.length,10);
|
|
assert.equal(scope.vars.aSimpleArray2[0].value,5);
|
|
assert.equal(scope.vars.aSimpleArray2[1].value,4);
|
|
assert.equal(typeof scope.vars.aSimpleArray2[2],'undefined');
|
|
assert.equal(typeof scope.vars.aSimpleArray2[3],'undefined');
|
|
assert.equal(typeof scope.vars.aSimpleArray2[4],'undefined');
|
|
assert.equal(typeof scope.vars.aSimpleArray2[5],'undefined');
|
|
assert.equal(typeof scope.vars.aSimpleArray2[6],'undefined');
|
|
assert.equal(typeof scope.vars.aSimpleArray2[7],'undefined');
|
|
assert.equal(typeof scope.vars.aSimpleArray2[8],'undefined');
|
|
assert.equal(scope.vars.aSimpleArray2[9].value,5);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("Should work with truncated content beetween chunks", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/7-truncated-part1.dat');
|
|
readStream.pipe(myVarStream, { end: false })
|
|
readStream.on('end', function () {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("Should work with truncated content beetween chunks", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/7-truncated-part2.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("Should interpret rightvals first", function(done) {
|
|
var readStream = fs.createReadStream(__dirname+'/fixtures/8-rightval.dat');
|
|
readStream.pipe(myVarStream, { end: false });
|
|
readStream.on('end', function () {
|
|
assert.equal(scope.vars.aSimpleArray[0],10);
|
|
assert.equal(scope.vars.aSimpleArray[1],10);
|
|
assert.equal(scope.vars.aSimpleArray2[0].value,9);
|
|
assert.equal(scope.vars.aSimpleArray2[1].value,9);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it("Should output good contents", function(done) {
|
|
var content = ''
|
|
, decoder = new StringDecoder('utf8');
|
|
myVarStream.on('data', function(chunk) {
|
|
content += decoder.write(chunk);
|
|
});
|
|
myVarStream.on('end', function() {
|
|
assert.equal(content,
|
|
fs.readFileSync(__dirname+'/fixtures/0-result.dat', 'utf8'));
|
|
done();
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
describe('Reading chunked varstreams', function() {
|
|
|
|
it("Should work at the lval level", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aVar1=ok\naVa');
|
|
assert.equal(scope.vars.aVar1,'ok');
|
|
assert.equal(typeof scope.vars.aVar2,'undefined');
|
|
myVarStream.read('r2=1000\naVar3=2000\n');
|
|
assert.equal(scope.vars.aVar2,1000);
|
|
assert.equal(scope.vars.aVar3,2000);
|
|
});
|
|
|
|
it("Should work at the operator level", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aVar1=ok\naVar2');
|
|
assert.equal(scope.vars.aVar1,'ok');
|
|
assert.equal(typeof scope.vars.aVar2,'undefined');
|
|
myVarStream.read('=1000\naVar3=2000\n');
|
|
assert.equal(scope.vars.aVar2,1000);
|
|
assert.equal(scope.vars.aVar3,2000);
|
|
});
|
|
|
|
it("Should work at the next operator level", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aVar1=ok\naVar2=');
|
|
assert.equal(scope.vars.aVar1,'ok');
|
|
assert.equal(typeof scope.vars.aVar2,'undefined');
|
|
myVarStream.read('1000\naVar3=2000\n');
|
|
assert.equal(scope.vars.aVar2,1000);
|
|
assert.equal(scope.vars.aVar3,2000);
|
|
});
|
|
|
|
it("Should work at the rval level", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aVar1=ok\naVar2=1');
|
|
assert.equal(scope.vars.aVar1,'ok');
|
|
assert.equal(typeof scope.vars.aVar2,'undefined');
|
|
myVarStream.read('000\naVar3=2000\n');
|
|
assert.equal(scope.vars.aVar2,1000);
|
|
assert.equal(scope.vars.aVar3,2000);
|
|
});
|
|
|
|
it("Should work at the multiline level", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aVar1=ok\naVar2=Y');
|
|
assert.equal(scope.vars.aVar1,'ok');
|
|
assert.equal(typeof scope.vars.aVar2,'undefined');
|
|
myVarStream.read('ep!\\\n');
|
|
assert.equal(scope.vars.aVar2,'Yep!\n');
|
|
myVarStream.read(' That\'');
|
|
assert.equal(scope.vars.aVar2,'Yep!\n That\'');
|
|
myVarStream.read('s me!\n');
|
|
assert.equal(scope.vars.aVar2,'Yep!\n That\'s me!');
|
|
});
|
|
|
|
});
|
|
|
|
describe('Reading varstreams', function() {
|
|
|
|
it("should work well with props containing underscores", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('a_obj.a_text=This is a text \\\\\n');
|
|
assert.strictEqual(scope.vars.a_obj.a_text,'This is a text \\');
|
|
myVarStream.read('a_obj.a_text=This is \\a text.\n');
|
|
assert.strictEqual(scope.vars.a_obj.a_text,'This is \\a text.');
|
|
myVarStream.read('a_obj.a_text=This is \\\\a text.\n');
|
|
assert.strictEqual(scope.vars.a_obj.a_text,'This is \\a text.');
|
|
});
|
|
|
|
it("should work well when chars are escaped", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aObj.aText=This is a text \\\\\n');
|
|
assert.strictEqual(scope.vars.aObj.aText,'This is a text \\');
|
|
myVarStream.read('aObj.aText=This is \\a text.\n');
|
|
assert.strictEqual(scope.vars.aObj.aText,'This is \\a text.');
|
|
myVarStream.read('aObj.aText=This is \\\\a text.\n');
|
|
assert.strictEqual(scope.vars.aObj.aText,'This is \\a text.');
|
|
});
|
|
|
|
it("should work when the stream refers to its root scope with ^", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aObj.parent&=^\n');
|
|
assert.equal(scope.vars,scope.vars.aObj.parent);
|
|
});
|
|
|
|
it("should work when the stream refers to its root scope with ^0", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aObj.parent&=^\n');
|
|
assert.equal(scope.vars,scope.vars.aObj.parent);
|
|
});
|
|
|
|
it("should work well when chars are escaped in multiline strings", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
myVarStream.read('aObj.aText=This is a \\\n');
|
|
assert.strictEqual(scope.vars.aObj.aText,'This is a \n');
|
|
myVarStream.read('multiline \\ text.\\\n');
|
|
assert.strictEqual(scope.vars.aObj.aText,'This is a \nmultiline \\ text.\n');
|
|
myVarStream.read('With two \\\\ lines.\\\\\n');
|
|
assert.strictEqual(scope.vars.aObj.aText,'This is a \nmultiline \\ text.\nWith two \\ lines.\\');
|
|
});
|
|
|
|
});
|
|
|
|
describe('Reading bad varstreams', function() {
|
|
|
|
describe("should silently fail when", function() {
|
|
|
|
it("a line ends with no value after =", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a line has an empty lvalue", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a line has an empty lvalue with a multiline rightvalue", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n=truc\\n1\\n2\\nmachin\n\nvalidVar2=bidule\n'); // Something wrong here
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a line ends with no value after &=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar&=\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a line ends with no value after +=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar+=\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a line ends with no value after -=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar-=\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a line ends with no value after /=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar/=\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("when there are an empty node at start", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n.ASimpleVar=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("when there are an empty node somewhere", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.aNode..anotherNode.and=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("when there are an empty node at end", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode.=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("when there malformed nodes at start", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n$%*.ASimpleVar.anode.$=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("when there malformed nodes somewhere", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode.$.another=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("when there malformed nodes at end", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode.$=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("there are malformed backward reference in a leftval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n^3g.SimpleVar.anode=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("there are malformed backward reference in a leftval 2", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n^g3.SimpleVar.anode=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("there are malformed backward reference in a righval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode&=^3g.truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {anode: null},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("there are malformed backward reference in a righval 2", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode&=^g3.truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {anode: null},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("there are out of range backward reference in a leftval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\n^12.ASimpleVar.anode=truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
validVar2: 'bidule'
|
|
});
|
|
});/*
|
|
|
|
it("there are out of range backward reference in a rightval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode+=^12.truc.truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {anode: null},
|
|
validVar2: 'bidule'
|
|
});
|
|
});*/
|
|
|
|
it("a legal char is escaped", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode=truc\\truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {anode: 'truc\\truc'},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
it("a legal char is escaped in a multiline value", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars');
|
|
assert.doesNotThrow(function() {
|
|
myVarStream.read('validVar1=machin\nASimpleVar.anode=truc\\\ntruc\\truc\nvalidVar2=bidule\n');
|
|
});
|
|
assert.deepEqual(scope.vars, {
|
|
validVar1: 'machin',
|
|
ASimpleVar: {anode: 'truc\ntruc\\truc'},
|
|
validVar2: 'bidule'
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
describe("in strict mode, should raise exceptions when", function() {
|
|
|
|
it("a line ends with no =", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Unexpected new line found while parsing '
|
|
+' a leftValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a line has no lvalue", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('=ASimpleVar\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an empty leftValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a line ends with no value after &=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar&=\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an empty rightValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a line ends with no value after +=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar+=\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an empty rightValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a line ends with no value after -=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar-=\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an empty rightValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a line ends with no value after *=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar*=\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an empty rightValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a line ends with no value after /=", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar/=\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an empty rightValue.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are a empty node at start", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('.ASimpleVar=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='The leftValue can\'t have empty nodes'
|
|
+' (.ASimpleVar).') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are a empty node somewhere", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar.prop..prop.prop=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='The leftValue can\'t have empty nodes'
|
|
+' (ASimpleVar.prop..prop.prop).') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are a empty node at end", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar.=false\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='The leftValue can\'t have empty nodes (ASimpleVar.).') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are malformed nodes", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimp-+leVar.ds+d=false\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Unexpected char after the "-" operator. Expected "="'
|
|
+' found "+".') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are malformed nodes", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar.ds$d=false\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Illegal chars found in a the node "ds$d".') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are out of range backward reference", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar.prop1.prop2=false\n^4.test=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Backward reference index is greater than the'
|
|
+' previous node max index.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are malformed backward reference in a righval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar.prop1.prop2=false\n^4b.test=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Malformed backward reference.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are malformed backward reference in a righval 2", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('ASimpleVar.prop1.prop2=false\n^b5.test=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Malformed backward reference.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are malformed backward reference in a leftval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('^b5.test=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Malformed backward reference.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are malformed backward reference in a leftval 2", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('^5b.test=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Malformed backward reference.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("there are bad range backward reference in a leftval", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('^8.test=true\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Backward reference index is greater than the previous node max index.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a legal char is escaped", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('test=t\\rue\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an escape char but there was nothing to escape.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("a legal char is escaped in a multiline value", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('test=truc\\\ntruc\\truc\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Found an escape char but there was nothing to escape.') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
it("an operator is not folled by =", function() {
|
|
var scope = {};
|
|
var myVarStream=new VarStream.Reader(scope,'vars',
|
|
VarStream.Reader.STRICT_MODE);
|
|
assert.throws(
|
|
function() {
|
|
myVarStream.read('test&\n');
|
|
},
|
|
function(err) {
|
|
if(err instanceof Error
|
|
&&err.message==='Unexpected char after the "&" operator. Expected "=" found "\n".') {
|
|
return true;
|
|
}
|
|
}
|
|
);
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|