1 files changed, 726 insertions, 0 deletions
diff --git a/ecomp-portal-FE/client/bower_components/jqTree/src_test/test_tree.js b/ecomp-portal-FE/client/bower_components/jqTree/src_test/test_tree.js
new file mode 100644
index 00000000..ffa4910c
--- /dev/null
+++ b/ecomp-portal-FE/client/bower_components/jqTree/src_test/test_tree.js
@@ -0,0 +1,726 @@
+var utils_for_test = require('./utils_for_test');
+
+var example_data = utils_for_test.example_data;
+var formatNodes = utils_for_test.formatNodes;
+
+var tree_vars = utils_for_test.getTreeVariables();
+
+var Node = tree_vars.Node;
+var Position = tree_vars.Position;
+
+var test = QUnit.test;
+
+
+QUnit.module("Tree");
+test('constructor', function(assert) {
+    // 1. Create node from string
+    var node = new Node('n1');
+
+    assert.equal(node.name, 'n1');
+    assert.equal(node.children.length, 0);
+    assert.equal(node.parent, null);
+
+    // 2. Create node from object
+    node = new Node({
+        label: 'n2',
+        id: 123,
+        parent: 'abc',  // parent must be ignored
+        children: ['c'], // children must be ignored
+        url: '/'
+    });
+
+    assert.equal(node.name, 'n2');
+    assert.equal(node.id, 123);
+    assert.equal(node.url, '/');
+    assert.equal(node.label, undefined);
+    assert.equal(node.children.length, 0);
+    assert.equal(node.parent, null);
+});
+
+test("create tree from data", function(assert) {
+    function checkData(tree) {
+        assert.equal(
+            formatNodes(tree.children),
+            'node1 node2',
+            'nodes on level 1'
+        );
+        assert.equal(
+            formatNodes(tree.children[0].children),
+            'child1 child2',
+            'children of node1'
+        );
+        assert.equal(
+            formatNodes(tree.children[1].children),
+            'child3',
+            'children of node2'
+        );
+        assert.equal(
+            tree.children[0].id,
+            123,
+            'id'
+        );
+    }
+
+    // - create tree from example data
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+    checkData(tree);
+
+    // - create tree from new data format
+    var data = [
+        {
+            label: 'node1',
+            id: 123,
+            children: ['child1', 'child2']  // nodes are only defined by a string
+        },
+        {
+            label: 'node2',
+            id: 124,
+            children: ['child3']
+        }
+    ];
+    var tree = new Node(null, true);
+    tree.loadFromData(data);
+    checkData(tree);
+});
+
+test("addChild", function(assert) {
+    var tree = new Node('tree1', true);
+    tree.addChild(
+        new Node('abc')
+    );
+    tree.addChild(
+        new Node('def')
+    );
+
+    assert.equal(
+        formatNodes(tree.children),
+        'abc def',
+        'children'
+    );
+
+    var node = tree.children[0];
+    assert.equal(
+        node.parent.name,
+        'tree1',
+        'parent of node'
+    );
+});
+
+test('addChildAtPosition', function(assert) {
+    var tree = new Node(null, true);
+    tree.addChildAtPosition(new Node('abc'), 0);  // first
+    tree.addChildAtPosition(new Node('ghi'), 2);  // index 2 does not exist
+    tree.addChildAtPosition(new Node('def'), 1);
+    tree.addChildAtPosition(new Node('123'), 0);
+
+    assert.equal(
+        formatNodes(tree.children),
+        '123 abc def ghi',
+        'children'
+    );
+});
+
+test('removeChild', function(assert) {
+    var tree = new Node(null, true);
+
+    var abc = new Node({'label': 'abc', 'id': 1});
+    var def = new Node({'label': 'def', 'id': 2});
+    var ghi = new Node({'label': 'ghi', 'id': 3});
+
+    tree.addChild(abc);
+    tree.addChild(def);
+    tree.addChild(ghi);
+
+    var jkl = new Node({'label': 'jkl', 'id': 4});
+    def.addChild(jkl);
+
+    assert.equal(
+        formatNodes(tree.children),
+        'abc def ghi',
+        'children'
+    );
+
+    assert.equal(tree.id_mapping[2].name, 'def');
+    assert.equal(tree.id_mapping[4].name, 'jkl');
+
+    // remove 'def'
+    tree.removeChild(def);
+    assert.equal(
+        formatNodes(tree.children),
+        'abc ghi',
+        'children'
+    );
+
+    assert.equal(tree.id_mapping[2], null);
+    assert.equal(tree.id_mapping[4], null);
+
+    // remove 'ghi'
+    tree.removeChild(ghi);
+    assert.equal(
+        formatNodes(tree.children),
+        'abc',
+        'children'
+    );
+
+    // remove 'abc'
+    tree.removeChild(abc);
+    assert.equal(
+        formatNodes(tree.children),
+        '',
+        'children'
+    );
+});
+
+test('getChildIndex', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+
+    var abc = new Node('abc');
+    var def = new Node('def');
+    var ghi = new Node('ghi');
+    tree.addChild(abc);
+    tree.addChild(def);
+    tree.addChild(ghi);
+
+    // 1. Get child index of 'def'
+    assert.equal(tree.getChildIndex(def), 1);
+
+    // 2. Get child index of non-existing node
+    assert.equal(tree.getChildIndex(new Node('xyz')), -1);
+});
+
+test('hasChildren', function(assert) {
+    var tree = new Node(null, true);
+    assert.equal(
+        tree.hasChildren(),
+        false,
+        'tree without children'
+    );
+
+    tree.addChild(new Node('abc'));
+    assert.equal(
+        tree.hasChildren(),
+        true,
+        'tree has children'
+    );
+});
+
+test('iterate', function(assert) {
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // iterate over all the nodes
+    var nodes = [];
+    tree.iterate(
+        function(node, level) {
+            nodes.push(node);
+            return true;
+        }
+    );
+
+    assert.equal(
+        formatNodes(nodes),
+        'node1 child1 child2 node2 child3',
+        'all nodes'
+    );
+
+    // iterate over nodes on first level
+    nodes = [];
+    tree.iterate(
+        function(node, level) {
+            nodes.push(node);
+            return false;
+        }
+    );
+
+    assert.equal(
+        formatNodes(nodes),
+        'node1 node2',
+        'nodes on first level'
+    );
+
+    // add child 4
+    var node3 = tree.getNodeById(124).children[0];
+    node3.addChild(
+        new Node('child4')
+    );
+
+    // test level parameter
+    nodes = [];
+    tree.iterate(
+        function(node, level) {
+            nodes.push(node.name + ' ' + level);
+            return true;
+        }
+    );
+
+    assert.equal(
+        nodes.join(','),
+        'node1 0,child1 1,child2 1,node2 0,child3 1,child4 2'
+    );
+});
+
+test('moveNode', function(assert) {
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    /*
+      node1
+      ---child1
+      ---child2
+      node2
+      ---child3
+    */
+
+    var node1 = tree.children[0];
+    var node2 = tree.children[1];
+    var child1 = node1.children[0];
+    var child2 = node1.children[1];
+    assert.equal(node2.name, 'node2', 'node2 name');
+    assert.equal(child2.name, 'child2', 'child2 name');
+
+    // move child2 after node2
+    tree.moveNode(child2, node2, Position.AFTER);
+
+    /*
+      node1
+      ---child1
+      node2
+      ---child3
+      child2
+    */
+    assert.equal(
+        formatNodes(tree.children),
+        'node1 node2 child2',
+        'tree nodes at first level'
+    );
+    assert.equal(
+        formatNodes(node1.children),
+        'child1',
+        'node1 children'
+    );
+
+    // move child1 inside node2
+    // this means it's the first child
+    tree.moveNode(child1, node2, Position.INSIDE);
+
+    /*
+      node1
+      node2
+      ---child1
+      ---child3
+      child2
+    */
+    assert.equal(
+        formatNodes(node2.children),
+        'child1 child3',
+        'node2 children'
+    );
+    assert.equal(
+        formatNodes(node1.children),
+        '',
+        'node1 has no children'
+    );
+
+    // move child2 before child1
+    tree.moveNode(child2, child1, Position.BEFORE);
+
+    /*
+      node1
+      node2
+      ---child2
+      ---child1
+      ---child3
+    */
+    assert.equal(
+        formatNodes(node2.children),
+        'child2 child1 child3',
+        'node2 children'
+    );
+    assert.equal(
+        formatNodes(tree.children),
+        'node1 node2',
+        'tree nodes at first level'
+    );
+});
+
+test('initFromData', function(assert) {
+    var data =
+        {
+            label: 'main',
+            children: [
+                'c1',
+                {
+                    label: 'c2',
+                    id: 201
+                }
+            ]
+        };
+    var node = new Node(null, true);
+    node.initFromData(data);
+
+    assert.equal(node.name, 'main')
+    assert.equal(
+        formatNodes(node.children),
+        'c1 c2',
+        'children'
+    );
+    assert.equal(node.children[1].id, 201);
+});
+
+test('getData', function(assert) {
+    // 1. empty node
+    var node = new Node(null, true);
+    assert.deepEqual(node.getData(), []);
+
+    // 2.node with data
+    node.loadFromData(
+        [
+            {
+                label: 'n1',
+                children: [
+                    {
+                        label: 'c1'
+                    }
+                ]
+            }
+        ]
+    );
+    assert.deepEqual(
+        node.getData(),
+        [
+            {
+                name: 'n1',
+                children: [
+                    {
+                        name: 'c1'
+                    }
+                ]
+            }
+        ]
+    );
+
+    // 3. get data including parent
+    var n1 = node.getNodeByName('n1');
+
+    assert.deepEqual(
+        n1.getData(true),
+        [
+            {
+                name: 'n1',
+                children: [
+                    { name: 'c1'}
+                ]
+            }
+        ]
+    );
+});
+
+test('addAfter', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    /*
+    -node1
+    ---c1
+    ---c2
+    -node2
+    ---c3
+    */
+
+    assert.equal(formatNodes(tree.children), 'node1 node2');
+
+    // - Add 'node_b' after node2
+    var node2 = tree.getNodeByName('node2');
+    node2.addAfter('node_b');
+
+    assert.equal(formatNodes(tree.children), 'node1 node2 node_b');
+
+    var node_b = tree.getNodeByName('node_b');
+    assert.equal(node_b.name, 'node_b');
+
+    // - Add 'node_a' after node1
+    var node1 = tree.getNodeByName('node1');
+    node1.addAfter('node_a');
+
+    assert.equal(formatNodes(tree.children), 'node1 node_a node2 node_b');
+
+    // - Add 'node_c' after node_b; new node is an object
+    node_b.addAfter({
+        label: 'node_c',
+        id: 789
+    });
+
+    var node_c = tree.getNodeByName('node_c');
+    assert.equal(node_c.id, 789);
+
+    assert.equal(formatNodes(tree.children), 'node1 node_a node2 node_b node_c');
+
+    // - Add after root node; this is not possible
+    assert.equal(tree.addAfter('node_x'), null);
+});
+
+test('addBefore', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // - Add 'node_0' before node1
+    var node1 = tree.getNodeByName('node1');
+    node1.addBefore('node0');
+    assert.equal(formatNodes(tree.children), 'node0 node1 node2');
+
+    // - Add before root node; this is not possile
+    assert.equal(tree.addBefore('x'), null);
+});
+
+test('addParent', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // - Add node 'root' as parent of node1
+    // Note that node also becomes a child of 'root'
+    var node1 = tree.getNodeByName('node1');
+    node1.addParent('root');
+
+    var root = tree.getNodeByName('root');
+    assert.equal(formatNodes(root.children), 'node1 node2');
+
+    // - Add parent to root node; not possible
+    assert.equal(tree.addParent('x'), null);
+});
+
+test('remove', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    var child1 = tree.getNodeByName('child1');
+    var node1 = tree.getNodeByName('node1');
+
+    assert.equal(formatNodes(node1.children), 'child1 child2');
+    assert.equal(child1.parent, node1);
+
+    // 1. Remove child1
+    child1.remove();
+
+    assert.equal(formatNodes(node1.children), 'child2');
+    assert.equal(child1.parent, null);
+});
+
+test('append', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    var node1 = tree.getNodeByName('node1');
+
+    // 1. Append child3 to node1
+    node1.append('child3');
+
+    assert.equal(formatNodes(node1.children), 'child1 child2 child3');
+
+    // 2. Append subtree
+    node1.append(
+        {
+            name: 'child4',
+            children: [
+                { name: 'child5' }
+            ]
+        }
+    );
+
+    assert.equal(formatNodes(node1.children), 'child1 child2 child3 child4');
+
+    var child4 = node1.getNodeByName('child4');
+    assert.equal(formatNodes(child4.children), 'child5');
+});
+
+test('prepend', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    var node1 = tree.getNodeByName('node1');
+
+    // 1. Prepend child0 to node1
+    node1.prepend('child0');
+
+    assert.equal(formatNodes(node1.children), 'child0 child1 child2');
+
+    // 2. Prepend subtree
+    node1.prepend({
+        name: 'child3',
+        children: [
+            { name: 'child4' }
+        ]
+    });
+
+    assert.equal(formatNodes(node1.children), 'child3 child0 child1 child2');
+
+    var child3 = node1.getNodeByName('child3');
+    assert.equal(formatNodes(child3.children), 'child4');
+});
+
+test('getNodeById', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // 1. Get node with id 124
+    var node = tree.getNodeById(124);
+    assert.equal(node.name, 'node2');
+
+    // 2. Delete node with id 124 and search again
+    node.remove();
+
+    assert.equal(tree.getNodeById(124), null);
+
+    // 3. Add node with id 456 and search for it
+    var child3 = tree.getNodeByName('child2');
+    child3.append({
+        id: 456,
+        label: 'new node'
+    });
+
+    node = tree.getNodeById(456);
+    assert.equal(node.name, 'new node');
+});
+
+test('getLevel', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // 1. get level for node1 and child1
+    assert.equal(tree.getNodeByName('node1').getLevel(), 1);
+    assert.equal(tree.getNodeByName('child1').getLevel(), 2);
+});
+
+test('loadFromData and id mapping', function(assert) {
+    // - get node from empty tree
+    var tree = new Node(null, true);
+    assert.equal(tree.getNodeById(999), null);
+
+    // - load example data in tree
+    tree.loadFromData(example_data);
+    assert.equal(tree.getNodeById(124).name, 'node2');
+
+    var child2 = tree.getNodeById(126);
+    child2.addChild(
+        new Node({label: 'child4', id: 128})
+    );
+    child2.addChild(
+        new Node({label: 'child5', id: 129})
+    );
+
+    // - load data in node child2
+    child2.loadFromData(['abc', 'def']);
+
+    assert.equal(tree.getNodeById(128), null);
+    assert.equal(child2.children.length, 2);
+    assert.equal(child2.children[0].name, 'abc');
+});
+
+test('removeChildren', function(assert) {
+    // - load example data
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // add child4 and child5
+    var child2 = tree.getNodeById(126);
+    assert.equal(child2.name, 'child2');
+
+    child2.addChild(
+        new Node({label: 'child4', id: 128})
+    );
+    child2.addChild(
+        new Node({label: 'child5', id: 129})
+    );
+    assert.equal(tree.getNodeById(128).name, 'child4');
+
+    // - remove children from child2
+    child2.removeChildren();
+    assert.equal(tree.getNodeById(128), null);
+    assert.equal(child2.children.length, 0);
+});
+
+test('node with id 0', function(assert) {
+    // - load node with id 0
+    var tree = new Node(null, true);
+    tree.loadFromData([
+        {
+            id: 0,
+            label: 'mynode'
+        }
+    ]);
+
+    // - get node by id
+    var node = tree.getNodeById(0);
+    assert.equal(node.name, 'mynode');
+
+    // -- remove the node
+    node.remove();
+
+    assert.equal(tree.getNodeById(0), undefined);
+});
+
+test('getPreviousSibling', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // - getPreviousSibling
+    assert.equal(
+        tree.getNodeByName('child2').getPreviousSibling().name,
+        'child1'
+    );
+    assert.equal(tree.getPreviousSibling(), null);
+    assert.equal(
+        tree.getNodeByName('child1').getPreviousSibling(),
+        null
+    );
+});
+
+test('getNextSibling', function(assert) {
+    // setup
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    // - getNextSibling
+    assert.equal(
+        tree.getNodeByName('node1').getNextSibling().name,
+        'node2'
+    );
+    assert.equal(
+        tree.getNodeByName('node2').getNextSibling(),
+        null
+    );
+    assert.equal(tree.getNextSibling(), null);
+});
+
+test('getNodesByProperty', function(assert) {
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    nodes = tree.getNodesByProperty('name', 'child1');
+
+    assert.equal(nodes.length, 1);
+    assert.equal(nodes[0].name, 'child1');
+});
+
+test('getNodeByCallback', function(assert) {
+    var tree = new Node(null, true);
+    tree.loadFromData(example_data);
+
+    node = tree.getNodeByCallback(
+        function(node) {
+            return node.name == 'child1';
+        }
+    );
+
+    assert.equal(node.name, 'child1');
+});