src/editor/modules/documentCanvas/canvas/canvas.test.js

   1 define([
   2 'libs/jquery',
   3 'libs/chai',
   4 'libs/sinon',
   5 'modules/documentCanvas/canvas/canvas',
   6 'modules/documentCanvas/canvas/utils',
   7 'modules/documentCanvas/canvas/documentElement',
   8 'wlxml/wlxml',
   9 ], function($, chai, sinon, canvas, utils, documentElement, wlxml) {
  10
  11 'use strict';
  12 /* global describe, it, beforeEach, afterEach */
  13
  14 var expect = chai.expect;
  15
  16 var getCanvasFromXML = function(xml, elements) {
  17     return canvas.fromXMLDocument(getDocumentFromXML(xml), elements);
  18 };
  19
  20 var getDocumentFromXML = function(xml) {
  21     return wlxml.WLXMLDocumentFromXML(xml);
  22 };
  23
  24 var wait = function(callback, timeout) {
  25     /* globals window */
  26     return window.setTimeout(callback, timeout || 0.5);
  27 };
  28
  29
  30 describe('wtf', function() {
  31     it('wtf!', function() {
  32         var c = getCanvasFromXML('<section>Alice</section>'),
  33             doc = c.wlxmlDocument;
  34
  35         var txtNode = doc.root.contents()[0];
  36         txtNode.wrapWith({tagName: 'header', start: 1, end: 2});
  37         expect(c.doc().children().length).to.equal(3);
  38     });
  39 });
  40
  41 describe('new Canvas', function() {
  42     it('abc', function() {
  43         var doc = wlxml.WLXMLDocumentFromXML('<section>Alice <span>has</span> a cat!</div>'),
  44             c = canvas.fromXMLDocument(doc);
  45
  46         expect(c.doc().children()).to.have.length(3);
  47         expect(c.doc().children()[0].canvas).to.equal(c);
  48         expect(c.doc().children()[0].wlxmlNode.sameNode(doc.root));
  49     });
  50 });
  51
  52 describe('Handling empty text nodes', function() {
  53     it('puts zero width space into node with about to be remove text', function(done) {
  54         var c = getCanvasFromXML('<section>Alice</section>'),
  55             textElement = c.doc().children()[0];
  56         textElement.setText('');
  57
  58         /* Wait for MutationObserver to kick in. */
  59         wait(function() {
  60             expect(textElement.getText({raw:true})).to.equal(utils.unicode.ZWS, 'ZWS in canvas');
  61             expect(c.wlxmlDocument.root.contents()[0].getText()).to.equal('', 'empty string in a document');
  62             done();
  63         });
  64     });
  65 });
  66
  67 describe('Handling changes to the document', function() {
  68     it('replaces the whole canvas content when document root node replaced', function() {
  69         var doc = getDocumentFromXML('<section></section>'),
  70             c = canvas.fromXMLDocument(doc);
  71
  72         var header = doc.root.replaceWith({tagName: 'header'});
  73         expect(c.doc().wlxmlNode.sameNode(header)).to.equal(true);
  74     });
  75 });
  76
  77 describe('Listening to document changes', function() {
  78
  79     it('Handling element node moved', function() {
  80         var doc = getDocumentFromXML('<section><a></a><b></b></section>'),
  81             a = doc.root.contents()[0],
  82             b = doc.root.contents()[1],
  83             c = canvas.fromXMLDocument(doc);
  84
  85         a.before(b);
  86         var sectionChildren = c.doc().children();
  87         expect(sectionChildren.length).to.equal(2);
  88         expect(sectionChildren[0].wlxmlNode.getTagName()).to.equal('b');
  89         expect(sectionChildren[1].wlxmlNode.getTagName()).to.equal('a');
  90     });
  91
  92     it('Handling text node moved', function() {
  93         var doc = getDocumentFromXML('<section><a></a>Alice</section>'),
  94             a = doc.root.contents()[0],
  95             textNode = doc.root.contents()[1],
  96             c = canvas.fromXMLDocument(doc);
  97
  98         a.before(textNode);
  99         var sectionChildren = c.doc().children();
 100         expect(sectionChildren.length).to.equal(2);
 101         expect(sectionChildren[0].getText()).to.equal('Alice');
 102         expect(sectionChildren[1].wlxmlNode.getTagName()).to.equal('a');
 103     });
 104
 105     it('Handles nodeTagChange event', function() {
 106
 107         var doc = wlxml.WLXMLDocumentFromXML('<section><div>Alice</div></section>'),
 108             c = canvas.fromXMLDocument(doc);
 109
 110         doc.root.contents()[0].setTag('header');
 111
 112         var headerNode = doc.root.contents()[0],
 113             headerElement = c.doc().children()[0];
 114
 115         expect(headerElement.wlxmlNode.getTagName()).to.equal('header', 'element ok');
 116
 117         /* Make sure we handle invalidation of reference to wlxmlNode after changing its tag */
 118         expect(headerNode.getData('canvasElement').sameNode(headerElement)).to.equal(true, 'node->element');
 119         expect(headerElement.wlxmlNode.sameNode(headerNode)).to.equal(true, 'element->node');
 120     });
 121
 122     it('Handles nodeDetached event for an empty text node', function(done) {
 123         var doc = wlxml.WLXMLDocumentFromXML('<section><div>A<span>b</span></div></section>'),
 124             aTextNode = doc.root.contents()[0].contents()[0],
 125             aTextElement;
 126
 127         canvas.fromXMLDocument(doc);
 128         aTextElement = utils.getElementForNode(aTextNode);
 129
 130         aTextElement.setText('');
 131
 132         wait(function() {
 133             var parent = aTextElement.parent();
 134             expect(aTextElement.getText({raw:true})).to.equal(utils.unicode.ZWS, 'canvas represents this as empty node');
 135             aTextElement.wlxmlNode.detach();
 136             expect(parent.children().length).to.equal(1);
 137             expect(parent.children()[0].wlxmlNode.getTagName()).to.equal('span');
 138             done();
 139         });
 140     });
 141 });
 142
 143 describe('Displaying span nodes', function() {
 144     it('inlines a span element with a text', function() {
 145         var c = getCanvasFromXML('<section><span>Alice</span></section>'),
 146             spanElement = c.doc().children()[0];
 147         expect(spanElement.isBlock()).to.equal(false);
 148     });
 149     it('renders non-span element as a block', function() {
 150         var c = getCanvasFromXML('<section><span></span></section>'),
 151             element = c.doc().children()[0],
 152             node = element.wlxmlNode;
 153
 154         expect(element.isBlock()).to.equal(false, 'initially inline');
 155         node = node.setTag('div');
 156         expect(node.getData('canvasElement').isBlock()).to.equal(true, 'block');
 157     });
 158
 159     it('inlines a span element if its block content gets removed', function() {
 160         var c = getCanvasFromXML('<section><span>Alice <div>has</div> a cat!</span></section>'),
 161             spanElement = c.doc().children()[0],
 162             divNode = spanElement.wlxmlNode.contents()[1];
 163
 164         expect(spanElement.isBlock()).to.equal(true, 'initially a block');
 165         divNode.detach();
 166         expect(spanElement.isBlock()).to.equal(false, 'inlined after removing inner block');
 167
 168         spanElement.wlxmlNode.append({tagName: 'div'});
 169
 170         expect(spanElement.isBlock()).to.equal(true, 'block again after bringing back inner block');
 171     });
 172
 173     it('keeps showing element as a block after changing its node tag to span if it contains elements of non-span nodes', function() {
 174         var c = getCanvasFromXML('<section><div><div></div></div></section>'),
 175             outerDivElement = c.doc().children()[0],
 176             outerDivNode = outerDivElement.wlxmlNode;
 177         outerDivNode = outerDivNode.setTag('span');
 178         expect(c.doc().children()[0].isBlock()).to.equal(true);
 179     });
 180 });
 181
 182
 183 describe('Default document changes handling', function() {
 184     it('handles added node', function() {
 185         var c = getCanvasFromXML('<section></section>');
 186         c.wlxmlDocument.root.append({tagName:'div'});
 187         expect(c.doc().children().length).to.equal(1);
 188         c.wlxmlDocument.root.prepend({tagName:'div'});
 189         expect(c.doc().children().length).to.equal(2);
 190
 191         var node = c.wlxmlDocument.root.contents()[1];
 192         node.before({tagName: 'div'});
 193         expect(c.doc().children().length).to.equal(3);
 194         node.after({tagName: 'div'});
 195         expect(c.doc().children().length).to.equal(4);
 196     });
 197
 198     it('handles attribute value change for a class attribute', function() {
 199         var c = getCanvasFromXML('<section></section>');
 200         c.wlxmlDocument.root.setAttr('class', 'test');
 201         expect(c.doc().wlxmlNode.getClass()).to.equal('test');
 202     });
 203
 204     it('handles detached node', function() {
 205         var c = getCanvasFromXML('<section><div></div></section>');
 206         c.wlxmlDocument.root.contents()[0].detach();
 207         expect(c.doc().children().length).to.equal(0);
 208     });
 209
 210     it('handles moved node', function() {
 211         var doc = getDocumentFromXML('<section><c></c><a></a><b></b></section>'),
 212             c = doc.root.contents()[0],
 213             a = doc.root.contents()[1],
 214             b = doc.root.contents()[2],
 215             cv = canvas.fromXMLDocument(doc);
 216
 217         a.document.transaction(function() {
 218             a.before(b); // => cab
 219             b.after(c); // => bca
 220         }, {
 221             error: function(e) {throw e;}
 222         });
 223
 224         var sectionChildren = cv.doc().children();
 225         expect(sectionChildren.length).to.equal(3);
 226         expect(sectionChildren[0].wlxmlNode.getTagName()).to.equal('b');
 227         expect(sectionChildren[1].wlxmlNode.getTagName()).to.equal('c');
 228         expect(sectionChildren[2].wlxmlNode.getTagName()).to.equal('a');
 229     });
 230
 231     it('handles moving text node to another parent', function() {
 232         var c = getCanvasFromXML('<section>Alice<div><span>has</span></div>a cat.</section>'),
 233             doc = c.wlxmlDocument,
 234             text = doc.root.contents()[0],
 235             div = doc.root.contents()[1];
 236
 237         div.append(text);
 238
 239         var sectionChildren = c.doc().children();
 240         expect(sectionChildren.length).to.equal(2);
 241         expect(sectionChildren[0].wlxmlNode.sameNode(div)).to.equal(true);
 242         expect(sectionChildren[1].getText()).to.equal('a cat.');
 243
 244         expect(div.contents().length).to.equal(2);
 245         expect(div.contents()[0].getTagName()).to.equal('span');
 246         expect(div.contents()[1].getText()).to.equal('Alice');
 247     });
 248
 249     it('handles change in a text node', function() {
 250         var c = getCanvasFromXML('<section>Alice</section>');
 251         c.wlxmlDocument.root.contents()[0].setText('cat');
 252         expect(c.doc().children()[0].getText()).to.equal('cat');
 253     });
 254
 255     describe('Regression tests', function() {
 256         it('handles moving node after its next neighbour correctly', function() {
 257             var c = getCanvasFromXML('<section><a></a><b></b></section>'),
 258                 doc = c.wlxmlDocument,
 259                 a = doc.root.contents()[0],
 260                 b = doc.root.contents()[1];
 261             b.after(a);
 262             var sectionChildren = c.doc().children();
 263             expect(sectionChildren[0].wlxmlNode.getTagName()).to.equal('b');
 264             expect(sectionChildren[1].wlxmlNode.getTagName()).to.equal('a');
 265         });
 266     });
 267 });
 268
 269 describe('Custom elements based on wlxml class attribute', function() {
 270     it('allows custom rendering', function() {
 271         var prototype = $.extend({}, documentElement.DocumentNodeElement.prototype, {
 272                 init: function() {
 273                     this._container().append('<test></test>');
 274                 }
 275             }),
 276             c = getCanvasFromXML('<section><div class="testClass"></div></section>', [
 277             {tag: 'div', klass: 'testClass', prototype: prototype}
 278         ]);
 279
 280         expect(c.doc().children()[0]._container().children('test').length).to.equal(1); // @!
 281     });
 282
 283     it('allows handling changes to internal structure of rendered node', function() {
 284         var prototype = $.extend({}, documentElement.DocumentNodeElement.prototype, {
 285                 init: function() {
 286                     this.header = $('<h1>');
 287                     this._container().append(this.header);
 288                     this.refresh2();
 289                 },
 290                 refresh2: function() {
 291                     this.header.text(this.wlxmlNode.contents().length);
 292                 },
 293                 onNodeAdded: function(event) {
 294                     void(event);
 295                     this.refresh2();
 296                 },
 297                 onNodeTextChange: function(event) {
 298                     this.header.text(event.meta.node.getText());
 299                 },
 300                 children: function() { return []; }
 301         });
 302
 303         var c = getCanvasFromXML('<section><div class="testClass"><a></a></div></section>', [
 304             {tag: 'div', klass: 'testClass', prototype: prototype}
 305         ]);
 306
 307         var node = c.wlxmlDocument.root.contents()[0],
 308             element = node.getData('canvasElement');
 309
 310         var header = element.dom.find('h1');
 311         expect(header.text()).to.equal('1', 'just <a>');
 312
 313         node.append({tagName: 'div'});
 314
 315         expect(header.text()).to.equal('2', 'added div');
 316
 317         var textNode = node.append({text: 'test'});
 318
 319         expect(header.text()).to.equal('3', 'added text node');
 320
 321         textNode.setText('test2');
 322
 323         expect(header.text()).to.equal('test2', 'text node change handled');
 324     });
 325
 326     describe('Handling unknown class', function() {
 327         it('Inherits default behavior', function() {
 328             var c = getCanvasFromXML('<section><div class="unknown">Hi!</div></section>');
 329             expect(c.doc().children()[0].children()[0].getText()).to.equal('Hi!');
 330         });
 331     });
 332 });
 333
 334 describe('Cursor', function() {
 335     /* globals Node */
 336     var getSelection;
 337
 338     var findTextNode = function(inside, text) {
 339         var nodes = inside.find(':not(iframe)').addBack().contents().filter(function() {
 340             return this.nodeType === Node.TEXT_NODE && this.data === text;
 341         });
 342         if(nodes.length) {
 343             return nodes[0];
 344         }
 345         return null;
 346     };
 347
 348     beforeEach(function() {
 349         /* globals window */
 350         getSelection = sinon.stub(window, 'getSelection');
 351     });
 352
 353     afterEach(function() {
 354         getSelection.restore();
 355     });
 356
 357     it('returns position when browser selection collapsed', function() {
 358         var c = getCanvasFromXML('<section>Alice has a cat</section>'),
 359             dom = c.doc().dom,
 360             text = findTextNode(dom, 'Alice has a cat');
 361
 362         expect(text.nodeType).to.equal(Node.TEXT_NODE, 'correct node selected');
 363         expect($(text).text()).to.equal('Alice has a cat');
 364
 365         getSelection.returns({
 366             anchorNode: text,
 367             focusNode: text,
 368             anchorOffset: 5,
 369             focusOffset: 5,
 370             isCollapsed: true
 371         });
 372         var cursor = c.getCursor(),
 373             position = cursor.getPosition();
 374
 375         expect(cursor.isSelecting()).to.equal(false, 'cursor is not selecting anything');
 376         expect(position.element.getText()).to.equal('Alice has a cat');
 377         expect(position.offset).to.equal(5);
 378         expect(position.offsetAtEnd).to.equal(false, 'offset is not at end');
 379
 380         getSelection.returns({
 381             anchorNode: text,
 382             focusNode: text,
 383             anchorOffset: 15,
 384             focusOffset: 15,
 385             isCollapsed: true
 386         });
 387
 388         expect(cursor.getPosition().offsetAtEnd).to.equal(true, 'offset at end');
 389     });
 390
 391     it('recognizes selection start and end on document order', function() {
 392         var c = getCanvasFromXML('<section><span>Alice</span><span>has a cat</span><div>abc<span>...</span>cde</div></section>'),
 393             dom = c.doc().dom,
 394             textFirst = findTextNode(dom, 'Alice'),
 395             textSecond = findTextNode(dom, 'has a cat'),
 396             textAbc = findTextNode(dom, 'abc'),
 397             textCde = findTextNode(dom, 'cde');
 398
 399         var check = function(label, expected) {
 400             var cursor = c.getCursor();
 401             label = label + ': ';
 402             expect(cursor.getSelectionStart().element.getText()).to.equal(expected.start.text, label + 'start element ok');
 403             expect(cursor.getSelectionStart().offset).to.equal(expected.start.offset, label + 'start offset ok');
 404             expect(cursor.getSelectionEnd().element.getText()).to.equal(expected.end.text, label + 'end element ok');
 405             expect(cursor.getSelectionEnd().offset).to.equal(expected.end.offset, label + 'end offset ok');
 406         };
 407
 408         getSelection.returns({
 409             anchorNode: textFirst,
 410             focusNode: textFirst,
 411             anchorOffset: 1,
 412             focusOffset: 3,
 413             isCollapsed: false
 414         });
 415
 416         check('same element, anchor first', {
 417             start: {text: 'Alice', offset: 1},
 418             end: {text: 'Alice', offset:3}
 419         });
 420
 421
 422         getSelection.returns({
 423             anchorNode: textFirst,
 424             focusNode: textFirst,
 425             anchorOffset: 3,
 426             focusOffset: 1,
 427             isCollapsed: false
 428         });
 429
 430         check('same element, anchor second', {
 431             start: {text: 'Alice', offset: 1},
 432             end: {text: 'Alice', offset:3}
 433         });
 434
 435
 436         getSelection.returns({
 437             anchorNode: textAbc,
 438             focusNode: textCde,
 439             anchorOffset: 3,
 440             focusOffset: 1,
 441             isCollapsed: false
 442         });
 443
 444         check('same parent, anchor first', {
 445             start: {text: 'abc', offset: 3},
 446             end: {text: 'cde', offset:1}
 447         });
 448
 449
 450         getSelection.returns({
 451             anchorNode: textCde,
 452             focusNode: textAbc,
 453             anchorOffset: 1,
 454             focusOffset: 3,
 455             isCollapsed: false
 456         });
 457
 458         check('same parent, anchor second', {
 459             start: {text: 'abc', offset: 3},
 460             end: {text: 'cde', offset:1}
 461         });
 462
 463
 464         getSelection.returns({
 465             anchorNode: textFirst,
 466             focusNode: textSecond,
 467             anchorOffset: 1,
 468             focusOffset: 3,
 469             isCollapsed: false
 470         });
 471
 472         check('different parents, anchor first', {
 473             start: {text: 'Alice', offset: 1},
 474             end: {text: 'has a cat', offset:3}
 475         });
 476
 477
 478         getSelection.returns({
 479             anchorNode: textSecond,
 480             focusNode: textFirst,
 481             anchorOffset: 3,
 482             focusOffset: 1,
 483             isCollapsed: false
 484         });
 485
 486         check('different parents, anchor second', {
 487             start: {text: 'Alice', offset: 1},
 488             end: {text: 'has a cat', offset:3}
 489         });
 490     });
 491
 492     it('returns boundries of selection when browser selection not collapsed', function() {
 493         var c = getCanvasFromXML('<section>Alice <span>has</span> a <span>big</span> cat</section>'),
 494             dom = c.doc().dom,
 495             text = {
 496                 alice: findTextNode(dom, 'Alice '),
 497                 has: findTextNode(dom, 'has'),
 498                 cat: findTextNode(dom, ' cat')
 499             },
 500             cursor = c.getCursor(),
 501             aliceElement = c.getDocumentElement(text.alice),
 502             catElement = c.getDocumentElement(text.cat);
 503
 504         [
 505             {focus: text.alice, focusOffset: 1, anchor: text.cat,   anchorOffset: 2, selectionAnchor: catElement},
 506             {focus: text.cat,   focusOffset: 2, anchor: text.alice, anchorOffset: 1, selectionAnchor: aliceElement}
 507         ].forEach(function(s, idx) {
 508             getSelection.returns({isColapsed: false, anchorNode: s.anchor, anchorOffset: s.anchorOffset, focusNode: s.focus, focusOffset: s.focusOffset});
 509
 510             var selectionStart = cursor.getSelectionStart(),
 511                 selectionEnd = cursor.getSelectionEnd(),
 512                 selectionAnchor = cursor.getSelectionAnchor();
 513
 514             expect(cursor.isSelecting()).to.equal(true, 'cursor is selecting');
 515             expect(selectionStart.element.sameNode(aliceElement)).to.equal(true, '"Alice" is the start of the selection ' + idx);
 516             expect(selectionStart.offset).to.equal(1, '"Alice" offset ok' + idx);
 517             expect(selectionEnd.element.sameNode(catElement)).to.equal(true, '"Cat" is the start of the selection ' + idx);
 518             expect(selectionEnd.offset).to.equal(2, '"Cat" offset ok' + idx);
 519             expect(selectionAnchor.element.sameNode(s.selectionAnchor)).to.equal(true, 'anchor ok');
 520             expect(selectionAnchor.offset).to.equal(s.anchorOffset, 'anchor offset ok');
 521         });
 522     });
 523
 524     it('recognizes when browser selection boundries lies in sibling DocumentTextElements', function() {
 525         var c = getCanvasFromXML('<section>Alice <span>has</span> a <span>big</span> cat</section>'),
 526             dom = c.doc().dom,
 527             text = {
 528                 alice: findTextNode(dom, 'Alice '),
 529                 has: findTextNode(dom, 'has'),
 530                 a: findTextNode(dom, ' a '),
 531                 big: findTextNode(dom, 'big'),
 532                 cat: findTextNode(dom, ' cat'),
 533             },
 534             cursor = c.getCursor();
 535
 536         expect($(text.alice).text()).to.equal('Alice ');
 537         expect($(text.has).text()).to.equal('has');
 538         expect($(text.a).text()).to.equal(' a ');
 539         expect($(text.big).text()).to.equal('big');
 540         expect($(text.cat).text()).to.equal(' cat');
 541
 542         getSelection.returns({anchorNode: text.alice, focusNode: text.a});
 543         expect(cursor.isSelectingSiblings()).to.equal(true, '"Alice" and "a" are children');
 544
 545         getSelection.returns({anchorNode: text.alice, focusNode: text.cat});
 546         expect(cursor.isSelectingSiblings()).to.equal(true, '"Alice" and "cat" are children');
 547
 548         getSelection.returns({anchorNode: text.alice, focusNode: text.has});
 549         expect(cursor.isSelectingSiblings()).to.equal(false, '"Alice" and "has" are not children');
 550
 551         getSelection.returns({anchorNode: text.has, focusNode: text.big});
 552         expect(cursor.isSelectingSiblings()).to.equal(false, '"has" and "big" are not children');
 553     });
 554 });
 555
 556 });