e2c11faf886cfdc6f0cf09f1088dad29f639c649
[fnpeditor.git] / src / wlxml / wlxml.test.js
1 define([
2     'libs/chai',
3     './wlxml.js'
4 ], function(chai, wlxml) {
5     
6 'use strict';
7
8 /* jshint expr:true */
9 /* global it, describe */
10
11 var expect = chai.expect;
12
13 var nodeFromXML = function(xml) {
14     return wlxml.WLXMLElementNodeFromXML(xml);
15 };
16
17 var getDocumentFromXML = function(xml, options) {
18     return wlxml.WLXMLDocumentFromXML(xml, options || {});
19 };
20
21
22 describe('WLXMLDocument', function() {
23     
24     describe('Basic wlxml element node properties', function() {
25         it('returns its class', function() {
26             var node = nodeFromXML('<header class="class.subclass"></header>');
27             expect(node.getClass()).to.equal('class.subclass');
28         });
29
30         it('returns attributes other than class and meta-* as other attributes', function() {
31             var node = nodeFromXML('<span class="uri" meta-attr="val" attr1="val1" attr2="val2"></span>');
32             expect(node.getOtherAttributes()).to.eql({attr1: 'val1', attr2: 'val2'});
33         });
34     });
35
36     describe('WLXML node meta attributes', function() {
37
38         it('inherits keys from super classes', function() {
39             var testClasses = {
40                     '': {
41                         attrs: {'common': {type: 'string'}}
42                     },
43                     'a': {
44                         attrs: {'a_attr': {type: 'string'}}
45                     },
46                     'a.b': {
47                         attrs: {'a_b_attr': {type: 'string'}}
48                     },
49                     'a.b.c': {
50                         attrs: {'a_b_c_attr': {type: 'string'}}
51                     }
52                 },
53                 doc = getDocumentFromXML('<section></section>', {wlxmlClasses: testClasses}),
54                 section = doc.root;
55
56             expect(section.getMetaAttributes().keys()).to.eql(['common']);
57
58             section.setClass('a');
59             expect(section.getMetaAttributes().keys().sort()).to.eql(['common', 'a_attr'].sort());
60
61             section.setClass('a.b');
62             expect(section.getMetaAttributes().keys().sort()).to.eql(['common', 'a_attr', 'a_b_attr'].sort());
63
64             section.setClass('a.b.c');
65             expect(section.getMetaAttributes().keys().sort()).to.eql(['common', 'a_attr', 'a_b_attr', 'a_b_c_attr'].sort());
66         });
67
68         describe('api', function() {
69             it('returns meta attributes as a dict', function() {
70                 var testClasses = {
71                         'test': {
72                             attrs: {
73                                 attr1: {type: 'string'},
74                                 attr2: {type: 'date'}
75                             }
76                         }
77                     },
78                     node = getDocumentFromXML(
79                         '<span class="test" meta-attr1="val1" meta-attr2="2014-01-01"></span>',
80                         {wlxmlClasses: testClasses}
81                     ).root,
82                     attrs = node.getMetaAttributes();
83
84                 expect(attrs.keys().sort()).to.eql(['attr1', 'attr2'].sort());
85                 expect(attrs.attr1.value).to.equal('val1');
86                 expect(attrs.attr1.type).to.equal('string');
87                 expect(attrs.attr2.value).to.equal('2014-01-01');
88                 expect(attrs.attr2.type).to.equal('date');
89             });
90             it('returns undefined value if attribute is missing', function() {
91                 var testClasses = {
92                         'test': {
93                             attrs: {
94                                 attr1: {type: 'string'},
95                             }
96                         }
97                     },
98                     node = getDocumentFromXML('<span class="test"></span>', {wlxmlClasses: testClasses}).root,
99                     attrs = node.getMetaAttributes();
100                     expect(attrs.attr1.value).to.be.undefined;
101             });
102         });
103     });
104
105     describe('White space handling', function() {
106         it('ignores white space surrounding block elements', function() {
107             var node = nodeFromXML('<section> <div></div> </section>'),
108                 contents = node.contents();
109             expect(contents).to.have.length(1);
110             expect(contents[0].nodeType).to.equal(Node.ELEMENT_NODE);
111         });
112         it('ignores white space between block elements', function() {
113             var node = nodeFromXML('<section><div></div> <div></div></section>'),
114             contents = node.contents();
115             expect(contents).to.have.length(2);
116             [0,1].forEach(function(idx) {
117                 expect(contents[idx].nodeType).to.equal(Node.ELEMENT_NODE);
118             });
119         });
120         it('trims white space from the beginning and the end of the block elements', function() {
121             var node = nodeFromXML('<section> Alice <span>has</span> a cat </section>');
122             expect(node.contents()[0].getText()).to.equal('Alice ');
123             expect(node.contents()[2].getText()).to.equal(' a cat');
124         });
125         it('normalizes string of white characters to one space at the inline element boundries', function() {
126             var node = nodeFromXML('<span>   Alice has a cat   </span>');
127             expect(node.contents()[0].getText()).to.equal(' Alice has a cat ');
128         });
129         it('normalizes string of white characters to one space before inline element', function() {
130             var node = nodeFromXML('<div>Alice has  <span>a cat</span></div>');
131             expect(node.contents()[0].getText()).to.equal('Alice has ');
132         });
133         it('normalizes string of white characters to one space after inline element', function() {
134             var node = nodeFromXML('<div>Alice has <span>a</span>  cat</div>');
135             expect(node.contents()[2].getText()).to.equal(' cat');
136         });
137     });
138
139     describe('formatting output xml', function() {
140
141         /*jshint multistr: true */
142
143         it('keeps white space between XML nodes', function() {
144             var xmlIn = '<section>\n\n\n<div></div>\n\n\n<div></div>\n\n\n</section>',
145             doc = getDocumentFromXML(xmlIn),
146             xmlOut = doc.toXML();
147
148             var partsIn = xmlIn.split('\n\n\n'),
149                 partsOut = xmlOut.split('\n\n\n');
150
151             expect(partsIn).to.deep.equal(partsOut);
152         });
153
154         it('keeps white space between XML nodes - inline case', function() {
155             var xmlIn = '<section>\n\n\n<span></span>\n\n\n<span></span>\n\n\n</section>',
156                 doc = getDocumentFromXML(xmlIn),
157                 xmlOut = doc.toXML();
158
159             var partsIn = xmlIn.split('\n\n\n'),
160                 partsOut = xmlOut.split('\n\n\n');
161             expect(partsIn).to.deep.equal(partsOut);
162         });
163
164         it('keeps white space at the beginning of text', function() {
165             var xmlIn = '<section>    abc<div>some div</div>    abc</section>',
166                 doc = getDocumentFromXML(xmlIn),
167                 xmlOut = doc.toXML();
168
169             expect(xmlOut).to.equal(xmlIn);
170         });
171
172         // it('nests new children block elements', function() {
173         //     var doc = getDocumentFromXML('<section></section>');
174     
175         //     doc.root.append({tag: 'header'});
176
177         //     var xmlOut = doc.toXML();
178         //     expect(xmlOut.split('\n  ')[0]).to.equal('<section>', 'nesting start ok');
179         //     expect(xmlOut.split('\n').slice(-1)[0]).to.equal('</section>', 'nesting end ok');
180
181         // });
182
183         // it('doesn\'t nest new children inline elements', function() {
184         //     var doc = getDocumentFromXML('<section></section>');
185     
186         //     doc.root.append({tag: 'span'});
187
188         //     var xmlOut = doc.toXML();
189         //     expect(xmlOut).to.equal('<section><span></span></section>');
190         // });
191
192         it('keeps original white space at the end of text', function() {
193             
194             var xmlIn = '<header>    Some text ended with white space \
195             \
196             <span class="uri">Some text</span> some text\
197         \
198         </header>',
199                 doc = getDocumentFromXML(xmlIn),
200                 xmlOut = doc.toXML();
201         
202             expect(xmlOut).to.equal(xmlIn);
203         });
204
205         it('keeps white space around text node', function() {
206             var xmlIn = '<section>\
207             <header>header1</header>\
208             Some text surrounded by white space\
209             <header>header2</header>\
210         </section>',
211                 doc = getDocumentFromXML(xmlIn),
212                 xmlOut = doc.toXML();
213             expect(xmlOut).to.equal(xmlIn);
214         });
215
216         it('keeps white space around text node - last node case', function() {
217             var xmlIn = '<section>\
218             <header>header</header>\
219                 \
220             Some text surrounded by white space\
221                 \
222         </section>',
223                 doc = getDocumentFromXML(xmlIn),
224                 xmlOut = doc.toXML();
225
226             expect(xmlOut).to.equal(xmlIn);
227         });
228
229         it('keeps white space after detaching text element', function() {
230             var xmlIn = '<section><header>header</header>\n\
231                 \n\
232             text1\n\
233                 \n\
234         </section>',
235                 expectedXmlOut = '<section><header>header</header>\n\
236                 \n\
237             \n\
238                 \n\
239         </section>',
240                 doc = getDocumentFromXML(xmlIn),
241                 contents = doc.root.contents(),
242                 text = contents[contents.length-1];
243             
244             expect(text.getText()).to.equal('text1');
245
246             text.detach();
247
248             var xmlOut = doc.toXML();
249             expect(xmlOut).to.equal(expectedXmlOut);
250         });
251
252     });
253
254     describe('Extension', function() {
255         var doc, extension, elementNode, textNode, testClassNode;
256
257         beforeEach(function() {
258             doc = getDocumentFromXML('<section>Alice<div class="test_class"></div></section>');
259             elementNode = doc.root;
260             textNode = doc.root.contents()[0];
261             extension = {};
262             
263             console.log('A');
264             expect(function() {
265                 elementNode.transform('testTransformation');
266             }).to.throw(Error);
267             console.log('B');
268             expect(function() {
269                 textNode.transform('testTransformation');
270             }).to.throw(Error);
271             console.log('C');
272             expect(function() {
273                 doc.transform('testTransformation');
274             }).to.throw(Error);
275             expect(doc.testMethod).to.be.undefined;
276             expect(elementNode.testMethod).to.be.undefined;
277             expect(textNode.testMethod).to.be.undefined;
278         });
279
280         it('allows adding method to a document', function() {
281             extension = {document: {methods: {
282                 testMethod: function() { return this; }
283             }}};
284
285             doc.registerExtension(extension);
286             expect(doc.testMethod()).to.equal(doc, 'context is set to a document instance');
287         });
288
289         it('allows adding transformation to a document', function() {
290             extension = {document: {transformations: {
291                 testTransformation: function() { return this; },
292                 testTransformation2: {impl: function() { return this;}}
293             }}};
294
295             doc.registerExtension(extension);
296             expect(doc.transform('testTransformation')).to.equal(doc, 'context is set to a document instance');
297             expect(doc.transform('testTransformation2')).to.equal(doc, 'context is set to a document instance');
298         });
299
300         it('allows adding method to a DocumentNode instance', function() {
301             extension = {documentNode: {methods: {
302                 testMethod: function() { return this; }    
303             }}};
304
305             doc.registerExtension(extension);
306             expect(elementNode.testMethod().sameNode(elementNode)).to.equal(true, 'context is set to a node instance');
307             expect(textNode.testMethod().sameNode(textNode)).to.equal(true, 'context is set to a node instance');
308         });
309
310         it('allows adding transformation to a DocumentNode', function() {
311             extension = {documentNode: {transformations: {
312                 testTransformation: function() { return this; },
313                 testTransformation2: {impl: function() { return this;}}
314             }}};
315             
316             doc.registerExtension(extension);
317
318             expect(elementNode.transform('testTransformation').sameNode(elementNode)).to.equal(true, '1');
319             expect(elementNode.transform('testTransformation2').sameNode(elementNode)).to.equal(true, '2');
320             expect(textNode.transform('testTransformation').sameNode(textNode)).to.equal(true, '3');
321             expect(textNode.transform('testTransformation2').sameNode(textNode)).to.equal(true, '4');
322         });
323
324         it('allows adding method to an ElementNode of specific class', function() {
325             extension = {wlxmlClass: {test_class: {methods: {
326                 testMethod: function() { return this; }
327             }}}};
328             doc.registerExtension(extension);
329             testClassNode = doc.root.contents()[1];
330             expect(testClassNode.object.testMethod().sameNode(testClassNode)).to.equal(true, '1');
331         });
332
333         it('allows adding transformation to an ElementNode of specific class', function() {
334             extension = {wlxmlClass: {test_class: {transformations: {
335                 testTransformation: function() { return this; },
336                 testTransformation2: {impl: function() { return this; }}
337             }}}};
338             doc.registerExtension(extension);
339             testClassNode = doc.root.contents()[1];
340             expect(testClassNode.object.transform('testTransformation').sameNode(testClassNode)).to.equal(true, '1');
341             expect(testClassNode.object.transform('testTransformation2').sameNode(testClassNode)).to.equal(true, '1');
342         });
343
344
345     });
346
347 });
348
349 });