var mockjax = require('jquery-mockjax')(jQuery, window);

var utils_for_test = require('./utils_for_test');

var example_data = utils_for_test.example_data;
var example_data2 = utils_for_test.example_data2;
var formatNodes = utils_for_test.formatNodes;
var formatTitles = utils_for_test.formatTitles;
var isNodeOpen = utils_for_test.isNodeOpen;
var isNodeClosed = utils_for_test.isNodeClosed;

var tree_vars = utils_for_test.getTreeVariables();

var Position = tree_vars.Position;

var test = QUnit.test;


QUnit.module("jqtree", {
    beforeEach: function() {
        $('body').append('<div id="tree1"></div>');
    },

    afterEach: function() {
        var $tree = $('#tree1');
        $tree.tree('destroy');
        $tree.remove();

        $.mockjax.clear();
    }
});

test("create jqtree from data", function(assert) {
    $('#tree1').tree({
        data: example_data
    });

    assert.equal(
        $('#tree1').children().length, 1,
        'number of children on level 0'
    );
    assert.ok(
        $('#tree1').children().is('ul.jqtree-tree'),
        'first element is ul.jqtree-tree'
    );
    assert.equal(
        $('#tree1 ul.jqtree-tree > li').length, 2,
        'number of children on level 1'
    );
    assert.ok(
        $('#tree1 ul.jqtree-tree li:eq(0)').is('li.jqtree-folder.jqtree-closed'),
        'first child is li.jqtree-folder.jqtree-closed'
    );
    assert.ok(
        $('#tree1 ul.jqtree-tree li:eq(0) > .jqtree-element > a.jqtree-toggler').is('a.jqtree-toggler.jqtree-closed'),
        'button in first folder'
    );
    assert.equal(
        $('#tree1 ul.jqtree-tree li:eq(0) > .jqtree-element span.jqtree-title').text(),
        'node1'
    );
});

test('toggle', function(assert) {
    // setup
    var done = assert.async();

    // create tree
    var $tree = $('#tree1');
    var $node1;
    var node1;

    $tree.tree({
        data: example_data
    });

    $tree.bind(
        'tree.open',
        function(e) {
            assert.ok(! isNodeClosed($node1), 'node1 is open');

            // 2. close node1
            $tree.tree('toggle', node1);
        }
    );

    $tree.bind(
        'tree.close',
        function(e) {
            assert.ok(isNodeClosed($node1), 'node1 is closed');

            done();
        }
    );

    var tree = $tree.tree('getTree');
    node1 = tree.children[0];
    $node1 = $tree.find('ul.jqtree-tree li:eq(0)');

    // node1 is initially closed
    assert.ok(isNodeClosed($node1), 'node1 is closed');

    // 1. open node1
    $tree.tree('toggle', node1);
});

test("click event", function(assert) {
    var select_count = 0;

    // create tree
    var $tree = $('#tree1');

    $tree.tree({
        data: example_data,
        selectable: true
    });

    var $node1 = $tree.find('ul.jqtree-tree li:first');
    var $text_span = $node1.find('span:first');

    $tree.bind('tree.click', function(e) {
        assert.equal(e.node.name, 'node1');
    });

    var done = assert.async();

    $tree.bind('tree.select', function(e) {
        select_count += 1;

        if (select_count == 1) {
            assert.equal(e.node.name, 'node1');

            assert.equal($tree.tree('getSelectedNode').name, 'node1');

            // deselect
            $text_span.click();
        }
        else {
            assert.equal(e.node, null);
            assert.equal(e.previous_node.name, 'node1');
            assert.equal($tree.tree('getSelectedNode'), false);

            done();
        }
    });

    // click on node1
    $text_span.click();
});

test('saveState', function(assert) {
    var $tree = $('#tree1');

    var saved_state;

    function setState(state) {
        saved_state = state;
    }

    function getState() {
        return saved_state;
    }

    function createTree() {
        $tree.tree({
            data: example_data,
            saveState: true,
            onSetStateFromStorage: setState,
            onGetStateFromStorage: getState,
            selectable: true
        });
    }

    // create tree
    createTree();

    // nodes are initially closed
    var tree = $tree.tree('getTree');
    tree.iterate(function(node) {
        assert.ok(! node.is_open, 'jqtree-closed');
        return true;
    });

    // open node1
    $tree.tree('toggle', tree.children[0]);

    // node1 is open
    assert.ok(tree.children[0].is_open, 'node1 is_open');

    // select node2
    $tree.tree('selectNode', tree.children[1]);

    // node2 is selected
    assert.equal(
        $tree.tree('getSelectedNode').name,
        'node2',
        'getSelectedNode (1)'
    );

    // create tree again
    $tree.tree('destroy');
    createTree();

    tree = $tree.tree('getTree');
    assert.ok(tree.children[0].is_open, 'node1 is_open');
    assert.ok(! tree.children[1].is_open, 'node2 is closed');

    // node2 is selected
    assert.equal(
        $tree.tree('getSelectedNode').name,
        'node2',
        'getSelectedNode (2)'
    );
});

test('getSelectedNode', function(assert) {
    var $tree = $('#tree1');

    // create tree
    $tree.tree({
        data: example_data,
        selectable: true
    });

    // there is no node selected
    assert.equal(
        $tree.tree('getSelectedNode'),
        false,
        'getSelectedNode'
    );

    // select node1
    var tree = $tree.tree('getTree');
    var node1 = tree.children[0];
    $tree.tree('selectNode', node1);

    // node1 is selected
    assert.equal(
        $tree.tree('getSelectedNode').name,
        'node1',
        'getSelectedNode'
    );
});

test("toJson", function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    // 1. call toJson
    assert.equal(
        $tree.tree('toJson'),
        '[{"name":"node1","id":123,"int_property":1,"str_property":"1",'+
        '"children":[{"name":"child1","id":125,"int_property":2},{"name":'+
        '"child2","id":126}]},{"name":"node2","id":124,"int_property":3,'+
        '"str_property":"3","children":[{"name":"child3","id":127}]}]'
    );

    // Check that properties 'children', 'parent' and 'element' still exist.
    var tree = $tree.tree('getTree');
    assert.equal(tree.children.length, 2);
    assert.ok(tree.children[0].parent != undefined, 'parent');
    assert.ok($(tree.children[0].element).is('li'), 'element');
});

test('loadData', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        autoOpen: true
    });

    // first node is 'node1'
    assert.equal(
        $tree.find('> ul > li:first .jqtree-element:first > span').text(),
        'node1'
    );

    // - load new data
    $tree.tree('loadData', example_data2);

    // first node is 'main'
    assert.equal(
        $tree.find('> ul > li:first .jqtree-element:first > span').text(),
        'main'
    );

    // - load new data under node 'child3'
    $tree.tree('loadData', example_data);

    var child3 = $tree.tree('getNodeByName', 'child3');

    var data = [
        { label: 'c4', id: 200 },
        {
            label: 'c5', id: 201,
            children: [
                { label: 'c6', id: 202 }
            ]
        }
    ];
    $tree.tree('loadData', data, child3);

    // first node in html is still 'node1'
    assert.equal(
        $tree.find('li:eq(0)').find('.jqtree-element:eq(0) span.jqtree-title').text(),
        'node1'
    );

    // Node 'child3' now has a children 'c4' and 'c5'
    var $child3 = $tree.find('span:contains(child3)');
    var $li = $child3.closest('li');
    assert.equal(
        $li.children('ul').children('li:eq(0)').find('.jqtree-element span.jqtree-title').text(),
        'c4'
    );

    // Node 'child3' must have toggler button
    assert.ok(
        $child3.prev().is('a.jqtree-toggler'),
        "node 'child3' must have toggler button"
    );

    // - select node 'c5' and load new data under 'child3'
    var c5 = $tree.tree('getNodeByName', 'c5');
    $tree.tree('selectNode', c5);

    assert.equal($tree.tree('getSelectedNode').name, 'c5');

    var data2 = [
        { label: 'c7' },
        { label: 'c8' }
    ];
    $tree.tree('loadData', data2, child3);

    // c5 must be deselected
    assert.equal($tree.tree('getSelectedNode'), false);

    // - select c7; load new data under child3; note that c7 has no id
    $tree.tree('selectNode', $tree.tree('getNodeByName', 'c7'));

    assert.equal($tree.tree('getSelectedNode').name, 'c7');

    $tree.tree('loadData', [ 'c9' ], child3);

    assert.equal($tree.tree('getSelectedNode'), false);

    // - select c9 (which has no id); load new nodes under child2
    $tree.tree('selectNode', $tree.tree('getNodeByName', 'c9'));

    var child2 = $tree.tree('getNodeByName', 'child2');
    $tree.tree('loadData', [ 'c10' ], child2);

    assert.equal($tree.tree('getSelectedNode').name, 'c9');
});

test('openNode and closeNode', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    var node2 = $tree.tree('getNodeByName', 'node2');
    assert.equal(node2.name, 'node2');
    assert.equal(node2.is_open, undefined);

    // 1. open node2
    $tree.tree('openNode', node2, false);
    assert.equal(node2.is_open, true);
    assert.equal(isNodeOpen($(node2.element)), true);

    // 2. close node2
    $tree.tree('closeNode', node2, false);
    assert.equal(node2.is_open, false);
    assert.equal(isNodeClosed($(node2.element)), true);

    // 3. open child1
    var node1 = $tree.tree('getNodeByName', 'node1');
    var child1 = $tree.tree('getNodeByName', 'child1');

    // add a child to child1 so it is a folder
    $tree.tree('appendNode', 'child1a', child1);

    // node1 is initialy closed
    assert.equal(node1.is_open, undefined);

    // open child1
    $tree.tree('openNode', child1, false);

    // node1 and child1 are now open1
    assert.equal(node1.is_open, true);
    assert.equal(child1.is_open, true);
});

function test_open_node_with_callback(slide, include_slide_param, assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    var node2 = $tree.tree('getNodeByName', 'node2');

    // open node2
    var done = assert.async();

    function handleOpenNode(node) {
      assert.equal(node.name, 'node2');
      assert.ok(node.is_open);

      done();
    }

    if (include_slide_param) {
        $tree.tree('openNode', node2, slide, handleOpenNode);
    }
    else {
        $tree.tree('openNode', node2, handleOpenNode);
    }
}

test('openNode with callback with slide true', function(assert) {
    test_open_node_with_callback(true, true, assert);
});

test('openNode with callback with slide false', function(assert) {
    test_open_node_with_callback(false, true, assert);
});

test('openNode with callback with slide null', function(assert) {
    test_open_node_with_callback(null, true, assert);
});

test('openNode with callback without slide param', function(assert) {
    test_open_node_with_callback(null, false, assert);
});

test('selectNode', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        selectable: true
    });

    var node1 = $tree.tree('getTree').children[0];
    var node2 = $tree.tree('getTree').children[1];
    var child3 = node2.children[0];

    assert.equal(child3.name, 'child3');
    assert.equal(node1.is_open, undefined);
    assert.equal(node2.is_open, undefined);
    assert.equal(child3.is_open, undefined);

    // -- select node 'child3', which is a child of 'node2'; must_open_parents = true
    $tree.tree('selectNode', child3, true);
    assert.equal($tree.tree('getSelectedNode').name, 'child3');

    assert.equal(node1.is_open, undefined);
    assert.equal(node2.is_open, true);
    assert.equal(child3.is_open, undefined);

    // -- select node 'node1'
    $tree.tree('selectNode', node1);
    assert.equal($tree.tree('getSelectedNode').name, 'node1');

    // -- is 'node1' selected?
    assert.equal($tree.tree('isNodeSelected', node1), true);

    // -- deselect
    $tree.tree('selectNode', null);
    assert.equal($tree.tree('getSelectedNode'), false);

    // -- is 'node1' selected?
    assert.equal($tree.tree('isNodeSelected', node1), false);
});

test('selectNode when another node is selected', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        selectable: true
    });

    var node1 = $tree.tree('getTree').children[0];
    var node2 = $tree.tree('getTree').children[1];

    // -- select node 'node2'
    $tree.tree('selectNode', node2);
    assert.equal($tree.tree('getSelectedNode').name, 'node2');

    // -- setting event
    // -- is node 'node2' named 'deselected_node' in object's attributes?
    var is_select_event_fired = false;

    $tree.bind('tree.select', function(e) {
        assert.equal(e.deselected_node, node2);
        is_select_event_fired = true;
    });

    // -- select node 'node1'; node 'node2' is selected before it
    $tree.tree('selectNode', node1);
    assert.equal($tree.tree('getSelectedNode').name, 'node1');

    assert.equal($tree.tree('isNodeSelected', node1), true);

    // event was fired
    assert.ok(is_select_event_fired);
});

test('click toggler', function(assert) {
    // setup
    var done = assert.async();

    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        selectable: true
    });

    var $title = $tree.find('li:eq(0)').find('> .jqtree-element > span.jqtree-title');
    assert.equal($title.text(), 'node1');
    var $toggler = $title.prev();
    assert.ok($toggler.is('a.jqtree-toggler.jqtree-closed'));

    $tree.bind('tree.open', function(e) {
        // 2. handle 'open' event
        assert.equal(e.node.name, 'node1');

        // 3. click toggler again
        $toggler.click();
    });

    $tree.bind('tree.close', function(e) {
        assert.equal(e.node.name, 'node1');
        done();
    });

    // 1. click toggler of 'node1'
    $toggler.click();
});

test('getNodeById', function(assert) {
	// setup
	var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });
    var node2 = $tree.tree('getNodeByName', 'node2');

    // 1. get 'node2' by id
    assert.equal(
        $tree.tree('getNodeById', 124).name,
        'node2'
    );

    // 2. get id that does not exist
    assert.equal($tree.tree('getNodeById', 333), null);

    // 3. get id by string
    assert.equal(
        $tree.tree('getNodeById', '124').name,
        'node2'
    );

    // 4. add node with string id; search by int
    $tree.tree(
        'appendNode',
        {
            label: 'abc',
            id: '234'
        }
    );

    assert.equal(
        $tree.tree('getNodeById', 234).name,
        'abc'
    );
    assert.equal(
        $tree.tree('getNodeById', '234').name,
        'abc'
    );

    // 5. load subtree in node2
    var subtree_data = [
        {
            label: 'sub1',
            id: 200,
            children: [
                {label: 'sub2', id: 201}
            ]
        }
    ];
    $tree.tree('loadData',  subtree_data, node2);
    var t = $tree.tree('getTree');

    assert.equal(
        $tree.tree('getNodeById', 200).name,
        'sub1'
    );
    assert.equal(
        $tree.tree('getNodeById', 201).name,
        'sub2'
    );
});

test('autoOpen', function(assert) {
    var $tree = $('#tree1');

    function formatOpenFolders() {
        var open_nodes = [];
        $tree.find('li').each(function() {
            var $li = $(this);
            if ($li.is('.jqtree-folder') && ! $li.is('.jqtree-closed')) {
                var label = $li.children('.jqtree-element').find('span').text();
                open_nodes.push(label);
            };
        });

        return open_nodes.join(';');
    }

    /*
    -l1n1 (level 0)
    ----l2n1 (1)
    ----l2n2 (1)
    -------l3n1 (2)
    ----------l4n1 (3)
    -l1n2
    */
    var data = [
        {
            label: 'l1n1',
            children: [
                'l2n1',
                {
                    label: 'l2n2',
                    children: [
                        {
                            label: 'l3n1',
                            children: [
                                'l4n1'
                            ]
                        }
                    ]
                }
            ]
        },
        'l1n2'
    ];

    // 1. autoOpen is false
    $tree.tree({
        data: data,
        autoOpen: false
    });
    assert.equal(formatOpenFolders(), '');

    $tree.tree('destroy');

    // 2. autoOpen is true
    $tree.tree({
        data: data,
        autoOpen: true
    });
    assert.equal(formatOpenFolders(), 'l1n1;l2n2;l3n1');

    $tree.tree('destroy');

    // 3. autoOpen level 1
    $tree.tree({
        data: data,
        autoOpen: 1
    });
    assert.equal(formatOpenFolders(), 'l1n1;l2n2');
});

test('onCreateLi', function(assert) {
    // 1. init tree with onCreateLi
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        onCreateLi: function(node, $li) {
            var $span = $li.children('.jqtree-element').find('span');
            $span.html('_' + node.name + '_');
        }
    });

    assert.equal(
        $tree.find('span:eq(0)').text(),
        '_node1_'
    );
});

test('save state', function(assert) {
    // setup
    var state = null;

    // Fake $.cookie plugin for browsers that do not support localstorage
    $.cookie = function(key, param2, param3) {
        if (typeof param3 == 'object') {
            // set
            state = param2;
        }
        else {
            // get
            return state;
        }
    }

    // Remove state from localstorage
    if (typeof localStorage != 'undefined') {
        localStorage.setItem('my_tree', null);
    }

    // 1. init tree
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        selectable: true,
        saveState: 'my_tree'
    });

    var tree = $tree.tree('getTree');
    assert.equal($tree.tree('getSelectedNode'), false);

    // 2. select node -> state is saved
    $tree.tree('selectNode', tree.children[0]);
    assert.equal($tree.tree('getSelectedNode').name, 'node1');

    // 3. init tree again
    $tree.tree('destroy');

    $tree.tree({
        data: example_data,
        selectable: true,
        saveState: 'my_tree'
    });

    assert.equal($tree.tree('getSelectedNode').name, 'node1');

    $.cookie = null;
});

test('generate hit areas', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    // 1. get hit areas
	var node = $tree.tree('getNodeById', 123);
    var hit_areas = $tree.tree('testGenerateHitAreas', node);

    var strings = $.map(hit_areas, function(hit_area) {
        return hit_area.node.name + ' ' + Position.getName(hit_area.position);
    });
    assert.equal(strings.join(';'), 'node1 none;node2 inside;node2 after');
});

test('removeNode', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        selectable: true
    });

    // 1. Remove selected node; node is 'child1'
    var child1 = $tree.tree('getNodeByName', 'child1');
    $tree.tree('selectNode', child1);

    assert.equal($tree.tree('getSelectedNode').name, 'child1');

    $tree.tree('removeNode', child1);

    assert.equal(
        formatTitles($tree),
        'node1 child2 node2 child3'
    );

    // getSelectedNode must now return false
    assert.equal($tree.tree('getSelectedNode'), false);

    // 2. No node is selected; remove child3
    $tree.tree('loadData', example_data);

    var child3 = $tree.tree('getNodeByName', 'child3');
    $tree.tree('removeNode', child3);

    assert.equal(
        formatTitles($tree),
        'node1 child1 child2 node2'
    );

    assert.equal($tree.tree('getSelectedNode'), false);

    // 3. Remove parent of selected node
    $tree.tree('loadData', example_data);

    child1 = $tree.tree('getNodeByName', 'child1');
    var node1 = $tree.tree('getNodeByName', 'node1');

    $tree.tree('selectNode', child1);

    $tree.tree('removeNode', node1);

    // node is unselected
    assert.equal($tree.tree('getSelectedNode'), false);

    // 4. Remove unselected node without an id
    $tree.tree('loadData', example_data2);

    var c1 = $tree.tree('getNodeByName', 'c1');

    $tree.tree('removeNode', c1);

    assert.equal(
        formatTitles($tree),
        'main c2'
    );
});

test('appendNode', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    var node1 = $tree.tree('getNodeByName', 'node1');

    // 1. Add child3 to node1
    $tree.tree('appendNode', 'child3', node1);

    assert.equal(
        formatTitles($(node1.element)),
        'node1 child1 child2 child3'
    );

    // 2. Add child4 to child1
    var child1 = $tree.tree('getNodeByName', 'child1');

    // Node 'child1' does not have a toggler button
    assert.equal(
        $(child1.element).find('> .jqtree-element > .jqtree-toggler').length,
        0
    );

    $tree.tree('appendNode', 'child4', child1);

    assert.equal(formatTitles($(child1.element)), 'child1 child4');

    // Node 'child1' must get a toggler button
    assert.equal(
        $(child1.element).find('> .jqtree-element > .jqtree-toggler').length,
        1
    );
});

test('prependNode', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    var node1 = $tree.tree('getNodeByName', 'node1');

    // 1. Prepend child0 to node1
    $tree.tree('prependNode', 'child0', node1);

    assert.equal(
        formatTitles($(node1.element)),
        'node1 child0 child1 child2'
    );
});

test('init event for local data', function(assert) {
    // setup
    var done = assert.async();

    var $tree = $('#tree1');

    $tree.bind('tree.init', function() {
        // Check that we can call functions in 'tree.init' event
        assert.equal($tree.tree('getNodeByName', 'node2').name, 'node2');

        done();
    });

    // init tree
    $tree.tree({
        data: example_data
    });
});

test('init event for ajax', function(assert) {
    // setup
    var done = assert.async();

    var $tree = $('#tree1');

    mockjax({
        url: '/tree/',
        responseText: example_data,
        logging: false
    });

    $tree.bind('tree.init', function() {
        assert.equal($tree.tree('getNodeByName', 'node2').name, 'node2');

        done();
    });

    // init tree
    $tree.tree({
        dataUrl: '/tree/'
    });
});

test('updateNode', function(assert) {
    // setup
    var $tree = $('#tree1');

    $tree.tree({ data: example_data });

    assert.equal(formatTitles($tree), 'node1 child1 child2 node2 child3');

    // -- update label
    var node2 = $tree.tree('getNodeByName', 'node2');
    $tree.tree('updateNode', node2, 'CHANGED');

    assert.equal(formatTitles($tree), 'node1 child1 child2 CHANGED child3');
    assert.equal(node2.name, 'CHANGED');

    // -- update data
    $tree.tree(
        'updateNode',
        node2,
        {
            name: 'xyz',
            tag1: 'abc'
        }
    );

    assert.equal(formatTitles($tree), 'node1 child1 child2 xyz child3');
    assert.equal(node2.name, 'xyz');
    assert.equal(node2.tag1, 'abc');

    // - update id
    assert.equal(node2.id, 124);

    $tree.tree('updateNode', node2, {id: 555});

    assert.equal(node2.id, 555);
    assert.equal(node2.name, 'xyz');

    // get node by id
    var node_555 = $tree.tree('getNodeById', 555);
    assert.equal(node_555.name, 'xyz');

    var node_124 = $tree.tree('getNodeById', 124);
    assert.equal(node_124, undefined);

    // update child1
    var child1 = $tree.tree('getNodeByName', 'child1');

    $tree.tree('updateNode', child1, 'child1a');

    assert.equal(formatTitles($tree), 'node1 child1a child2 xyz child3');

    // select child1
    $tree.tree('selectNode', child1);
    $tree.tree('updateNode', child1, 'child1b');

    assert.ok($(child1.element).hasClass('jqtree-selected'));

    // add children to child1
    $tree.tree(
        'updateNode',
        child1,
        {
            id: child1.id,
            name: 'child1',
            children: [
                { id: 5, name: 'child1-1' }
            ]
        }
    );

    assert.equal(formatTitles($tree), 'node1 child1 child1-1 child2 xyz child3');

    // remove children
    $tree.tree(
        'updateNode',
        child1,
        {
            id: child1.id,
            name: 'child1',
            children: []
        }
    );

    assert.equal(formatTitles($tree), 'node1 child1 child2 xyz child3');
});

test('moveNode', function(assert) {
    // setup
    var $tree = $('#tree1');

    $tree.tree({ data: example_data });

    var child1 = $tree.tree('getNodeByName', 'child1');
    var child2 = $tree.tree('getNodeByName', 'child2');
    var node1 = $tree.tree('getNodeByName', 'node1');
    var node2 = $tree.tree('getNodeByName', 'node2');

    // -- Move child1 after node2
    $tree.tree('moveNode', child1, node2, 'after');

    assert.equal(formatTitles($tree), 'node1 child2 node2 child3 child1');

    // -- Check that illegal moves are skipped
    $tree.tree('moveNode', node1, child2, 'inside');
});

test('load on demand', function(assert) {
    // setup
    var done = assert.async();

    var $tree = $('#tree1');

    $tree.tree({
        data: [
            {
                id: 1,
                label: 'node1',
                load_on_demand: true
            }
        ],
        dataUrl: '/tree/'
    });

    mockjax({
        url: '*',
        response: function(options) {
            assert.equal(options.url, '/tree/', '2');
            assert.deepEqual(options.data, { 'node' : 1 }, '3');

            this.responseText = [
                {
                    id: 2,
                    label: 'child1'
                }
            ];
        },
        logging: false
    });

    // -- open node
    function handleOpenNode(node) {
        assert.equal(node.name, 'node1');
        assert.equal(formatTitles($tree), 'node1 child1', '4');

        done();
    }

    var node1 = $tree.tree('getNodeByName', 'node1');
    assert.equal(formatTitles($tree), 'node1', '1');

    $tree.tree('openNode', node1, handleOpenNode);
});

test('addNodeAfter', function(assert) {
    // setup
    var $tree = $('#tree1');

    $tree.tree({ data: example_data });
    var node1 = $tree.tree('getNodeByName', 'node1');

    // -- add node after node1
    $tree.tree('addNodeAfter', 'node3', node1);

    assert.equal(formatTitles($tree), 'node1 child1 child2 node3 node2 child3');
});

test('addNodeBefore', function(assert) {
    // setup
    var $tree = $('#tree1');

    $tree.tree({ data: example_data });
    var node1 = $tree.tree('getNodeByName', 'node1');

    // -- add node before node1
    var new_node = $tree.tree('addNodeBefore', 'node3', node1);

    assert.equal(formatTitles($tree), 'node3 node1 child1 child2 node2 child3');
});

test('addParentNode', function(assert) {
    // setup
    var $tree = $('#tree1');

    $tree.tree({ data: example_data });
    var child3 = $tree.tree('getNodeByName', 'child3');

    // -- add parent to child3
    $tree.tree('addParentNode', 'node3', child3);

    assert.equal(formatTitles($tree), 'node1 child1 child2 node2 node3 child3');
});

test('mouse events', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data,
        dragAndDrop: true,
        autoOpen: true
    });
    $tree.tree('setMouseDelay', 0);

    function getTitleElement(node_name) {
        var node = $tree.tree('getNodeByName', node_name);
        var $el = $(node.element);
        return $($el.find('.jqtree-title'));
    }

    var $node1 = getTitleElement('node1');
    var $child3 = getTitleElement('child3');

    // Move node1 inside child3
    // trigger mousedown event on node1
    $node1.trigger(
        $.Event('mousedown', { which: 1 })
    );

    // trigger mouse move to child3
    var child3_offset = $child3.offset();
    $tree.trigger(
        $.Event('mousemove', { pageX: child3_offset.left, pageY: child3_offset.top })
    );
    $tree.trigger('mouseup');

    assert.equal(
        formatTitles($tree),
        'node2 child3 node1 child1 child2'
    );
});

test('multiple select', function(assert) {
    // setup
    var $tree = $('#tree1');
    $tree.tree({ data: example_data });

    var child1 = $tree.tree('getNodeByName', 'child1');
    var child2 = $tree.tree('getNodeByName', 'child2');

    // -- add nodes to selection
    // todo: more nodes as parameters?
    // todo: rename to 'selection.add' or 'selection' 'add'?
    $tree.tree('addToSelection', child1);
    $tree.tree('addToSelection', child2);

    // -- get selected nodes
    var selected_nodes = $tree.tree('getSelectedNodes');
    assert.equal(
        formatNodes(selected_nodes),
        'child1 child2'
    );
});

test('keyboard', function(assert) {
    // setup
    var $tree = $('#tree1');

    function keyDown(key) {
        $tree.trigger(
            $.Event('keydown', { which: key })
        );
    }

    $tree.tree({ data: example_data });

    var node1 = $tree.tree('getNodeByName', 'node1');

    // select node1
    $tree.tree('selectNode', node1);
    assert.equal(node1.is_open, undefined);

    // - move down; -> node2
    keyDown(40);
    assert.equal($tree.tree('getSelectedNode').name, 'node2');

    // - move up; -> back to node1
    keyDown(38);
    assert.equal($tree.tree('getSelectedNode').name, 'node1');

    // - move right; open node1
    keyDown(39);
    assert.equal(node1.is_open, true);
    assert.equal($tree.tree('getSelectedNode').name, 'node1');

    // - select child3 and move up -> node2
    $tree.tree('selectNode', $tree.tree('getNodeByName', 'child3'));
    keyDown(38);
    assert.equal($tree.tree('getSelectedNode').name, 'node2');

    // - move up -> child2
    keyDown(38);
    assert.equal($tree.tree('getSelectedNode').name, 'child2');

    // - select node1 and move left ->  close
    $tree.tree('selectNode', node1);
    keyDown(37);
    assert.equal(node1.is_open, false);
    assert.equal($tree.tree('getSelectedNode').name, 'node1');
});

test('getNodesByProperty', function(assert) {
  // setup
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });
    var node2 = $tree.tree('getNodeByName', 'node2');

    // 1. get 'node1' by property
    assert.equal(
        $tree.tree('getNodesByProperty', 'int_property', 1)[0].name,
        'node1'
    );

    // 2. get property that does not exist in any node
    assert.equal($tree.tree('getNodesByProperty', 'int_property', 123).length, 0);

    // 3. get string property
    assert.equal(
        $tree.tree('getNodesByProperty', 'str_property', '1')[0].name,
        'node1'
    );

    // 4. add node with string id; search by int
    $tree.tree(
        'appendNode',
        {
            label: 'abc',
            id: '234',
            str_property: '111',
            int_property: 111
        }
    );

    assert.equal(
        $tree.tree('getNodesByProperty', 'int_property', 111)[0].name,
        'abc'
    );
    assert.equal(
        $tree.tree('getNodesByProperty', 'str_property', '111')[0].name,
        'abc'
    );

    // 5. load subtree in node2
    var subtree_data = [
        {
            label: 'sub1',
            id: 200,
            int_property: 222,
            children: [
                {label: 'sub2', id: 201, int_property: 444}
            ]
        }
    ];
    $tree.tree('loadData',  subtree_data, node2);
    var t = $tree.tree('getTree');

    assert.equal(
        $tree.tree('getNodesByProperty', 'int_property', 222)[0].name,
        'sub1'
    );
    assert.equal(
        $tree.tree('getNodesByProperty', 'int_property', 444)[0].name,
        'sub2'
    );
});

test('dataUrl extra options', function(assert) {
    var done = assert.async();

    var $tree = $('#tree1');

    mockjax({
        url: '*',
        response: function(options) {
            // 2. handle ajax request
            // expect 'headers' option
            assert.equal(options.url, '/tree2/');
            assert.deepEqual(options.headers, {'abc': 'def'});

            done();
        },
        logging: false
    });

    // 1. init tree
    // dataUrl contains 'headers' option
    $tree.tree({
        dataUrl: {
            'url': '/tree2/',
            'headers': {'abc': 'def'}
        }
    });
});

test('dataUrl is function', function(assert) {
    var done = assert.async();

    var $tree = $('#tree1');

    mockjax({
        url: '*',
        response: function(options) {
            // 2. handle ajax request
            // expect 'headers' option
            assert.equal(options.url, '/tree3/');
            assert.deepEqual(options.headers, {'abc': 'def'});

            done();
        },
        logging: false
    });

    // 1. init tree
    // dataUrl is a function
    $tree.tree({
        dataUrl: function(node) {
            return {
                'url': '/tree3/',
                'headers': {'abc': 'def'}
            };
        }
    });
});

test('getNodeByHtmlElement', function(assert) {
    var $tree = $('#tree1');
    $tree.tree({
        data: example_data
    });

    var $el = $('.jqtree-title');

    // Get node for jquery element
    var node = $tree.tree('getNodeByHtmlElement', $el);
    assert.equal(node.name, 'node1');

    // Same for html element
    node = $tree.tree('getNodeByHtmlElement', $el[0]);
    assert.equal(node.name, 'node1');
});

test('onLoadFailed', function(assert) {
    mockjax({
        url: '/tree/',
        status: 500,
        responseText: 'test error',
        logging: false
    });

    var done = assert.async();

    function handleLoadFailed(e) {
        assert.equal(e.responseText, 'test error');

        done();
    }

    var $tree = $('#tree1');
    $tree.tree({
        dataUrl: '/tree/',
        onLoadFailed: handleLoadFailed
    });
});