ecomp-portal-FE/client/bower_components/jqTree/src_test/test_tree.js

   1 var utils_for_test = require('./utils_for_test');
   2
   3 var example_data = utils_for_test.example_data;
   4 var formatNodes = utils_for_test.formatNodes;
   5
   6 var tree_vars = utils_for_test.getTreeVariables();
   7
   8 var Node = tree_vars.Node;
   9 var Position = tree_vars.Position;
  10
  11 var test = QUnit.test;
  12
  13
  14 QUnit.module("Tree");
  15 test('constructor', function(assert) {
  16     // 1. Create node from string
  17     var node = new Node('n1');
  18
  19     assert.equal(node.name, 'n1');
  20     assert.equal(node.children.length, 0);
  21     assert.equal(node.parent, null);
  22
  23     // 2. Create node from object
  24     node = new Node({
  25         label: 'n2',
  26         id: 123,
  27         parent: 'abc',  // parent must be ignored
  28         children: ['c'], // children must be ignored
  29         url: '/'
  30     });
  31
  32     assert.equal(node.name, 'n2');
  33     assert.equal(node.id, 123);
  34     assert.equal(node.url, '/');
  35     assert.equal(node.label, undefined);
  36     assert.equal(node.children.length, 0);
  37     assert.equal(node.parent, null);
  38 });
  39
  40 test("create tree from data", function(assert) {
  41     function checkData(tree) {
  42         assert.equal(
  43             formatNodes(tree.children),
  44             'node1 node2',
  45             'nodes on level 1'
  46         );
  47         assert.equal(
  48             formatNodes(tree.children[0].children),
  49             'child1 child2',
  50             'children of node1'
  51         );
  52         assert.equal(
  53             formatNodes(tree.children[1].children),
  54             'child3',
  55             'children of node2'
  56         );
  57         assert.equal(
  58             tree.children[0].id,
  59             123,
  60             'id'
  61         );
  62     }
  63
  64     // - create tree from example data
  65     var tree = new Node(null, true);
  66     tree.loadFromData(example_data);
  67     checkData(tree);
  68
  69     // - create tree from new data format
  70     var data = [
  71         {
  72             label: 'node1',
  73             id: 123,
  74             children: ['child1', 'child2']  // nodes are only defined by a string
  75         },
  76         {
  77             label: 'node2',
  78             id: 124,
  79             children: ['child3']
  80         }
  81     ];
  82     var tree = new Node(null, true);
  83     tree.loadFromData(data);
  84     checkData(tree);
  85 });
  86
  87 test("addChild", function(assert) {
  88     var tree = new Node('tree1', true);
  89     tree.addChild(
  90         new Node('abc')
  91     );
  92     tree.addChild(
  93         new Node('def')
  94     );
  95
  96     assert.equal(
  97         formatNodes(tree.children),
  98         'abc def',
  99         'children'
 100     );
 101
 102     var node = tree.children[0];
 103     assert.equal(
 104         node.parent.name,
 105         'tree1',
 106         'parent of node'
 107     );
 108 });
 109
 110 test('addChildAtPosition', function(assert) {
 111     var tree = new Node(null, true);
 112     tree.addChildAtPosition(new Node('abc'), 0);  // first
 113     tree.addChildAtPosition(new Node('ghi'), 2);  // index 2 does not exist
 114     tree.addChildAtPosition(new Node('def'), 1);
 115     tree.addChildAtPosition(new Node('123'), 0);
 116
 117     assert.equal(
 118         formatNodes(tree.children),
 119         '123 abc def ghi',
 120         'children'
 121     );
 122 });
 123
 124 test('removeChild', function(assert) {
 125     var tree = new Node(null, true);
 126
 127     var abc = new Node({'label': 'abc', 'id': 1});
 128     var def = new Node({'label': 'def', 'id': 2});
 129     var ghi = new Node({'label': 'ghi', 'id': 3});
 130
 131     tree.addChild(abc);
 132     tree.addChild(def);
 133     tree.addChild(ghi);
 134
 135     var jkl = new Node({'label': 'jkl', 'id': 4});
 136     def.addChild(jkl);
 137
 138     assert.equal(
 139         formatNodes(tree.children),
 140         'abc def ghi',
 141         'children'
 142     );
 143
 144     assert.equal(tree.id_mapping[2].name, 'def');
 145     assert.equal(tree.id_mapping[4].name, 'jkl');
 146
 147     // remove 'def'
 148     tree.removeChild(def);
 149     assert.equal(
 150         formatNodes(tree.children),
 151         'abc ghi',
 152         'children'
 153     );
 154
 155     assert.equal(tree.id_mapping[2], null);
 156     assert.equal(tree.id_mapping[4], null);
 157
 158     // remove 'ghi'
 159     tree.removeChild(ghi);
 160     assert.equal(
 161         formatNodes(tree.children),
 162         'abc',
 163         'children'
 164     );
 165
 166     // remove 'abc'
 167     tree.removeChild(abc);
 168     assert.equal(
 169         formatNodes(tree.children),
 170         '',
 171         'children'
 172     );
 173 });
 174
 175 test('getChildIndex', function(assert) {
 176     // setup
 177     var tree = new Node(null, true);
 178
 179     var abc = new Node('abc');
 180     var def = new Node('def');
 181     var ghi = new Node('ghi');
 182     tree.addChild(abc);
 183     tree.addChild(def);
 184     tree.addChild(ghi);
 185
 186     // 1. Get child index of 'def'
 187     assert.equal(tree.getChildIndex(def), 1);
 188
 189     // 2. Get child index of non-existing node
 190     assert.equal(tree.getChildIndex(new Node('xyz')), -1);
 191 });
 192
 193 test('hasChildren', function(assert) {
 194     var tree = new Node(null, true);
 195     assert.equal(
 196         tree.hasChildren(),
 197         false,
 198         'tree without children'
 199     );
 200
 201     tree.addChild(new Node('abc'));
 202     assert.equal(
 203         tree.hasChildren(),
 204         true,
 205         'tree has children'
 206     );
 207 });
 208
 209 test('iterate', function(assert) {
 210     var tree = new Node(null, true);
 211     tree.loadFromData(example_data);
 212
 213     // iterate over all the nodes
 214     var nodes = [];
 215     tree.iterate(
 216         function(node, level) {
 217             nodes.push(node);
 218             return true;
 219         }
 220     );
 221
 222     assert.equal(
 223         formatNodes(nodes),
 224         'node1 child1 child2 node2 child3',
 225         'all nodes'
 226     );
 227
 228     // iterate over nodes on first level
 229     nodes = [];
 230     tree.iterate(
 231         function(node, level) {
 232             nodes.push(node);
 233             return false;
 234         }
 235     );
 236
 237     assert.equal(
 238         formatNodes(nodes),
 239         'node1 node2',
 240         'nodes on first level'
 241     );
 242
 243     // add child 4
 244     var node3 = tree.getNodeById(124).children[0];
 245     node3.addChild(
 246         new Node('child4')
 247     );
 248
 249     // test level parameter
 250     nodes = [];
 251     tree.iterate(
 252         function(node, level) {
 253             nodes.push(node.name + ' ' + level);
 254             return true;
 255         }
 256     );
 257
 258     assert.equal(
 259         nodes.join(','),
 260         'node1 0,child1 1,child2 1,node2 0,child3 1,child4 2'
 261     );
 262 });
 263
 264 test('moveNode', function(assert) {
 265     var tree = new Node(null, true);
 266     tree.loadFromData(example_data);
 267
 268     /*
 269       node1
 270       ---child1
 271       ---child2
 272       node2
 273       ---child3
 274     */
 275
 276     var node1 = tree.children[0];
 277     var node2 = tree.children[1];
 278     var child1 = node1.children[0];
 279     var child2 = node1.children[1];
 280     assert.equal(node2.name, 'node2', 'node2 name');
 281     assert.equal(child2.name, 'child2', 'child2 name');
 282
 283     // move child2 after node2
 284     tree.moveNode(child2, node2, Position.AFTER);
 285
 286     /*
 287       node1
 288       ---child1
 289       node2
 290       ---child3
 291       child2
 292     */
 293     assert.equal(
 294         formatNodes(tree.children),
 295         'node1 node2 child2',
 296         'tree nodes at first level'
 297     );
 298     assert.equal(
 299         formatNodes(node1.children),
 300         'child1',
 301         'node1 children'
 302     );
 303
 304     // move child1 inside node2
 305     // this means it's the first child
 306     tree.moveNode(child1, node2, Position.INSIDE);
 307
 308     /*
 309       node1
 310       node2
 311       ---child1
 312       ---child3
 313       child2
 314     */
 315     assert.equal(
 316         formatNodes(node2.children),
 317         'child1 child3',
 318         'node2 children'
 319     );
 320     assert.equal(
 321         formatNodes(node1.children),
 322         '',
 323         'node1 has no children'
 324     );
 325
 326     // move child2 before child1
 327     tree.moveNode(child2, child1, Position.BEFORE);
 328
 329     /*
 330       node1
 331       node2
 332       ---child2
 333       ---child1
 334       ---child3
 335     */
 336     assert.equal(
 337         formatNodes(node2.children),
 338         'child2 child1 child3',
 339         'node2 children'
 340     );
 341     assert.equal(
 342         formatNodes(tree.children),
 343         'node1 node2',
 344         'tree nodes at first level'
 345     );
 346 });
 347
 348 test('initFromData', function(assert) {
 349     var data =
 350         {
 351             label: 'main',
 352             children: [
 353                 'c1',
 354                 {
 355                     label: 'c2',
 356                     id: 201
 357                 }
 358             ]
 359         };
 360     var node = new Node(null, true);
 361     node.initFromData(data);
 362
 363     assert.equal(node.name, 'main')
 364     assert.equal(
 365         formatNodes(node.children),
 366         'c1 c2',
 367         'children'
 368     );
 369     assert.equal(node.children[1].id, 201);
 370 });
 371
 372 test('getData', function(assert) {
 373     // 1. empty node
 374     var node = new Node(null, true);
 375     assert.deepEqual(node.getData(), []);
 376
 377     // 2.node with data
 378     node.loadFromData(
 379         [
 380             {
 381                 label: 'n1',
 382                 children: [
 383                     {
 384                         label: 'c1'
 385                     }
 386                 ]
 387             }
 388         ]
 389     );
 390     assert.deepEqual(
 391         node.getData(),
 392         [
 393             {
 394                 name: 'n1',
 395                 children: [
 396                     {
 397                         name: 'c1'
 398                     }
 399                 ]
 400             }
 401         ]
 402     );
 403
 404     // 3. get data including parent
 405     var n1 = node.getNodeByName('n1');
 406
 407     assert.deepEqual(
 408         n1.getData(true),
 409         [
 410             {
 411                 name: 'n1',
 412                 children: [
 413                     { name: 'c1'}
 414                 ]
 415             }
 416         ]
 417     );
 418 });
 419
 420 test('addAfter', function(assert) {
 421     // setup
 422     var tree = new Node(null, true);
 423     tree.loadFromData(example_data);
 424
 425     /*
 426     -node1
 427     ---c1
 428     ---c2
 429     -node2
 430     ---c3
 431     */
 432
 433     assert.equal(formatNodes(tree.children), 'node1 node2');
 434
 435     // - Add 'node_b' after node2
 436     var node2 = tree.getNodeByName('node2');
 437     node2.addAfter('node_b');
 438
 439     assert.equal(formatNodes(tree.children), 'node1 node2 node_b');
 440
 441     var node_b = tree.getNodeByName('node_b');
 442     assert.equal(node_b.name, 'node_b');
 443
 444     // - Add 'node_a' after node1
 445     var node1 = tree.getNodeByName('node1');
 446     node1.addAfter('node_a');
 447
 448     assert.equal(formatNodes(tree.children), 'node1 node_a node2 node_b');
 449
 450     // - Add 'node_c' after node_b; new node is an object
 451     node_b.addAfter({
 452         label: 'node_c',
 453         id: 789
 454     });
 455
 456     var node_c = tree.getNodeByName('node_c');
 457     assert.equal(node_c.id, 789);
 458
 459     assert.equal(formatNodes(tree.children), 'node1 node_a node2 node_b node_c');
 460
 461     // - Add after root node; this is not possible
 462     assert.equal(tree.addAfter('node_x'), null);
 463 });
 464
 465 test('addBefore', function(assert) {
 466     // setup
 467     var tree = new Node(null, true);
 468     tree.loadFromData(example_data);
 469
 470     // - Add 'node_0' before node1
 471     var node1 = tree.getNodeByName('node1');
 472     node1.addBefore('node0');
 473     assert.equal(formatNodes(tree.children), 'node0 node1 node2');
 474
 475     // - Add before root node; this is not possile
 476     assert.equal(tree.addBefore('x'), null);
 477 });
 478
 479 test('addParent', function(assert) {
 480     // setup
 481     var tree = new Node(null, true);
 482     tree.loadFromData(example_data);
 483
 484     // - Add node 'root' as parent of node1
 485     // Note that node also becomes a child of 'root'
 486     var node1 = tree.getNodeByName('node1');
 487     node1.addParent('root');
 488
 489     var root = tree.getNodeByName('root');
 490     assert.equal(formatNodes(root.children), 'node1 node2');
 491
 492     // - Add parent to root node; not possible
 493     assert.equal(tree.addParent('x'), null);
 494 });
 495
 496 test('remove', function(assert) {
 497     // setup
 498     var tree = new Node(null, true);
 499     tree.loadFromData(example_data);
 500
 501     var child1 = tree.getNodeByName('child1');
 502     var node1 = tree.getNodeByName('node1');
 503
 504     assert.equal(formatNodes(node1.children), 'child1 child2');
 505     assert.equal(child1.parent, node1);
 506
 507     // 1. Remove child1
 508     child1.remove();
 509
 510     assert.equal(formatNodes(node1.children), 'child2');
 511     assert.equal(child1.parent, null);
 512 });
 513
 514 test('append', function(assert) {
 515     // setup
 516     var tree = new Node(null, true);
 517     tree.loadFromData(example_data);
 518
 519     var node1 = tree.getNodeByName('node1');
 520
 521     // 1. Append child3 to node1
 522     node1.append('child3');
 523
 524     assert.equal(formatNodes(node1.children), 'child1 child2 child3');
 525
 526     // 2. Append subtree
 527     node1.append(
 528         {
 529             name: 'child4',
 530             children: [
 531                 { name: 'child5' }
 532             ]
 533         }
 534     );
 535
 536     assert.equal(formatNodes(node1.children), 'child1 child2 child3 child4');
 537
 538     var child4 = node1.getNodeByName('child4');
 539     assert.equal(formatNodes(child4.children), 'child5');
 540 });
 541
 542 test('prepend', function(assert) {
 543     // setup
 544     var tree = new Node(null, true);
 545     tree.loadFromData(example_data);
 546
 547     var node1 = tree.getNodeByName('node1');
 548
 549     // 1. Prepend child0 to node1
 550     node1.prepend('child0');
 551
 552     assert.equal(formatNodes(node1.children), 'child0 child1 child2');
 553
 554     // 2. Prepend subtree
 555     node1.prepend({
 556         name: 'child3',
 557         children: [
 558             { name: 'child4' }
 559         ]
 560     });
 561
 562     assert.equal(formatNodes(node1.children), 'child3 child0 child1 child2');
 563
 564     var child3 = node1.getNodeByName('child3');
 565     assert.equal(formatNodes(child3.children), 'child4');
 566 });
 567
 568 test('getNodeById', function(assert) {
 569     // setup
 570     var tree = new Node(null, true);
 571     tree.loadFromData(example_data);
 572
 573     // 1. Get node with id 124
 574     var node = tree.getNodeById(124);
 575     assert.equal(node.name, 'node2');
 576
 577     // 2. Delete node with id 124 and search again
 578     node.remove();
 579
 580     assert.equal(tree.getNodeById(124), null);
 581
 582     // 3. Add node with id 456 and search for it
 583     var child3 = tree.getNodeByName('child2');
 584     child3.append({
 585         id: 456,
 586         label: 'new node'
 587     });
 588
 589     node = tree.getNodeById(456);
 590     assert.equal(node.name, 'new node');
 591 });
 592
 593 test('getLevel', function(assert) {
 594     // setup
 595     var tree = new Node(null, true);
 596     tree.loadFromData(example_data);
 597
 598     // 1. get level for node1 and child1
 599     assert.equal(tree.getNodeByName('node1').getLevel(), 1);
 600     assert.equal(tree.getNodeByName('child1').getLevel(), 2);
 601 });
 602
 603 test('loadFromData and id mapping', function(assert) {
 604     // - get node from empty tree
 605     var tree = new Node(null, true);
 606     assert.equal(tree.getNodeById(999), null);
 607
 608     // - load example data in tree
 609     tree.loadFromData(example_data);
 610     assert.equal(tree.getNodeById(124).name, 'node2');
 611
 612     var child2 = tree.getNodeById(126);
 613     child2.addChild(
 614         new Node({label: 'child4', id: 128})
 615     );
 616     child2.addChild(
 617         new Node({label: 'child5', id: 129})
 618     );
 619
 620     // - load data in node child2
 621     child2.loadFromData(['abc', 'def']);
 622
 623     assert.equal(tree.getNodeById(128), null);
 624     assert.equal(child2.children.length, 2);
 625     assert.equal(child2.children[0].name, 'abc');
 626 });
 627
 628 test('removeChildren', function(assert) {
 629     // - load example data
 630     var tree = new Node(null, true);
 631     tree.loadFromData(example_data);
 632
 633     // add child4 and child5
 634     var child2 = tree.getNodeById(126);
 635     assert.equal(child2.name, 'child2');
 636
 637     child2.addChild(
 638         new Node({label: 'child4', id: 128})
 639     );
 640     child2.addChild(
 641         new Node({label: 'child5', id: 129})
 642     );
 643     assert.equal(tree.getNodeById(128).name, 'child4');
 644
 645     // - remove children from child2
 646     child2.removeChildren();
 647     assert.equal(tree.getNodeById(128), null);
 648     assert.equal(child2.children.length, 0);
 649 });
 650
 651 test('node with id 0', function(assert) {
 652     // - load node with id 0
 653     var tree = new Node(null, true);
 654     tree.loadFromData([
 655         {
 656             id: 0,
 657             label: 'mynode'
 658         }
 659     ]);
 660
 661     // - get node by id
 662     var node = tree.getNodeById(0);
 663     assert.equal(node.name, 'mynode');
 664
 665     // -- remove the node
 666     node.remove();
 667
 668     assert.equal(tree.getNodeById(0), undefined);
 669 });
 670
 671 test('getPreviousSibling', function(assert) {
 672     // setup
 673     var tree = new Node(null, true);
 674     tree.loadFromData(example_data);
 675
 676     // - getPreviousSibling
 677     assert.equal(
 678         tree.getNodeByName('child2').getPreviousSibling().name,
 679         'child1'
 680     );
 681     assert.equal(tree.getPreviousSibling(), null);
 682     assert.equal(
 683         tree.getNodeByName('child1').getPreviousSibling(),
 684         null
 685     );
 686 });
 687
 688 test('getNextSibling', function(assert) {
 689     // setup
 690     var tree = new Node(null, true);
 691     tree.loadFromData(example_data);
 692
 693     // - getNextSibling
 694     assert.equal(
 695         tree.getNodeByName('node1').getNextSibling().name,
 696         'node2'
 697     );
 698     assert.equal(
 699         tree.getNodeByName('node2').getNextSibling(),
 700         null
 701     );
 702     assert.equal(tree.getNextSibling(), null);
 703 });
 704
 705 test('getNodesByProperty', function(assert) {
 706     var tree = new Node(null, true);
 707     tree.loadFromData(example_data);
 708
 709     nodes = tree.getNodesByProperty('name', 'child1');
 710
 711     assert.equal(nodes.length, 1);
 712     assert.equal(nodes[0].name, 'child1');
 713 });
 714
 715 test('getNodeByCallback', function(assert) {
 716     var tree = new Node(null, true);
 717     tree.loadFromData(example_data);
 718
 719     node = tree.getNodeByCallback(
 720         function(node) {
 721             return node.name == 'child1';
 722         }
 723     );
 724
 725     assert.equal(node.name, 'child1');
 726 });