src/smartxml/smartxml.test.js

   1 define([
   2     'libs/chai',
   3     'libs/sinon',
   4     'libs/underscore',
   5     './smartxml.js'
   6 ], function(chai, sinon, _, smartxml) {
   7
   8 'use strict';
   9 /*jshint expr:true */
  10 /* global describe, it, beforeEach, Node, DOMParser */
  11
  12 var expect = chai.expect;
  13
  14
  15 var getDocumentFromXML = function(xml) {
  16     return smartxml.documentFromXML(xml);
  17 };
  18
  19 var elementNodeFromParams = function(params) {
  20     return smartxml.elementNodeFromXML('<' + params.tag + '></' + params.tag + '>');
  21 };
  22
  23 var elementNodeFromXML = function(xml) {
  24     return smartxml.elementNodeFromXML(xml);
  25 };
  26
  27
  28 describe('smartxml', function() {
  29
  30     describe('Basic Document properties', function() {
  31         it('exposes its root element', function() {
  32             var doc = getDocumentFromXML('<div></div>');
  33             expect(doc.root.getTagName()).to.equal('div');
  34         });
  35
  36         it('can resets its content entirely', function() {
  37             var doc = getDocumentFromXML('<div></div>');
  38
  39             expect(doc.root.getTagName()).to.equal('div');
  40
  41             doc.loadXML('<header></header>');
  42             expect(doc.root.getTagName()).to.equal('header');
  43         });
  44
  45         it('knows if it contains an ElementNode in its tree', function() {
  46             var doc = getDocumentFromXML('<root><a></a>text</root>'),
  47                 root = doc.root,
  48                 a = root.contents()[0],
  49                 text = root.contents()[1];
  50
  51             expect(doc.containsNode(root)).to.equal(true, 'contains its root');
  52             expect(doc.containsNode(a)).to.equal(true, 'contains Element Node');
  53             expect(doc.containsNode(text)).to.equal(true, 'contains Text Node');
  54         });
  55
  56         it('creates text nodes', function() {
  57             var doc = getDocumentFromXML('<div></div>'),
  58                 emptyTextNode = doc.createDocumentNode({text:''}),
  59                 nonEmptyTextNode = doc.createDocumentNode({text: 'alice'});
  60             expect(emptyTextNode.getText()).to.equal('', 'empty ok');
  61             expect(nonEmptyTextNode.getText()).to.equal('alice', 'non empty ok');
  62         });
  63
  64         it('creates nodes from xml strings', function() {
  65             var doc = getDocumentFromXML('<div></div>'),
  66                 node = doc.createDocumentNode('<a>Alice<b></b></a>');
  67             expect(node.getTagName()).to.equal('a');
  68             expect(node.contents().length).to.equal(2);
  69             expect(node.contents()[0].getText()).to.equal('Alice');
  70             expect(node.contents()[1].getTagName()).to.equal('b');
  71         });
  72     });
  73
  74     describe('DocumentNode', function() {
  75         it('can be cloned', function() {
  76             var doc = getDocumentFromXML('<div>Alice</div>'),
  77                 text = doc.root.contents()[0],
  78                 clone, suffix;
  79
  80             [doc.root, text].forEach(function(node) {
  81                 suffix = ' (' + (node.nodeType === Node.TEXT_NODE ? 'text' : 'element')  + ')';
  82                 clone = node.clone();
  83                 expect(doc.containsNode(clone)).to.equal(false, 'clone is not contained in a document' + suffix);
  84                 expect(node.sameNode(clone)).to.equal(false, 'clone is not same node as its originator' + suffix);
  85                 expect(node.nativeNode.isEqualNode(clone.nativeNode)).to.equal(true, 'clone is identical as its originator' + suffix);
  86             });
  87         });
  88
  89         it('can be cloned with its contents and its contents data', function() {
  90             var doc = getDocumentFromXML('<root><div></div></root>'),
  91                 root = doc.root,
  92                 div = root.contents()[0];
  93
  94             var ClonableObject = function(arg) {
  95                 this.arg = arg;
  96             };
  97             ClonableObject.prototype.clone = function() {
  98                 return new ClonableObject(this.arg);
  99             };
 100
 101             div.setData('key', 'value');
 102             div.setData('clonableObject', new ClonableObject('test'));
 103
 104             var rootClone = root.clone(),
 105                 divClone = rootClone.contents()[0],
 106                 stringClone = divClone.getData('key'),
 107                 objClone = divClone.getData('clonableObject');
 108
 109             expect(stringClone).to.equal('value');
 110             expect(objClone.arg).to.equal('test', 'clonable object got copied');
 111             expect(objClone !== div.getData('clonableObject')).to.be.equal(true, 'copy of the clonable object is a new object');
 112         });
 113
 114         it('knows its path in the document tree', function() {
 115             var doc = getDocumentFromXML('<root><a><b><c></c>text</b></a></root>'),
 116                 root = doc.root,
 117                 a = root.contents()[0],
 118                 b = a.contents()[0],
 119                 text = b.contents()[1];
 120
 121             expect(root.getPath()).to.eql([], 'path of the root element is empty');
 122             expect(a.getPath()).to.eql([0]);
 123             expect(b.getPath()).to.eql([0, 0]);
 124             expect(text.getPath()).to.eql([0,0,1]);
 125
 126             /* Paths relative to a given ancestor */
 127             expect(text.getPath(root)).to.eql([0,0,1]);
 128             expect(text.getPath(a)).to.eql([0,1]);
 129             expect(text.getPath(b)).to.eql([1]);
 130         });
 131     });
 132
 133     describe('Basic ElementNode properties', function() {
 134         it('exposes node contents', function() {
 135             var node = elementNodeFromXML('<node>Some<node>text</node>is here</node>'),
 136                 contents = node.contents();
 137
 138             expect(contents).to.have.length(3);
 139             expect(contents[0].nodeType).to.equal(Node.TEXT_NODE, 'text node 1');
 140             expect(contents[1].nodeType).to.equal(Node.ELEMENT_NODE, 'element node 1');
 141             expect(contents[2].nodeType).to.equal(Node.TEXT_NODE, 'text node 2');
 142         });
 143
 144         describe('Storing custom data', function() {
 145             var node;
 146
 147             beforeEach(function() {
 148                 node = elementNodeFromXML('<div></div>');
 149             });
 150
 151             it('can append single value', function() {
 152                 node.setData('key', 'value');
 153                 expect(node.getData('key')).to.equal('value');
 154             });
 155
 156             it('can overwrite the whole data', function() {
 157                 node.setData('key1', 'value1');
 158                 node.setData({key2: 'value2'});
 159                 expect(node.getData('key2')).to.equal('value2');
 160             });
 161
 162             it('can fetch the whole data at once', function() {
 163                 node.setData({key1: 'value1', key2: 'value2'});
 164                 expect(node.getData()).to.eql({key1: 'value1', key2: 'value2'});
 165             });
 166
 167             it('can remove specific data', function() {
 168                 node.setData('key', 'value');
 169                 node.setData('key', undefined);
 170                 expect(node.getData('key')).to.be.undefined;
 171             });
 172         });
 173
 174         describe('Changing node tag', function() {
 175
 176             it('can change tag name', function() {
 177                 var node = elementNodeFromXML('<div></div>');
 178                 node = node.setTag('span');
 179                 expect(node.getTagName()).to.equal('span');
 180             });
 181
 182             describe('Implementation specific expectations', function() {
 183                 it('keeps custom data', function() {
 184                     var node = elementNodeFromXML('<div></div>');
 185
 186                     node.setData('key', 'value');
 187                     node = node.setTag('header');
 188
 189                     expect(node.getTagName()).to.equal('header');
 190                     expect(node.getData()).to.eql({key: 'value'});
 191                 });
 192
 193                 it('can change document root tag name', function() {
 194                     var doc = getDocumentFromXML('<div></div>');
 195                     doc.root.setTag('span');
 196                     expect(doc.root.getTagName()).to.equal('span');
 197                 });
 198
 199                 it('keeps node contents', function() {
 200                     var node = elementNodeFromXML('<div><div></div></div>');
 201                     node = node.setTag('header');
 202                     expect(node.contents()).to.have.length(1);
 203                 });
 204             });
 205         });
 206
 207         describe('Setting node attributes', function() {
 208             it('can set node attribute', function() {
 209                 var node = elementNodeFromXML('<div></div>');
 210
 211                 node.setAttr('key', 'value');
 212                 expect(node.getAttr('key')).to.equal('value');
 213             });
 214             it('emits nodeAttrChange event', function() {
 215                 var node = elementNodeFromXML('<div key="value1"></div>'),
 216                     spy = sinon.spy();
 217
 218                 node.document.on('change', spy);
 219                 node.setAttr('key', 'value2');
 220                 var event = spy.args[0][0];
 221
 222                 expect(event.type).to.equal('nodeAttrChange');
 223                 expect(event.meta.node.sameNode(node)).to.be.true;
 224                 expect(event.meta.attr).to.equal('key');
 225                 expect(event.meta.oldVal).to.equal('value1');
 226             });
 227         });
 228
 229         describe('Searching for the last child text node', function() {
 230             [
 231                 '<div>xxx<div></div>last</div>',
 232                 '<div><div>last</div></div>',
 233                 '<div>xxx<div>last</div><div></div></div>'
 234             ].forEach(function(xml, i) {
 235                 var example = 'example ' + i;
 236                 it('returns last child text node ' + example + ')', function() {
 237                     var doc = getDocumentFromXML(xml),
 238                         lastTextNode = doc.root.getLastTextNode();
 239                     expect(lastTextNode.getText()).to.equal('last', example);
 240                 });
 241             });
 242         });
 243     });
 244
 245     describe('Basic TextNode properties', function() {
 246         it('can have its text set', function() {
 247             var node = elementNodeFromXML('<div>Alice</div>'),
 248                 textNode = node.contents()[0];
 249
 250             textNode.setText('Cat');
 251             expect(textNode.getText()).to.equal('Cat');
 252         });
 253
 254         it('emits nodeTextChange', function() {
 255             var node = elementNodeFromXML('<div>Alice</div>'),
 256                 textNode = node.contents()[0],
 257                 spy = sinon.spy();
 258
 259             textNode.document.on('change', spy);
 260             textNode.setText('Cat');
 261
 262             var event = spy.args[0][0];
 263             expect(event.type).to.equal('nodeTextChange');
 264         });
 265
 266         it('puts NodeElement after itself', function() {
 267             var node = elementNodeFromXML('<div>Alice</div>'),
 268                 textNode = node.contents()[0],
 269                 returned = textNode.after({tagName:'div'});
 270             expect(returned.sameNode(node.contents()[1])).to.be.true;
 271         });
 272
 273         it('puts NodeElement before itself', function() {
 274             var node = elementNodeFromXML('<div>Alice</div>'),
 275                 textNode = node.contents()[0],
 276                 returned = textNode.before({tagName:'div'});
 277             expect(returned.sameNode(node.contents()[0])).to.be.true;
 278         });
 279
 280         describe('Wrapping TextNode contents', function() {
 281
 282             it('wraps DocumentTextElement', function() {
 283                 var node = elementNodeFromXML('<section>Alice</section>'),
 284                     textNode = node.contents()[0];
 285
 286                 var returned = textNode.wrapWith({tagName: 'header'}),
 287                     parent = textNode.parent(),
 288                     parent2 = node.contents()[0];
 289
 290                 expect(returned.sameNode(parent)).to.be.equal(true, 'wrapper is a parent');
 291                 expect(returned.sameNode(parent2)).to.be.equal(true, 'wrapper has a correct parent');
 292                 expect(returned.getTagName()).to.equal('header');
 293             });
 294
 295             describe('wrapping part of DocumentTextElement', function() {
 296                 [{start: 5, end: 12}, {start: 12, end: 5}].forEach(function(offsets) {
 297                     it('wraps in the middle ' + offsets.start + '/' + offsets.end, function() {
 298                         var node = elementNodeFromXML('<section>Alice has a cat</section>'),
 299                             textNode = node.contents()[0];
 300
 301                         var returned = textNode.wrapWith({tagName: 'header', attrs: {'attr1': 'value1'}, start: offsets.start, end: offsets.end}),
 302                             contents = node.contents();
 303
 304                         expect(contents.length).to.equal(3);
 305
 306                         expect(contents[0].nodeType).to.be.equal(Node.TEXT_NODE, 'first node is text node');
 307                         expect(contents[0].getText()).to.equal('Alice');
 308
 309                         expect(contents[1].sameNode(returned)).to.be.true;
 310                         expect(returned.getTagName()).to.equal('header');
 311                         expect(returned.getAttr('attr1')).to.equal('value1');
 312                         expect(contents[1].contents().length).to.equal(1, 'wrapper has one node inside');
 313                         expect(contents[1].contents()[0].getText()).to.equal(' has a ');
 314
 315                         expect(contents[2].nodeType).to.be.equal(Node.TEXT_NODE, 'third node is text node');
 316                         expect(contents[2].getText()).to.equal('cat');
 317                     });
 318                 });
 319
 320                 it('wraps whole text inside DocumentTextElement if offsets span entire content', function() {
 321                     var node = elementNodeFromXML('<section>Alice has a cat</section>'),
 322                          textNode = node.contents()[0];
 323
 324                     textNode.wrapWith({tagName: 'header', start: 0, end: 15});
 325
 326                     var contents = node.contents();
 327                     expect(contents.length).to.equal(1);
 328                     expect(contents[0].getTagName()).to.equal('header');
 329                     expect(contents[0].contents()[0].getText()).to.equal('Alice has a cat');
 330                 });
 331             });
 332         });
 333
 334         describe('Dividing text node into two with element node', function() {
 335                 it('can divide text node with element node, splitting text node into two', function() {
 336                     var doc = getDocumentFromXML('<div>Alice has a cat</div>'),
 337                         text = doc.root.contents()[0];
 338
 339                     var returned = text.divideWithElementNode({tagName: 'aside'}, {offset: 5}),
 340                         contents = doc.root.contents(),
 341                         lhsText = contents[0],
 342                         rhsText = contents[2];
 343
 344                     expect(lhsText.getText()).to.equal('Alice');
 345                     expect(returned.sameNode(contents[1]));
 346                     expect(rhsText.getText()).to.equal(' has a cat');
 347                 });
 348
 349                 it('treats dividing at the very end as appending after it', function() {
 350                     var doc = getDocumentFromXML('<div>Alice has a cat</div>'),
 351                         text = doc.root.contents()[0];
 352
 353
 354                     var returned = text.divideWithElementNode({tagName: 'aside'}, {offset: 15}),
 355                         contents = doc.root.contents(),
 356                         textNode = contents[0],
 357                         elementNode = contents[1];
 358
 359                     expect(contents.length).to.equal(2);
 360                     expect(textNode.getText()).to.equal('Alice has a cat');
 361                     expect(returned.sameNode(elementNode)).to.be.true;
 362                     expect(elementNode.getTagName()).to.equal('aside');
 363                 });
 364
 365                 it('treats dividing at the very beginning as prepending before it', function() {
 366                     var doc = getDocumentFromXML('<div>Alice has a cat</div>'),
 367                         text = doc.root.contents()[0];
 368
 369                     var returned = text.divideWithElementNode({tagName: 'aside'}, {offset: 0}),
 370                         contents = doc.root.contents(),
 371                         textNode = contents[1],
 372                         elementNode = contents[0];
 373
 374                     expect(contents.length).to.equal(2);
 375                     expect(textNode.getText()).to.equal('Alice has a cat');
 376                     expect(returned.sameNode(elementNode)).to.be.true;
 377                     expect(elementNode.getTagName()).to.equal('aside');
 378                 });
 379         });
 380     });
 381
 382     describe('Manipulations', function() {
 383
 384         describe('detaching nodes', function() {
 385             it('can detach document root node', function() {
 386                 var doc = getDocumentFromXML('<div></div>');
 387
 388                 doc.root.detach();
 389                 expect(doc.root).to.equal(null);
 390             });
 391         });
 392
 393         describe('replacing node with another one', function() {
 394             it('replaces node with another one', function() {
 395                 var doc = getDocumentFromXML('<div><a></a></div>'),
 396                     a = doc.root.contents()[0];
 397
 398                 var c = a.replaceWith({tagName: 'b', attrs: {b:'1'}});
 399
 400                 expect(doc.root.contents()[0].sameNode(c));
 401                 expect(c.getTagName()).to.equal('b');
 402                 expect(c.getAttr('b')).to.equal('1');
 403             });
 404             it('can replace document root', function() {
 405                 var doc = getDocumentFromXML('<div></div>');
 406
 407                 var header = doc.root.replaceWith({tagName: 'header'});
 408
 409                 expect(doc.root.sameNode(header)).to.be.true;
 410                 expect(doc.containsNode(header)).to.be.true;
 411             });
 412         });
 413
 414         it('merges adjacent text nodes resulting from detaching an element node in between', function() {
 415             var doc = getDocumentFromXML('<div>Alice <span>has</span>a cat</div>'),
 416                 span = doc.root.contents()[1];
 417
 418             span.detach();
 419
 420             var rootContents = doc.root.contents();
 421             expect(rootContents).to.have.length(1, 'one child left');
 422             expect(rootContents[0].getText()).to.equal('Alice a cat');
 423         });
 424
 425         it('merges adjacent text nodes resulting from moving an element node in between', function() {
 426             var doc = getDocumentFromXML('<div><a></a>Alice <span>has</span>a cat</div>'),
 427                 span = doc.root.contents()[2],
 428                 a = doc.root.contents()[0];
 429
 430             a.append(span);
 431
 432             var rootContents = doc.root.contents();
 433             expect(rootContents).to.have.length(2, 'one child left');
 434             expect(rootContents[1].getText()).to.equal('Alice a cat');
 435         });
 436
 437         it('inserts node at index', function() {
 438             var doc = getDocumentFromXML('<div><a></a><b></b><c></c></div>'),
 439                 b = doc.root.contents()[1];
 440
 441             var inserted = doc.root.insertAtIndex({tagName: 'test'}, 1);
 442
 443             expect(doc.root.contents()[1].sameNode(inserted)).to.equal(true, 'inserted node returned');
 444             expect(b.getIndex()).to.equal(2, 'b node shifted right');
 445         });
 446
 447         it('appends node when inserting node at index out of range', function() {
 448             var doc = getDocumentFromXML('<div></div>');
 449
 450             var test1 = doc.root.insertAtIndex({tagName: 'test1'}, 0),
 451                 test2 = doc.root.insertAtIndex({tagName: 'test1'}, 10);
 452
 453             expect(doc.root.contents()[0].sameNode(test1)).to.equal(true, 'inserting at index 0 of empty nodes appends node');
 454             expect(doc.root.contents().length).to.equal(1, 'inserting at index out of range does nothing');
 455             expect(test2).to.equal(undefined, 'inserting at index out of range returns undefined');
 456         });
 457
 458         it('appends element node to another element node', function() {
 459             var node1 = elementNodeFromParams({tag: 'div'}),
 460                 node2 = elementNodeFromParams({tag: 'a'}),
 461                 node3 = elementNodeFromParams({tag: 'p'});
 462             node1.append(node2);
 463             node1.append(node3);
 464             expect(node1.contents()[0].sameNode(node2)).to.be.true;
 465             expect(node1.contents()[1].sameNode(node3)).to.be.true;
 466         });
 467
 468         it('prepends element node to another element node', function() {
 469             var node1 = elementNodeFromParams({tag: 'div'}),
 470                 node2 = elementNodeFromParams({tag: 'a'}),
 471                 node3 = elementNodeFromParams({tag: 'p'});
 472             node1.prepend(node2);
 473             node1.prepend(node3);
 474             expect(node1.contents()[0].sameNode(node3)).to.be.true;
 475             expect(node1.contents()[1].sameNode(node2)).to.be.true;
 476         });
 477
 478         describe('adding text nodes', function() {
 479             it('merges text nodes on append', function() {
 480                 var doc = getDocumentFromXML('<root>text1</root>'),
 481                     returned;
 482                 returned = doc.root.append({text: 'text2'});
 483                 expect(doc.root.contents().length).to.equal(1);
 484                 expect(returned.sameNode(doc.root.contents()[0])).to.equal(true, 'modified node returned');
 485                 expect(doc.root.contents()[0].getText()).to.equal('text1text2');
 486             });
 487
 488             it('merges text nodes on prepend', function() {
 489                 var doc = getDocumentFromXML('<root>text1</root>'),
 490                     returned;
 491                 returned = doc.root.prepend({text: 'text2'});
 492                 expect(doc.root.contents().length).to.equal(1);
 493                 expect(returned.sameNode(doc.root.contents()[0])).to.equal(true, 'modified node returned');
 494                 expect(doc.root.contents()[0].getText()).to.equal('text2text1');
 495             });
 496
 497             it('merges text nodes on before text node', function() {
 498                 var doc = getDocumentFromXML('<root>text1</root>'),
 499                     textNode = doc.root.contents()[0],
 500                     returned;
 501                 returned = textNode.before({text: 'text2'});
 502                 expect(doc.root.contents().length).to.equal(1);
 503                 expect(returned.sameNode(doc.root.contents()[0])).to.equal(true, 'modified node returned');
 504                 expect(doc.root.contents()[0].getText()).to.equal('text2text1');
 505             });
 506
 507             it('merges text nodes on after text node', function() {
 508                 var doc = getDocumentFromXML('<root>text1</root>'),
 509                     textNode = doc.root.contents()[0],
 510                     returned;
 511                 returned = textNode.after({text: 'text2'});
 512                 expect(doc.root.contents().length).to.equal(1);
 513                 expect(returned.sameNode(doc.root.contents()[0])).to.equal(true, 'modified node returned');
 514                 expect(doc.root.contents()[0].getText()).to.equal('text1text2');
 515             });
 516
 517             it('merges text nodes on before element node', function() {
 518                 var doc = getDocumentFromXML('<root>text1<div></div></root>'),
 519                     textNode = doc.root.contents()[0],
 520                     div = doc.root.contents()[1],
 521                     returned;
 522                 returned = div.before({text: 'text2'});
 523                 expect(doc.root.contents().length).to.equal(2);
 524                 expect(returned.sameNode(doc.root.contents()[0])).to.equal(true, 'modified node returned');
 525                 expect(textNode.getText()).to.equal('text1text2');
 526             });
 527
 528             it('merges text nodes on after element node', function() {
 529                 var doc = getDocumentFromXML('<root><div></div>text1</root>'),
 530                     textNode = doc.root.contents()[1],
 531                     div = doc.root.contents()[0],
 532                     returned;
 533                 returned = div.after({text: 'text2'});
 534                 expect(doc.root.contents().length).to.equal(2);
 535                 expect(returned.sameNode(doc.root.contents()[1])).to.equal(true, 'modified node returned');
 536                 expect(textNode.getText()).to.equal('text2text1');
 537             });
 538         });
 539
 540         it('wraps root element node with another element node', function() {
 541             var node = elementNodeFromXML('<div></div>'),
 542                 wrapper = elementNodeFromXML('<wrapper></wrapper>');
 543
 544             node.wrapWith(wrapper);
 545             expect(node.parent().sameNode(wrapper)).to.be.true;
 546             expect(node.document.root.sameNode(wrapper)).to.be.true;
 547         });
 548
 549         it('wraps element node with another element node', function() {
 550             var doc = getDocumentFromXML('<section><div></div></section>'),
 551                 div = doc.root.contents()[0];
 552
 553             var wrapper = div.wrapWith({tagName: 'wrapper'});
 554             expect(wrapper.sameNode(doc.root.contents()[0])).to.equal(true, '1');
 555             expect(div.parent().sameNode(wrapper)).to.equal(true, '2');
 556             expect(wrapper.contents()[0].sameNode(div)).to.equal(true, '3');
 557         });
 558
 559         it('wraps element outside of document tree', function() {
 560             var doc = getDocumentFromXML('<section><div></div></section>'),
 561                 node = doc.createDocumentNode({tagName: 'node'});
 562
 563             node.wrapWith({tagName: 'wrapper'});
 564             expect(node.parent().getTagName()).to.equal('wrapper');
 565             expect(node.parent().contents()[0].sameNode(node)).to.be.true;
 566             expect(doc.root.getTagName()).to.equal('section');
 567         });
 568
 569         it('unwraps element node contents', function() {
 570             var node = elementNodeFromXML('<div>Alice <div>has <span>propably</span> a cat</div>!</div>'),
 571                 outerDiv = node.contents()[1];
 572
 573             outerDiv.unwrapContent();
 574
 575             expect(node.contents().length).to.equal(3);
 576             expect(node.contents()[0].getText()).to.equal('Alice has ');
 577             expect(node.contents()[1].getTagName()).to.equal('span');
 578             expect(node.contents()[2].getText()).to.equal(' a cat!');
 579         });
 580
 581         it('removes parent-describing sibling nodes of unwrapped node', function() {
 582             var doc = getDocumentFromXML('<root><div><a></a><x></x><a></a></div></root>'),
 583                 div = doc.root.contents()[0],
 584                 x = div.contents()[1];
 585
 586             doc.registerExtension({documentNode: {methods: {
 587                 object: {
 588                     describesParent: function() {
 589                         return this.getTagName() === 'x';
 590                     }
 591                 }
 592             }}});
 593
 594             div.unwrapContent();
 595             expect(doc.root.contents().length).to.equal(2);
 596             expect(x.isInDocument()).to.be.false;
 597         });
 598
 599         it('unwrap single element node from its parent', function() {
 600             var doc = getDocumentFromXML('<div><a><b></b></a></div>'),
 601                 div = doc.root,
 602                 a = div.contents()[0],
 603                 b = a.contents()[0];
 604
 605             var parent = b.unwrap();
 606
 607             expect(parent.sameNode(div)).to.equal(true, 'returns new parent');
 608             expect(div.contents()).to.have.length(1, 'root contains only one node');
 609             expect(div.contents()[0].sameNode(b)).to.equal(true, 'node got unwrapped');
 610         });
 611
 612         it('unwrap single text node from its parent', function() {
 613             var doc = getDocumentFromXML('<div>Some <span>text</span>!</div>'),
 614                 div = doc.root,
 615                 span = div.contents()[1],
 616                 text = span.contents()[0];
 617
 618             var parent = text.unwrap();
 619
 620             expect(parent.sameNode(div)).to.equal(true, 'returns new parent');
 621             expect(div.contents()).to.have.length(1, 'root contains only one node');
 622             expect(div.contents()[0].getText()).to.equal('Some text!');
 623         });
 624
 625         describe('Wrapping text', function() {
 626             it('wraps text spanning multiple sibling TextNodes', function() {
 627                 var section = elementNodeFromXML('<section>Alice has a <span>small</span> cat</section>'),
 628                     wrapper = section.wrapText({
 629                         _with: {tagName: 'span', attrs: {'attr1': 'value1'}},
 630                         offsetStart: 6,
 631                         offsetEnd: 4,
 632                         textNodeIdx: [0,2]
 633                     });
 634
 635                 expect(section.contents().length).to.equal(2);
 636                 expect(section.contents()[0].nodeType).to.equal(Node.TEXT_NODE);
 637                 expect(section.contents()[0].getText()).to.equal('Alice ');
 638
 639                 var wrapper2 = section.contents()[1];
 640                 expect(wrapper2.sameNode(wrapper)).to.be.true;
 641                 expect(wrapper.getTagName()).to.equal('span');
 642
 643                 var wrapperContents = wrapper.contents();
 644                 expect(wrapperContents.length).to.equal(3);
 645                 expect(wrapperContents[0].getText()).to.equal('has a ');
 646
 647                 expect(wrapperContents[1].nodeType).to.equal(Node.ELEMENT_NODE);
 648                 expect(wrapperContents[1].contents().length).to.equal(1);
 649                 expect(wrapperContents[1].contents()[0].getText()).to.equal('small');
 650             });
 651
 652             it('keeps parent-describing nodes in place', function() {
 653                 var doc = getDocumentFromXML('<root>Alice<x></x> has a cat</root>'),
 654                     root = doc.root,
 655                     x = root.contents()[1];
 656
 657                 doc.registerExtension({documentNode: {methods: {
 658                     object: {
 659                         describesParent: function() {
 660                             return this.getTagName() === 'x';
 661                         }
 662                     }
 663                 }}});
 664
 665                 root.wrapText({
 666                     _with: {tagName: 'span', attrs: {'attr1': 'value1'}},
 667                     offsetStart: 1,
 668                     offsetEnd: 4,
 669                     textNodeIdx: [0,2]
 670                 });
 671                 expect(x.parent().sameNode(root)).to.be.true;
 672             });
 673         });
 674
 675         describe('Wrapping Nodes', function() {
 676             it('wraps multiple sibling nodes', function() {
 677                 var section = elementNodeFromXML('<section>Alice<div>has</div><div>a cat</div></section>'),
 678                     aliceText = section.contents()[0],
 679                     firstDiv = section.contents()[1],
 680                     lastDiv = section.contents()[section.contents().length -1];
 681
 682                 var returned = section.document.wrapNodes({
 683                         node1: aliceText,
 684                         node2: lastDiv,
 685                         _with: {tagName: 'header'}
 686                     });
 687
 688                 var sectionContentss = section.contents(),
 689                     header = sectionContentss[0],
 690                     headerContents = header.contents();
 691
 692                 expect(sectionContentss).to.have.length(1);
 693                 expect(header.sameNode(returned)).to.equal(true, 'wrapper returned');
 694                 expect(header.parent().sameNode(section)).to.be.true;
 695                 expect(headerContents).to.have.length(3);
 696                 expect(headerContents[0].sameNode(aliceText)).to.equal(true, 'first node wrapped');
 697                 expect(headerContents[1].sameNode(firstDiv)).to.equal(true, 'second node wrapped');
 698                 expect(headerContents[2].sameNode(lastDiv)).to.equal(true, 'third node wrapped');
 699             });
 700
 701             it('wraps multiple sibling Elements - middle case', function() {
 702                 var section = elementNodeFromXML('<section><div></div><div></div><div></div><div></div></section>'),
 703                     div2 = section.contents()[1],
 704                     div3 = section.contents()[2];
 705
 706                 section.document.wrapNodes({
 707                         node1: div2,
 708                         node2: div3,
 709                         _with: {tagName: 'header'}
 710                     });
 711
 712                 var sectionContentss = section.contents(),
 713                     header = sectionContentss[1],
 714                     headerChildren = header.contents();
 715
 716                 expect(sectionContentss).to.have.length(3);
 717                 expect(headerChildren).to.have.length(2);
 718                 expect(headerChildren[0].sameNode(div2)).to.equal(true, 'first node wrapped');
 719                 expect(headerChildren[1].sameNode(div3)).to.equal(true, 'second node wrapped');
 720             });
 721
 722             it('keeps parent-describing nodes in place', function() {
 723                 var section = elementNodeFromXML('<section>Alice<x></x><div>a cat</div></section>'),
 724                     aliceText = section.contents()[0],
 725                     x = section.contents()[1],
 726                     lastDiv = section.contents()[2];
 727
 728                 section.document.registerExtension({documentNode: {methods: {
 729                     object: {
 730                         describesParent: function() {
 731                             return this.getTagName() === 'x';
 732                         }
 733                     }
 734                 }}});
 735
 736                 section.document.wrapNodes({
 737                         node1: aliceText,
 738                         node2: lastDiv,
 739                         _with: {tagName: 'header'}
 740                     });
 741
 742                 expect(x.parent().sameNode(section)).to.be.true;
 743             });
 744         });
 745
 746     });
 747
 748     var getTextNodes = function(text, doc) {
 749         /* globals Node */
 750         var toret = [];
 751         var search = function(node) {
 752             node.contents().forEach(function(node) {
 753                 if(node.nodeType === Node.TEXT_NODE) {
 754                     if(node.getText() === text) {
 755                         toret.push(node);
 756                     }
 757                 } else {
 758                     search(node);
 759                 }
 760             });
 761         };
 762         search(doc.root);
 763         return toret;
 764     };
 765
 766     var getTextNode = function(text, doc) {
 767         var nodes = getTextNodes(text, doc),
 768             error;
 769         if(nodes.length === 0) {
 770             error = 'Text not found';
 771         } else if(nodes.length > 1) {
 772             error = 'Text not unique';
 773         } else if(nodes[0].getText() !== text) {
 774             error = 'I was trying to cheat your test :(';
 775         }
 776         if(error) {
 777             throw new Error(error);
 778         }
 779         return nodes[0];
 780     };
 781
 782     describe('Removing arbitrary text', function() {
 783         it('removes within single text element', function() {
 784             var doc = getDocumentFromXML('<div>Alice</div>'),
 785                 text = getTextNode('Alice', doc);
 786             doc.deleteText({
 787                 from: {
 788                     node: text,
 789                     offset: 1
 790                 },
 791                 to: {
 792                     node: text,
 793                     offset: 4
 794                 }
 795             });
 796             expect(doc.root.contents().length).to.equal(1);
 797             expect(doc.root.contents()[0].getText()).to.equal('Ae');
 798         });
 799         it('removes across elements - 1', function() {
 800             var doc = getDocumentFromXML('<div><a>aaa</a><b>bbb</b></div>');
 801
 802             doc.deleteText({
 803                 from: {
 804                     node: getTextNode('aaa', doc),
 805                     offset: 2
 806                 },
 807                 to: {
 808                     node: getTextNode('bbb', doc),
 809                     offset: 2
 810                 }
 811             });
 812
 813             var contents = doc.root.contents();
 814             expect(contents.length).to.equal(2);
 815             expect(contents[0].contents()[0].getText()).to.equal('aa');
 816             expect(contents[1].contents()[0].getText()).to.equal('b');
 817         });
 818         it('removes across elements - 2', function() {
 819             var doc = getDocumentFromXML('<a><b><c>ccc</c></b>xxx</a>');
 820             doc.deleteText({
 821                 from: {
 822                     node: getTextNode('ccc', doc),
 823                     offset: 2
 824                 },
 825                 to: {
 826                     node: getTextNode('xxx', doc),
 827                     offset: 2
 828                 }
 829             });
 830
 831             var contents = doc.root.contents();
 832             expect(contents.length).to.equal(2);
 833             expect(contents[0].getTagName()).to.equal('b');
 834             expect(contents[1].getText()).to.equal('x');
 835
 836             var bContents = contents[0].contents();
 837             expect(bContents.length).to.equal(1);
 838             expect(bContents[0].getTagName()).to.equal('c');
 839             expect(bContents[0].contents().length).to.equal(1);
 840             expect(bContents[0].contents()[0].getText()).to.equal('cc');
 841         });
 842         it('remove across elements - 3 (merged text nodes)', function() {
 843             var doc = getDocumentFromXML('<div>Alice <span>has</span> a cat</div>');
 844             doc.deleteText({
 845                 from: {
 846                     node: getTextNode('Alice ', doc),
 847                     offset: 1
 848                 },
 849                 to: {
 850                     node: getTextNode(' a cat', doc),
 851                     offset: 3
 852                 }
 853             });
 854             var contents = doc.root.contents();
 855             expect(contents.length).to.equal(1);
 856             expect(contents[0].getText()).to.equal('Acat');
 857         });
 858         it('remove across elements - 4', function() {
 859             var doc = getDocumentFromXML('<div>Alice <div>has <span>a</span> cat</div></div>');
 860             doc.deleteText({
 861                 from: {
 862                     node: getTextNode('Alice ', doc),
 863                     offset: 1
 864                 },
 865                 to: {
 866                     node: getTextNode(' cat', doc),
 867                     offset: 1
 868                 }
 869             });
 870             var contents = doc.root.contents();
 871             expect(contents.length).to.equal(2);
 872             expect(contents[0].getText()).to.equal('A');
 873             expect(contents[1].getTagName()).to.equal('div');
 874             expect(contents[1].contents().length).to.equal(1);
 875             expect(contents[1].contents()[0].getText()).to.equal('cat');
 876         });
 877         it('removes across elements - 5 (whole document)', function() {
 878             var doc = getDocumentFromXML('<div>Alice <div>has <span>a</span> cat</div>!!!</div>');
 879             doc.deleteText({
 880                 from: {
 881                     node: getTextNode('Alice ', doc),
 882                     offset: 0
 883                 },
 884                 to: {
 885                     node: getTextNode('!!!', doc),
 886                     offset: 3
 887                 }
 888             });
 889
 890             expect(doc.root.getTagName()).to.equal('div');
 891             expect(doc.root.contents().length).to.equal(1);
 892             expect(doc.root.contents()[0].getText()).to.equal('');
 893         });
 894         it('removes nodes in between', function() {
 895             var doc = getDocumentFromXML('<div><a>aaa<x>!</x></a>xxx<x></x><b><x>!</x>bbb</b></div>');
 896             doc.deleteText({
 897                 from: {
 898                     node: getTextNode('aaa', doc),
 899                     offset: 2
 900                 },
 901                 to: {
 902                     node: getTextNode('bbb', doc),
 903                     offset: 2
 904                 }
 905             });
 906
 907             var contents = doc.root.contents();
 908             expect(contents.length).to.equal(2, 'two nodes survived');
 909             expect(contents[0].getTagName()).to.equal('a');
 910             expect(contents[1].getTagName()).to.equal('b');
 911             expect(contents[0].contents().length).to.equal(1);
 912             expect(contents[0].contents()[0].getText()).to.equal('aa');
 913             expect(contents[1].contents().length).to.equal(1);
 914             expect(contents[1].contents()[0].getText()).to.equal('b');
 915         });
 916     });
 917
 918     describe('Splitting text', function() {
 919
 920         it('splits TextNode\'s parent into two ElementNodes', function() {
 921             var doc = getDocumentFromXML('<section><header>Some header</header></section>'),
 922                 section = doc.root,
 923                 text = section.contents()[0].contents()[0];
 924
 925             var returnedValue = text.split({offset: 5});
 926             expect(section.contents().length).to.equal(2, 'section has two children');
 927
 928             var header1 = section.contents()[0];
 929             var header2 = section.contents()[1];
 930
 931             expect(header1.getTagName()).to.equal('header', 'first section child ok');
 932             expect(header1.contents().length).to.equal(1, 'first header has one child');
 933             expect(header1.contents()[0].getText()).to.equal('Some ', 'first header has correct content');
 934             expect(header2.getTagName()).to.equal('header', 'second section child ok');
 935             expect(header2.contents().length).to.equal(1, 'second header has one child');
 936             expect(header2.contents()[0].getText()).to.equal('header', 'second header has correct content');
 937
 938             expect(returnedValue.first.sameNode(header1)).to.equal(true, 'first node returned');
 939             expect(returnedValue.second.sameNode(header2)).to.equal(true, 'second node returned');
 940         });
 941
 942         it('leaves empty copy of ElementNode if splitting at the very beginning', function() {
 943                 var doc = getDocumentFromXML('<section><header>Some header</header></section>'),
 944                 section = doc.root,
 945                 text = section.contents()[0].contents()[0];
 946
 947                 text.split({offset: 0});
 948
 949                 var header1 = section.contents()[0];
 950                 var header2 = section.contents()[1];
 951
 952                 expect(header1.contents().length).to.equal(0);
 953                 expect(header2.contents()[0].getText()).to.equal('Some header');
 954         });
 955
 956         it('leaves empty copy of ElementNode if splitting at the very end', function() {
 957                 var doc = getDocumentFromXML('<section><header>Some header</header></section>'),
 958                 section = doc.root,
 959                 text = section.contents()[0].contents()[0];
 960
 961                 text.split({offset: 11});
 962
 963                 var header1 = section.contents()[0];
 964                 var header2 = section.contents()[1];
 965
 966                 expect(header1.contents()[0].getText()).to.equal('Some header');
 967                 expect(header2.contents().length).to.equal(0);
 968         });
 969
 970         it('keeps TextNodes\'s parent\'s children elements intact', function() {
 971             var doc = getDocumentFromXML('<section><header>A <span>fancy</span> and <span>nice</span> header</header></section>'),
 972                 section = doc.root,
 973                 header = section.contents()[0],
 974                 textAnd = header.contents()[2];
 975
 976             textAnd.split({offset: 2});
 977
 978             var sectionContents = section.contents();
 979             expect(sectionContents.length).to.equal(2, 'Section has two children');
 980             expect(sectionContents[0].getTagName()).to.equal('header', 'First section node is a header');
 981             expect(sectionContents[1].getTagName()).to.equal('header', 'Second section node is a header');
 982
 983             var firstHeaderContents = sectionContents[0].contents();
 984             expect(firstHeaderContents.length).to.equal(3, 'First header has three children');
 985             expect(firstHeaderContents[0].getText()).to.equal('A ', 'First header starts with a text');
 986             expect(firstHeaderContents[1].getTagName()).to.equal('span', 'First header has span in the middle');
 987             expect(firstHeaderContents[2].getText()).to.equal(' a', 'First header ends with text');
 988
 989             var secondHeaderContents = sectionContents[1].contents();
 990             expect(secondHeaderContents.length).to.equal(3, 'Second header has three children');
 991             expect(secondHeaderContents[0].getText()).to.equal('nd ', 'Second header starts with text');
 992             expect(secondHeaderContents[1].getTagName()).to.equal('span', 'Second header has span in the middle');
 993             expect(secondHeaderContents[2].getText()).to.equal(' header', 'Second header ends with text');
 994         });
 995     });
 996
 997     describe('Events', function() {
 998         it('emits nodeDetached event on node detach', function() {
 999             var node = elementNodeFromXML('<div><div></div></div>'),
1000                 innerNode = node.contents()[0],
1001                 spy = sinon.spy();
1002             node.document.on('change', spy);
1003
1004             var detached = innerNode.detach(),
1005                 event = spy.args[0][0];
1006
1007             expect(event.type).to.equal('nodeDetached');
1008             expect(event.meta.node.sameNode(detached, 'detached node in event meta'));
1009             expect(event.meta.parent.sameNode(node), 'original parent node in event meta');
1010         }),
1011
1012         it('emits nodeAdded event when appending new node', function() {
1013             var node = elementNodeFromXML('<div></div>'),
1014                 spy = sinon.spy();
1015             node.document.on('change', spy);
1016
1017             var appended = node.append({tagName:'div'}),
1018                 event = spy.args[0][0];
1019             expect(event.type).to.equal('nodeAdded');
1020             expect(event.meta.node.sameNode(appended)).to.be.true;
1021         });
1022
1023         it('emits nodeDetached/nodeAdded events with `move` flag when appending aready existing node', function() {
1024             var node = elementNodeFromXML('<div><a></a><b></b></div>'),
1025                 a = node.contents()[0],
1026                 b = node.contents()[1],
1027                 spy = sinon.spy();
1028             node.document.on('change', spy);
1029
1030             var appended = a.append(b),
1031                 detachedEvent = spy.args[0][0],
1032                 addedEvent = spy.args[1][0];
1033
1034             expect(spy.callCount).to.equal(2);
1035             expect(detachedEvent.type).to.equal('nodeDetached');
1036             expect(detachedEvent.meta.node.sameNode(appended)).to.be.true;
1037             expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
1038             expect(addedEvent.type).to.equal('nodeAdded');
1039             expect(addedEvent.meta.node.sameNode(appended)).to.be.true;
1040             expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
1041
1042         });
1043
1044         it('emits nodeAdded event when prepending new node', function() {
1045             var node = elementNodeFromXML('<div></div>'),
1046                 spy = sinon.spy();
1047             node.document.on('change', spy);
1048
1049             var prepended = node.prepend({tagName:'div'}),
1050                 event = spy.args[0][0];
1051             expect(event.type).to.equal('nodeAdded');
1052             expect(event.meta.node.sameNode(prepended)).to.be.true;
1053         });
1054
1055         it('emits nodeDetached/nodeAdded events with `move` flag when prepending aready existing node', function() {
1056             var node = elementNodeFromXML('<div><a></a><b></b></div>'),
1057                 a = node.contents()[0],
1058                 b = node.contents()[1],
1059                 spy = sinon.spy();
1060             node.document.on('change', spy);
1061
1062             var prepended = a.prepend(b),
1063                 detachedEvent = spy.args[0][0],
1064                 addedEvent = spy.args[1][0];
1065
1066             expect(spy.callCount).to.equal(2);
1067             expect(detachedEvent.type).to.equal('nodeDetached');
1068             expect(detachedEvent.meta.node.sameNode(prepended)).to.be.true;
1069             expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
1070             expect(addedEvent.type).to.equal('nodeAdded');
1071             expect(addedEvent.meta.node.sameNode(prepended)).to.be.true;
1072             expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
1073         });
1074
1075         it('emits nodeAdded event when inserting node after another', function() {
1076             var node = elementNodeFromXML('<div><a></a></div>').contents()[0],
1077                 spy = sinon.spy();
1078             node.document.on('change', spy);
1079
1080             var inserted = node.after({tagName:'div'}),
1081                 event = spy.args[0][0];
1082             expect(event.type).to.equal('nodeAdded');
1083             expect(event.meta.node.sameNode(inserted)).to.be.true;
1084         });
1085
1086         it('emits nodeDetached/nodeAdded events with `move` flag when inserting aready existing node after another', function() {
1087             var node = elementNodeFromXML('<div><a></a><b></b></div>'),
1088                 a = node.contents()[0],
1089                 b = node.contents()[1],
1090                 spy = sinon.spy();
1091             node.document.on('change', spy);
1092             var inserted = b.after(a),
1093                 detachedEvent = spy.args[0][0],
1094                 addedEvent = spy.args[1][0];
1095
1096             expect(spy.callCount).to.equal(2);
1097             expect(detachedEvent.type).to.equal('nodeDetached');
1098             expect(detachedEvent.meta.node.sameNode(inserted)).to.be.true;
1099             expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
1100             expect(addedEvent.type).to.equal('nodeAdded');
1101             expect(addedEvent.meta.node.sameNode(inserted)).to.be.true;
1102             expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
1103         });
1104
1105         it('emits nodeAdded event when inserting node before another', function() {
1106             var node = elementNodeFromXML('<div><a></a></div>').contents()[0],
1107                 spy = sinon.spy();
1108             node.document.on('change', spy);
1109
1110             var inserted = node.before({tagName:'div'}),
1111                 event = spy.args[0][0];
1112             expect(event.type).to.equal('nodeAdded');
1113             expect(event.meta.node.sameNode(inserted)).to.be.true;
1114         });
1115
1116         it('emits nodeDetached/nodeAdded events with `move` flag when inserting aready existing node before another', function() {
1117             var node = elementNodeFromXML('<div><a></a><b></b></div>'),
1118                 a = node.contents()[0],
1119                 b = node.contents()[1],
1120                 spy = sinon.spy();
1121             node.document.on('change', spy);
1122             var inserted = a.before(b),
1123                 detachedEvent = spy.args[0][0],
1124                 addedEvent = spy.args[1][0];
1125
1126             expect(spy.callCount).to.equal(2);
1127             expect(detachedEvent.type).to.equal('nodeDetached');
1128             expect(detachedEvent.meta.node.sameNode(inserted)).to.be.true;
1129             expect(detachedEvent.meta.move).to.equal(true, 'move flag set to true for nodeDetachedEvent');
1130             expect(addedEvent.type).to.equal('nodeAdded');
1131             expect(addedEvent.meta.node.sameNode(inserted)).to.be.true;
1132             expect(addedEvent.meta.move).to.equal(true, 'move flag set to true for nodeAddedEvent');
1133         });
1134
1135         it('emits nodeDetached and nodeAdded when replacing root node with another', function() {
1136             var doc = getDocumentFromXML('<a></a>'),
1137                 oldRoot = doc.root,
1138                 spy = sinon.spy();
1139
1140             doc.on('change', spy);
1141
1142             doc.root.replaceWith({tagName: 'b'});
1143
1144             expect(spy.callCount).to.equal(2);
1145
1146             var event1 = spy.args[0][0],
1147                 event2 = spy.args[1][0];
1148
1149             expect(event1.type).to.equal('nodeDetached');
1150             expect(event1.meta.node.sameNode(oldRoot)).to.equal(true, 'root node in nodeDetached event metadata');
1151             expect(event2.type).to.equal('nodeAdded');
1152             expect(event2.meta.node.sameNode(doc.root)).to.equal(true, 'new root node in nodelAdded event meta');
1153         });
1154
1155
1156         ['append', 'prepend', 'before', 'after'].forEach(function(insertionMethod) {
1157             it('emits nodeDetached for node moved from a document tree to out of document node ' + insertionMethod, function() {
1158                 var doc = getDocumentFromXML('<div><a></a></div>'),
1159                     a = doc.root.contents()[0],
1160                     spy = sinon.spy();
1161
1162                 doc.on('change', spy);
1163
1164                 var newNode = doc.createDocumentNode({tagName: 'b'}),
1165                     newNodeInner = newNode.append({tagName:'c'});
1166
1167                 newNodeInner[insertionMethod](a);
1168
1169                 var event = spy.args[0][0];
1170                 expect(event.type).to.equal('nodeDetached');
1171                 expect(event.meta.node.sameNode(a));
1172             });
1173
1174             it('doesn\'t emit nodeDetached event for already out of document node moved to out of document node' + insertionMethod, function() {
1175                 var doc = getDocumentFromXML('<div><a></a></div>'),
1176                     spy = sinon.spy();
1177
1178                 doc.on('change', spy);
1179
1180                 var newNode = doc.createDocumentNode({tagName: 'b'});
1181                 newNode.append({tagName:'c'});
1182
1183                 expect(spy.callCount).to.equal(0);
1184             });
1185         });
1186
1187
1188     });
1189
1190     describe('Traversing', function() {
1191         describe('Basic', function() {
1192             it('can access node parent', function() {
1193                 var doc = getDocumentFromXML('<a><b></b></a>'),
1194                     a = doc.root,
1195                     b = a.contents()[0];
1196
1197                 expect(a.parent()).to.equal(null, 'parent of a root is null');
1198                 expect(b.parent().sameNode(a)).to.be.true;
1199             });
1200             it('can access node parents', function() {
1201                 var doc = getDocumentFromXML('<a><b><c></c></b></a>'),
1202                     a = doc.root,
1203                     b = a.contents()[0],
1204                     c = b.contents()[0];
1205
1206                 var parents = c.parents();
1207                 // @@
1208                 expect(parents[0].sameNode(b)).to.be.true;
1209                 expect(parents[1].sameNode(a)).to.be.true;
1210             });
1211         });
1212
1213         describe('finding sibling parents of two elements', function() {
1214             it('returns elements themself if they have direct common parent', function() {
1215                 var doc = getDocumentFromXML('<section><div><div>A</div><div>B</div></div></section>'),
1216                     wrappingDiv = doc.root.contents()[0],
1217                     divA = wrappingDiv.contents()[0],
1218                     divB = wrappingDiv.contents()[1];
1219
1220                 var siblingParents = doc.getSiblingParents({node1: divA, node2: divB});
1221
1222                 expect(siblingParents.node1.sameNode(divA)).to.equal(true, 'divA');
1223                 expect(siblingParents.node2.sameNode(divB)).to.equal(true, 'divB');
1224             });
1225
1226             it('returns sibling parents - example 1', function() {
1227                 var doc = getDocumentFromXML('<section>Alice <span>has a cat</span></section>'),
1228                     aliceText = doc.root.contents()[0],
1229                     span = doc.root.contents()[1],
1230                     spanText = span.contents()[0];
1231
1232                 var siblingParents = doc.getSiblingParents({node1: aliceText, node2: spanText});
1233
1234                 expect(siblingParents.node1.sameNode(aliceText)).to.equal(true, 'aliceText');
1235                 expect(siblingParents.node2.sameNode(span)).to.equal(true, 'span');
1236             });
1237
1238             it('returns node itself for two same nodes', function() {
1239                 var doc = getDocumentFromXML('<section><div></div></section>'),
1240                     div = doc.root.contents()[0];
1241
1242                 var siblingParents = doc.getSiblingParents({node1: div, node2: div});
1243                 expect(!!siblingParents.node1 && !!siblingParents.node2).to.equal(true, 'nodes defined');
1244                 expect(siblingParents.node1.sameNode(div)).to.be.equal(true, 'node1');
1245                 expect(siblingParents.node2.sameNode(div)).to.be.equal(true, 'node2');
1246             });
1247         });
1248     });
1249
1250     describe('Serializing document to WLXML', function() {
1251         it('keeps document intact when no changes have been made', function() {
1252             var xmlIn = '<section>Alice<div>has</div>a <span class="uri" meta-uri="http://cat.com">cat</span>!</section>',
1253                 doc = getDocumentFromXML(xmlIn),
1254                 xmlOut = doc.toXML();
1255
1256             var parser = new DOMParser(),
1257                 input = parser.parseFromString(xmlIn, 'application/xml').childNodes[0],
1258                 output = parser.parseFromString(xmlOut, 'application/xml').childNodes[0];
1259
1260             expect(input.isEqualNode(output)).to.be.true;
1261         });
1262
1263         it('keeps entities intact', function() {
1264             var xmlIn = '<section>&lt; &gt;</section>',
1265                 doc = getDocumentFromXML(xmlIn),
1266                 xmlOut = doc.toXML();
1267             expect(xmlOut).to.equal(xmlIn);
1268         });
1269         it('keeps entities intact when they form html/xml', function() {
1270             var xmlIn = '<section>&lt;abc&gt;</section>',
1271                 doc = getDocumentFromXML(xmlIn),
1272                 xmlOut = doc.toXML();
1273             expect(xmlOut).to.equal(xmlIn);
1274         });
1275     });
1276
1277     describe('Extension API', function() {
1278         var doc, extension, elementNode, textNode;
1279
1280         beforeEach(function() {
1281             doc = getDocumentFromXML('<section>Alice<div class="test_class"></div></section>');
1282             elementNode = doc.root;
1283             textNode = doc.root.contents()[0];
1284             extension = {};
1285
1286             expect(elementNode.testTransformation).to.be.undefined;
1287             expect(textNode.testTransformation).to.be.undefined;
1288             expect(doc.testTransformation).to.be.undefined;
1289
1290             expect(doc.testMethod).to.be.undefined;
1291             expect(elementNode.testMethod).to.be.undefined;
1292             expect(textNode.testMethod).to.be.undefined;
1293             expect(elementNode.elementTestMethod).to.be.undefined;
1294             expect(textNode.textTestMethod).to.be.undefined;
1295         });
1296
1297         it('allows adding method to a document', function() {
1298             extension = {document: {methods: {
1299                 testMethod: function() { return this; }
1300             }}};
1301
1302             doc.registerExtension(extension);
1303             expect(doc.testMethod()).to.equal(doc, 'context is set to a document instance');
1304         });
1305
1306         it('allows adding transformation to a document', function() {
1307             extension = {document: {transformations: {
1308                 testTransformation: function() { return this; },
1309                 testTransformation2: {impl: function() { return this;}}
1310             }}};
1311
1312             doc.registerExtension(extension);
1313             expect(doc.testTransformation()).to.equal(doc, 'context is set to a document instance');
1314             expect(doc.testTransformation2()).to.equal(doc, 'context is set to a document instance');
1315         });
1316
1317         it('allows adding method to a DocumentNode instance', function() {
1318             extension = {
1319                 documentNode: {
1320                     methods: {
1321                         testMethod: function() { return this; }
1322                     }
1323                 },
1324                 textNode: {
1325                     methods: {
1326                         textTestMethod: function() { return this; }
1327                     }
1328                 },
1329                 elementNode: {
1330                     methods: {
1331                         elementTestMethod: function() { return this; }
1332                     }
1333                 }
1334             };
1335
1336             doc.registerExtension(extension);
1337
1338             /* refresh */
1339             elementNode = doc.root;
1340             textNode = doc.root.contents()[0];
1341
1342             expect(elementNode.testMethod().sameNode(elementNode)).to.equal(true, 'context is set to a node instance');
1343             expect(textNode.testMethod().sameNode(textNode)).to.equal(true, 'context is set to a node instance');
1344
1345             expect(elementNode.elementTestMethod().sameNode(elementNode)).to.be.true;
1346             expect(elementNode.textTestMethod).to.be.undefined;
1347
1348             expect(textNode.textTestMethod().sameNode(textNode)).to.be.true;
1349             expect(textNode.elementTestMethod).to.be.undefined;
1350         });
1351
1352         it('allows adding transformation to a DocumentNode', function() {
1353             extension = {
1354                 documentNode: {
1355                     transformations: {
1356                         testTransformation: function() { return this; },
1357                         testTransformation2: {impl: function() { return this;}}
1358                     }
1359                 },
1360                 textNode: {
1361                     transformations: {
1362                         textTestTransformation: function() { return this; }
1363                     }
1364                 },
1365                 elementNode: {
1366                     transformations: {
1367                         elementTestTransformation: function() { return this; }
1368                     }
1369                 }
1370             };
1371
1372             doc.registerExtension(extension);
1373
1374             /* refresh */
1375             elementNode = doc.root;
1376             textNode = doc.root.contents()[0];
1377
1378             expect(elementNode.testTransformation().sameNode(elementNode)).to.equal(true, '1');
1379             expect(elementNode.testTransformation2().sameNode(elementNode)).to.equal(true, '2');
1380             expect(textNode.testTransformation().sameNode(textNode)).to.equal(true, '3');
1381             expect(textNode.testTransformation2().sameNode(textNode)).to.equal(true, '4');
1382
1383             expect(elementNode.elementTestTransformation().sameNode(elementNode)).to.be.true;
1384             expect(elementNode.textTestTransformation).to.be.undefined;
1385
1386             expect(textNode.textTestTransformation().sameNode(textNode)).to.be.true;
1387             expect(textNode.elementTestTransfomation).to.be.undefined;
1388         });
1389
1390         it('allows text/element node methods and transformations to access node and transormations on document node', function() {
1391
1392             var doc = getDocumentFromXML('<div>text</div>');
1393
1394             doc.registerExtension({
1395                 documentNode: {
1396                     methods: {
1397                         test: function() {
1398                             return 'super';
1399                         }
1400                     },
1401                     transformations: {
1402                         testT: function() {
1403                             return 'super_trans';
1404                         }
1405                     }
1406                 },
1407                 elementNode: {
1408                     methods: {
1409                         test: function() {
1410                             return 'element_sub_' + this.__super__.test();
1411                         }
1412                     },
1413                     transformations: {
1414                         testT: function() {
1415                             return 'element_trans_sub_' + this.__super__.testT();
1416                         }
1417                     }
1418                 },
1419                 textNode: {
1420                     methods: {
1421                         test: function() {
1422                             return 'text_sub_' + this.__super__.test();
1423                         }
1424                     },
1425                     transformations: {
1426                         testT: function() {
1427                             return 'text_trans_sub_' + this.__super__.testT();
1428                         }
1429                     }
1430                 }
1431             });
1432
1433             var textNode = doc.root.contents()[0];
1434
1435             expect(doc.root.test()).to.equal('element_sub_super');
1436             expect(textNode.test()).to.equal('text_sub_super');
1437             expect(doc.root.testT()).to.equal('element_trans_sub_super_trans');
1438             expect(textNode.testT()).to.equal('text_trans_sub_super_trans');
1439         });
1440     });
1441
1442     describe('Undo/redo', function() {
1443
1444         it('smoke tests', function() {
1445             var doc = getDocumentFromXML('<div>Alice</div>'),
1446                 textNode = doc.root.contents()[0];
1447
1448             expect(doc.undoStack).to.have.length(0);
1449
1450             textNode.wrapWith({tagName: 'span', start:1, end:2});
1451             expect(doc.undoStack).to.have.length(1, '1');
1452             expect(doc.toXML()).to.equal('<div>A<span>l</span>ice</div>');
1453
1454             doc.undo();
1455             expect(doc.undoStack).to.have.length(0, '2');
1456             expect(doc.toXML()).to.equal('<div>Alice</div>');
1457
1458             doc.redo();
1459             expect(doc.undoStack).to.have.length(1, '3');
1460             expect(doc.toXML()).to.equal('<div>A<span>l</span>ice</div>');
1461
1462             doc.undo();
1463             expect(doc.undoStack).to.have.length(0, '4');
1464             expect(doc.toXML()).to.equal('<div>Alice</div>');
1465
1466             doc.undo();
1467             expect(doc.undoStack).to.have.length(0, '5');
1468             expect(doc.toXML()).to.equal('<div>Alice</div>');
1469         });
1470
1471         it('smoke tests 2', function() {
1472             var doc = getDocumentFromXML('<div>Alice</div>'),
1473                 textNode = doc.root.contents()[0],
1474                 path = textNode.getPath();
1475
1476             textNode.setText('Alice ');
1477             textNode.setText('Alice h');
1478             textNode.setText('Alice ha');
1479             textNode.setText('Alice has');
1480
1481             expect(textNode.getText()).to.equal('Alice has');
1482
1483             doc.undo();
1484             expect(doc.root.contents()[0].getText()).to.equal('Alice ha', '1');
1485
1486             doc.undo();
1487             expect(doc.root.contents()[0].getText()).to.equal('Alice h', '2');
1488
1489             doc.redo();
1490             expect(doc.root.contents()[0].getText()).to.equal('Alice ha', '3');
1491
1492             doc.redo();
1493             expect(doc.root.contents()[0].getText()).to.equal('Alice has', '4');
1494
1495             doc.undo();
1496             doc.undo();
1497             textNode = doc.getNodeByPath(path);
1498             textNode.setText('Cat');
1499             doc.undo();
1500             textNode = doc.getNodeByPath(path);
1501             expect(textNode.getText()).to.equal('Alice h');
1502         });
1503
1504
1505         var sampleMethod = function(val) {
1506             this._$.attr('x', val);
1507             this.triggerChangeEvent();
1508         };
1509
1510         var transformations = {
1511             'unaware': sampleMethod,
1512             'returning change root': {
1513                 impl: sampleMethod,
1514                 getChangeRoot: function() {
1515                     return this.context;
1516                 }
1517             },
1518             'implementing undo operation': {
1519                 impl: function(t, val) {
1520                     t.oldVal = this.getAttr('x');
1521                     sampleMethod.call(this, val);
1522                 },
1523                 undo: function(t) {
1524                     this.setAttr('x', t.oldVal);
1525                 }
1526             }
1527         };
1528
1529         _.pairs(transformations).forEach(function(pair) {
1530             var name = pair[0],
1531                 transformaton = pair[1];
1532
1533             describe(name + ' transformation: ', function() {
1534                 var doc, node, nodePath;
1535
1536                 beforeEach(function() {
1537                     doc = getDocumentFromXML('<div><test x="old"></test></div>');
1538
1539                     doc.registerExtension({elementNode: {transformations: {
1540                         test: transformaton
1541                     }}});
1542
1543                     node = doc.root.contents()[0];
1544                     nodePath = node.getPath();
1545                 });
1546
1547                 it('transforms as expected', function() {
1548                     node.test('new');
1549                     expect(node.getAttr('x')).to.equal('new');
1550                 });
1551
1552                 it('can be undone', function() {
1553                     node.test('new');
1554                     doc.undo();
1555                     node = doc.getNodeByPath(nodePath);
1556                     expect(node.getAttr('x')).to.equal('old');
1557                 });
1558
1559                 it('can be undone and then redone', function() {
1560                     node.test('new');
1561                     doc.undo();
1562                     doc.redo();
1563                     node = doc.getNodeByPath(nodePath);
1564                     expect(node.getAttr('x')).to.equal('new');
1565                 });
1566
1567                 it('handles a sample scenario', function() {
1568                     doc.root.contents()[0].test('1');
1569                     doc.root.contents()[0].test('2');
1570                     doc.root.contents()[0].test('3');
1571                     doc.root.contents()[0].test('4');
1572                     doc.root.contents()[0].test('5');
1573
1574                     expect(doc.root.contents()[0].getAttr('x')).to.equal('5', 'after initial transformations');
1575                     doc.undo();
1576                     expect(doc.root.contents()[0].getAttr('x')).to.equal('4', 'undo 1.1');
1577                     doc.undo();
1578                     expect(doc.root.contents()[0].getAttr('x')).to.equal('3', 'undo 1.2');
1579                     doc.redo();
1580                     expect(doc.root.contents()[0].getAttr('x')).to.equal('4', 'redo 1.1');
1581                     doc.redo();
1582                     expect(doc.root.contents()[0].getAttr('x')).to.equal('5', 'redo 1.2');
1583                     doc.undo();
1584                     expect(doc.root.contents()[0].getAttr('x')).to.equal('4', 'undo 2.1');
1585                     doc.root.contents()[0].test('10');
1586                     expect(doc.root.contents()[0].getAttr('x')).to.equal('10', 'additional transformation');
1587                     expect(doc.redoStack.length).to.equal(0, 'transformation cleared redo stack');
1588                     doc.redo();
1589                     expect(doc.root.contents()[0].getAttr('x')).to.equal('10', 'empty redoStack so redo was noop');
1590                     doc.undo();
1591                     expect(doc.root.contents()[0].getAttr('x')).to.equal('4', 'undoing additional transformation');
1592                     doc.redo();
1593                     expect(doc.root.contents()[0].getAttr('x')).to.equal('10', 'redoing additional transformation');
1594                 });
1595             });
1596         });
1597
1598         it('smoke tests nested transformations', function() {
1599             var doc = getDocumentFromXML('<div></div>');
1600
1601             doc.registerExtension({elementNode: {transformations: {
1602                 nested: function(v) {
1603                     this._$.attr('innerAttr', v);
1604                     this.triggerChangeEvent();
1605                 },
1606                 outer: function(v) {
1607                     this.nested(v);
1608                     this._$.attr('outerAttr', v);
1609                     this.triggerChangeEvent();
1610                 }
1611             }}});
1612
1613             doc.root.outer('test1');
1614             doc.root.outer('test2');
1615
1616             expect(doc.root.getAttr('innerAttr')).to.equal('test2');
1617             expect(doc.root.getAttr('outerAttr')).to.equal('test2');
1618
1619             doc.undo();
1620
1621             expect(doc.root.getAttr('innerAttr')).to.equal('test1');
1622             expect(doc.root.getAttr('outerAttr')).to.equal('test1');
1623
1624             doc.undo();
1625
1626             expect(doc.root.getAttr('innerAttr')).to.equal(undefined);
1627             expect(doc.root.getAttr('outerAttr')).to.equal(undefined);
1628
1629             doc.redo();
1630
1631             expect(doc.root.getAttr('innerAttr')).to.equal('test1');
1632             expect(doc.root.getAttr('outerAttr')).to.equal('test1');
1633
1634             doc.redo();
1635
1636             expect(doc.root.getAttr('innerAttr')).to.equal('test2');
1637             expect(doc.root.getAttr('outerAttr')).to.equal('test2');
1638
1639         });
1640
1641         it('ignores transformation if document didn\'t emit change event', function() {
1642             var doc = getDocumentFromXML('<div></div>');
1643
1644             doc.registerExtension({elementNode: {transformations: {
1645                 test: function() {
1646                     // empty
1647                 }
1648             }}});
1649
1650             doc.root.test();
1651             expect(doc.undoStack.length).to.equal(0);
1652
1653         });
1654
1655         describe('Transactions', function() {
1656             it('allows to undo/redo series of transformations at once', function() {
1657                 var doc = getDocumentFromXML('<div></div>');
1658
1659                 doc.registerExtension({
1660                     elementNode: {transformations: {
1661                         test: function(v) {
1662                             this.setAttr('test', v);
1663                         }
1664                     }}
1665                 });
1666
1667                 doc.startTransaction();
1668                 doc.root.test('1');
1669                 doc.root.test('2');
1670                 doc.root.test('3');
1671                 doc.endTransaction();
1672
1673                 doc.undo();
1674                 expect(doc.root.getAttr('test'), '1');
1675                 doc.redo();
1676                 expect(doc.root.getAttr('test'), '3');
1677                 doc.undo();
1678                 expect(doc.root.getAttr('test'), '1');
1679                 doc.redo();
1680                 expect(doc.root.getAttr('test'), '3');
1681             });
1682
1683             it('ignores empty transactions', function() {
1684                 var doc = getDocumentFromXML('<div></div>');
1685                 doc.startTransaction();
1686                 doc.endTransaction();
1687                 expect(doc.undoStack).to.have.length(0, 'empty transaction doesn\'t get pushed into undo stack');
1688             });
1689
1690             it('doesn\'t break on optimizations', function() {
1691                 // This is a smoke test checking if optimizations made to transaction undoing
1692                 // doesnt't break anything.
1693                 var doc = getDocumentFromXML('<div smart="1" unaware="1"></div>');
1694
1695                 doc.registerExtension({
1696                     elementNode: {transformations: {
1697                         unaware: function(v) {
1698                             this.setAttr('unware', v);
1699                             this.triggerChangeEvent();
1700                         },
1701                         smart: {
1702                             impl: function(t, v) {
1703                                 t.oldVal = this.getAttr('smart');
1704                                 this.setAttr('smart', v);
1705                                 this.triggerChangeEvent();
1706                             },
1707                             undo: function(t) {
1708                                 this.setAttr('smart', t.oldVal);
1709                                 this.triggerChangeEvent();
1710                             }
1711                         }
1712                     }}
1713                 });
1714
1715                 doc.startTransaction();
1716                 doc.root.smart('2');
1717                 doc.root.unaware('2');
1718                 doc.root.smart('3');
1719                 doc.root.unaware('3');
1720                 doc.endTransaction();
1721
1722                 doc.undo();
1723
1724                 expect(doc.root.getAttr('smart')).to.equal('1');
1725                 expect(doc.root.getAttr('unaware')).to.equal('1');
1726             });
1727
1728             it('can have associated metadata', function() {
1729                 var doc = getDocumentFromXML('<div></div>'),
1730                     metadata = Object.create({});
1731
1732                 doc.registerExtension({document: {transformations: {
1733                     test: function() {
1734                         this.trigger('change');
1735                     }
1736                 }}});
1737
1738                 doc.startTransaction(metadata);
1739                 doc.test();
1740                 doc.endTransaction();
1741
1742                 var transaction = doc.undoStack[0];
1743                 expect(transaction.metadata).to.equal(metadata);
1744             });
1745
1746             it('can be rolled back', function() {
1747                 var doc = getDocumentFromXML('<root></root>');
1748
1749                 doc.startTransaction();
1750                 doc.root.append({tagName: 'div'});
1751                 doc.rollbackTransaction();
1752
1753                 expect(doc.undoStack.length).to.equal(0, 'nothing to undo');
1754                 expect(doc.root.contents().length).to.equal(0);
1755             });
1756
1757             it('rollbacks and calls error handleor if error gets thrown', function() {
1758                 var doc = getDocumentFromXML('<root></root>'),
1759                     err = new Error(),
1760                     spy = sinon.spy();
1761
1762                 doc.transaction(function() {
1763                     doc.root.append({tagName: 'div'});
1764                     throw err;
1765                 }, {error: spy});
1766
1767                 expect(spy.args[0][0]).to.equal(err);
1768                 expect(doc.root.contents().length).to.equal(0);
1769                 expect(doc.undoStack.length).to.equal(0);
1770             });
1771         });
1772
1773         describe('Regression tests', function() {
1774             it('redos correctly after running its own undo followed by unaware transformation undo', function() {
1775                 var doc = getDocumentFromXML('<section t="0"></section>');
1776
1777                 doc.registerExtension({elementNode: {transformations: {
1778                     unaware: function() {
1779                         this.triggerChangeEvent();
1780                     },
1781                     test: {
1782                         impl: function() {
1783                             this._$.attr('t', 1);
1784                             this.triggerChangeEvent();
1785                         },
1786                         undo: function() {
1787                             this._$.attr('t', 0);
1788                         }
1789                     }
1790                 }}});
1791                 doc.root.unaware();
1792                 doc.root.test();
1793                 doc.undo();
1794                 doc.undo();
1795                 doc.redo();
1796                 doc.redo();
1797                 expect(doc.root.getAttr('t')).to.equal('1');
1798             });
1799             it('can perform undo of an operation performed after automatic transaction rollback', function() {
1800                 var doc = getDocumentFromXML('<section></section>'),
1801                     extension = {document: {transformations: {
1802                         throwingTransformation: function() { throw new Error(); }
1803                     }}};
1804
1805                 doc.registerExtension(extension);
1806
1807                 doc.throwingTransformation();
1808
1809                 doc.transaction(function() {
1810                     doc.root.setAttr('x', '2');
1811                 });
1812
1813                 expect(doc.undoStack.length).to.equal(1);
1814                 expect(doc.root.getAttr('x')).to.equal('2');
1815
1816                 doc.undo();
1817
1818                 expect(doc.undoStack.length).to.equal(0);
1819                 expect(doc.root.getAttr('x')).to.be.undefined;
1820
1821             });
1822         });
1823     });
1824
1825 });
1826
1827 });