jqtree 1.7.5 → 1.8.1

package/lib/test/node.test.js

@@ -1,1202 +0,0 @@
-"use strict";
-
-var _givens = _interopRequireDefault(require("givens"));
-var _node = require("../node");
-var _exampleData = _interopRequireDefault(require("./support/exampleData"));
-require("jest-extended");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-var context = describe;
-describe("addAfter", function () {
-  var given = (0, _givens["default"])();
-  given("node1", function () {
-    return given.tree.getNodeByNameMustExist("node1");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("when moving after node1", function () {
-    it("returns the new node", function () {
-      expect(given.node1.addAfter("new node")).toMatchObject({
-        name: "new node"
-      });
-    });
-    it("adds after the node", function () {
-      given.node1.addAfter("new node");
-      expect(given.tree).toMatchObject({
-        children: [expect.objectContaining({
-          name: "node1"
-        }), expect.objectContaining({
-          name: "new node"
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-  });
-  context("when moving after the root node", function () {
-    it("returns null", function () {
-      expect(given.tree.addAfter("new node")).toBeNull();
-    });
-    it("doesn't add anything", function () {
-      expect(given.tree).toMatchObject({
-        children: [expect.objectContaining({
-          name: "node1"
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-  });
-  context("when adding a node with children", function () {
-    it("adds the children", function () {
-      given.node1.addAfter({
-        name: "new node",
-        children: ["newchild1", "newchild2"]
-      });
-      expect(given.tree).toMatchObject({
-        children: [expect.objectContaining({
-          name: "node1"
-        }), expect.objectContaining({
-          name: "new node",
-          children: [expect.objectContaining({
-            name: "newchild1"
-          }), expect.objectContaining({
-            name: "newchild2"
-          })]
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-  });
-});
-describe("addBefore", function () {
-  var given = (0, _givens["default"])();
-  given("node2", function () {
-    return given.tree.getNodeByNameMustExist("node2");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  it("returns the new node", function () {
-    expect(given.node2.addBefore("new node")).toMatchObject({
-      name: "new node"
-    });
-  });
-  it("adds before the node", function () {
-    given.node2.addBefore("new node");
-    expect(given.tree).toMatchObject({
-      children: [expect.objectContaining({
-        name: "node1"
-      }), expect.objectContaining({
-        name: "new node"
-      }), expect.objectContaining({
-        name: "node2"
-      })]
-    });
-  });
-  context("with a root node", function () {
-    it("returns null", function () {
-      expect(given.tree.addBefore("new node")).toBeNull();
-    });
-    it("does nothing", function () {
-      given.tree.addBefore("new node");
-      expect(given.tree).toMatchObject({
-        children: [expect.objectContaining({
-          name: "node1"
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-  });
-  context("when adding a node with children", function () {
-    it("adds the children", function () {
-      given.node2.addBefore({
-        name: "new node",
-        children: ["newchild1", "newchild2"]
-      });
-      expect(given.tree).toMatchObject({
-        children: [expect.objectContaining({
-          name: "node1"
-        }), expect.objectContaining({
-          name: "new node",
-          children: [expect.objectContaining({
-            name: "newchild1"
-          }), expect.objectContaining({
-            name: "newchild2"
-          })]
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-  });
-});
-describe("addChild", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return new _node.Node();
-  });
-  beforeEach(function () {
-    given.node.addChild(new _node.Node({
-      id: 100,
-      name: "child1"
-    }));
-  });
-  it("adds the child", function () {
-    expect(given.node.children).toEqual(expect.arrayContaining([expect.objectContaining({
-      id: 100,
-      name: "child1"
-    })]));
-  });
-  it("sets the parent of the child", function () {
-    var _given$node$children$;
-    expect((_given$node$children$ = given.node.children[0]) === null || _given$node$children$ === void 0 ? void 0 : _given$node$children$.parent).toEqual(given.node);
-  });
-});
-describe("addChildAtPosition", function () {
-  var given = (0, _givens["default"])();
-  given("child", function () {
-    return new _node.Node("new");
-  });
-  given("node", function () {
-    return new _node.Node("new").loadFromData(["child1", "child2"]);
-  });
-  beforeEach(function () {
-    given.node.addChildAtPosition(given.child, given.index);
-  });
-  context("with index 0", function () {
-    given("index", function () {
-      return 0;
-    });
-    it("adds at the start", function () {
-      expect(given.node.children).toEqual([expect.objectContaining({
-        name: "new"
-      }), expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "child2"
-      })]);
-      expect(given.node.children).toEqual([expect.objectContaining({
-        name: "new"
-      }), expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "child2"
-      })]);
-    });
-  });
-  context("with index 1", function () {
-    given("index", function () {
-      return 1;
-    });
-    it("inserts at index 1", function () {
-      expect(given.node.children).toEqual([expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "new"
-      }), expect.objectContaining({
-        name: "child2"
-      })]);
-    });
-  });
-  context("with non existing index", function () {
-    given("index", function () {
-      return 99;
-    });
-    it("adds add the end", function () {
-      expect(given.node.children).toEqual([expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "child2"
-      }), expect.objectContaining({
-        name: "new"
-      })]);
-    });
-  });
-});
-describe("addParent", function () {
-  var given = (0, _givens["default"])();
-  given("node1", function () {
-    return new _node.Node("node1");
-  });
-  given("tree", function () {
-    return new _node.Node({}, true);
-  });
-  beforeEach(function () {
-    given.tree.addChild(given.node1);
-    given.node1.append("child1");
-  });
-  it("adds a parent node", function () {
-    given.node1.addParent("parent1");
-    expect(given.tree).toMatchObject({
-      name: "",
-      children: [expect.objectContaining({
-        name: "parent1",
-        children: [expect.objectContaining({
-          name: "node1",
-          children: [expect.objectContaining({
-            name: "child1"
-          })]
-        })]
-      })]
-    });
-  });
-  it("returns the new node", function () {
-    expect(given.node1.addParent("parent1")).toMatchObject({
-      name: "parent1"
-    });
-  });
-  context("with a root node", function () {
-    it("returns null", function () {
-      expect(given.tree.addParent("parent1")).toBeNull();
-    });
-  });
-});
-describe("append", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return new _node.Node("node1");
-  });
-  it("appends a node", function () {
-    given.node.append("child1");
-    given.node.append("child2");
-    expect(given.node).toMatchObject({
-      name: "node1",
-      children: [expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "child2"
-      })]
-    });
-  });
-  it("returns the new node", function () {
-    expect(given.node.append("child1")).toMatchObject({
-      name: "child1"
-    });
-  });
-  context("when adding a node with children", function () {
-    it("adds the children", function () {
-      given.node.append({
-        name: "new node",
-        children: ["newchild1", "newchild2"]
-      });
-      expect(given.node).toMatchObject({
-        children: [expect.objectContaining({
-          name: "new node",
-          children: [expect.objectContaining({
-            name: "newchild1"
-          }), expect.objectContaining({
-            name: "newchild2"
-          })]
-        })]
-      });
-    });
-  });
-});
-describe("constructor", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return given.params === undefined ? new _node.Node() : new _node.Node(given.params);
-  });
-  context("without parameters", function () {
-    it("creates a node", function () {
-      expect(given.node.name).toBe("");
-      expect(given.node.id).toBeUndefined();
-    });
-  });
-  context("with a string", function () {
-    given("params", function () {
-      return "n1";
-    });
-    it("creates a node", function () {
-      expect(given.node).toMatchObject({
-        name: "n1",
-        children: [],
-        parent: null
-      });
-      expect(given.node).not.toHaveProperty("id");
-    });
-    it("sets isEmptyFolder to false", function () {
-      expect(given.node.isEmptyFolder).toBe(false);
-    });
-  });
-  context("with an object with a name property", function () {
-    given("params", function () {
-      return {
-        id: 123,
-        name: "n1"
-      };
-    });
-    it("creates a node", function () {
-      expect(given.node).toMatchObject({
-        id: 123,
-        name: "n1"
-      });
-    });
-  });
-  context("when the name property is null", function () {
-    given("params", function () {
-      return {
-        name: null
-      };
-    });
-    it("sets the name to an empty string", function () {
-      expect(given.node.name).toBe("");
-    });
-  });
-  context("with an object with more properties", function () {
-    given("params", function () {
-      return {
-        color: "green",
-        id: 123,
-        name: "n1",
-        url: "/abc"
-      };
-    });
-    it("creates a node", function () {
-      expect(given.node).toMatchObject({
-        color: "green",
-        id: 123,
-        name: "n1",
-        url: "/abc"
-      });
-    });
-  });
-  context("with an object with a label property", function () {
-    given("params", function () {
-      return {
-        id: 123,
-        label: "n1",
-        url: "/"
-      };
-    });
-    it("creates a node", function () {
-      expect(given.node).toMatchObject({
-        id: 123,
-        name: "n1",
-        url: "/"
-      });
-      expect(given.node).not.toHaveProperty("label");
-      expect(given.node.children).toHaveLength(0);
-      expect(given.node.parent).toBeNull();
-    });
-  });
-  context("with an object with a parent", function () {
-    given("params", function () {
-      return {
-        name: "n1",
-        parent: "abc"
-      };
-    });
-    it("doesn't set the parent", function () {
-      expect(given.node.name).toBe("n1");
-      expect(given.node.parent).toBeNull();
-    });
-  });
-  context("with an object with children", function () {
-    given("params", function () {
-      return {
-        name: "n1",
-        children: ["c"]
-      };
-    });
-    it("doesn't set the children", function () {
-      expect(given.node.name).toBe("n1");
-      expect(given.node.children).toHaveLength(0);
-    });
-    it("sets isEmptyFolder to false", function () {
-      expect(given.node.isEmptyFolder).toBe(false);
-    });
-  });
-  context("when the data contains an empty children attribute", function () {
-    given("params", function () {
-      return {
-        name: "n1",
-        children: []
-      };
-    });
-    it("sets isEmptyFolder to true", function () {
-      expect(given.node.isEmptyFolder).toBe(true);
-    });
-  });
-});
-describe("getChildIndex", function () {
-  var given = (0, _givens["default"])();
-  given("child2", function () {
-    return new _node.Node("child2");
-  });
-  given("node", function () {
-    return new _node.Node();
-  });
-  beforeEach(function () {
-    given.node.addChild(new _node.Node("child1"));
-    given.node.addChild(given.child2);
-    given.node.addChild(new _node.Node("child3"));
-  });
-  context("when a child exists", function () {
-    it("returns the index", function () {
-      expect(given.node.getChildIndex(given.child2)).toBe(1);
-    });
-  });
-  context("when a child doesn't exist", function () {
-    it("returns -1", function () {
-      var nonExistingChild = new _node.Node("non-existing");
-      expect(given.node.getChildIndex(nonExistingChild)).toBe(-1);
-    });
-  });
-});
-describe("getData", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  it("returns the tree data", function () {
-    expect(given.tree.getData()).toEqual([expect.objectContaining({
-      name: "node1",
-      children: [expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "child2"
-      })]
-    }), expect.objectContaining({
-      name: "node2"
-    })]);
-  });
-  it("doesn't include internal attributes", function () {
-    expect(given.tree.getData()[0]).not.toContainAnyKeys(["element", "isEmptyFolder", "parent"]);
-  });
-  context("with includeParent parameter", function () {
-    it("returns the tree data including the node itself", function () {
-      expect(given.tree.getData(true)).toEqual([expect.objectContaining({
-        children: [expect.objectContaining({
-          name: "node1"
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      })]);
-    });
-  });
-});
-describe("getLastChild", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return new _node.Node();
-  });
-  context("when a node has no children", function () {
-    it("returns null", function () {
-      expect(given.node.getLastChild()).toBeNull();
-    });
-  });
-  context("when a node has children", function () {
-    beforeEach(function () {
-      given.node.append("child1");
-      given.node.append("child2");
-    });
-    it("returns the last child", function () {
-      expect(given.node.getLastChild()).toMatchObject({
-        name: "child2"
-      });
-    });
-    context("when its last child is open and has children", function () {
-      beforeEach(function () {
-        var child2 = given.node.children[1];
-        child2 === null || child2 === void 0 || child2.append("child2a");
-        child2 === null || child2 === void 0 || child2.append("child2b");
-      });
-      context("and the last child is open", function () {
-        beforeEach(function () {
-          var child2 = given.node.children[1];
-          if (child2) {
-            child2.is_open = true;
-          }
-        });
-        it("returns the last child of that child", function () {
-          expect(given.node.getLastChild()).toMatchObject({
-            name: "child2b"
-          });
-        });
-      });
-      context("and the last child is closed", function () {
-        it("returns the last child", function () {
-          expect(given.node.getLastChild()).toMatchObject({
-            name: "child2"
-          });
-        });
-      });
-    });
-  });
-});
-describe("getNextNode", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("with a parent node", function () {
-    given("fromNode", function () {
-      return given.tree.getNodeByNameMustExist("node1");
-    });
-    context("when the parent node is closed", function () {
-      it("returns the first child", function () {
-        expect(given.fromNode.getNextNode()).toMatchObject({
-          name: "child1"
-        });
-      });
-    });
-    context("when the parent node is open", function () {
-      beforeEach(function () {
-        given.fromNode.is_open = true;
-      });
-      it("returns the first child", function () {
-        expect(given.fromNode.getNextNode()).toMatchObject({
-          name: "child1"
-        });
-      });
-    });
-  });
-  context("with the node is the last child", function () {
-    given("fromNode", function () {
-      return given.tree.getNodeByNameMustExist("child2");
-    });
-    it("returns the next sibling of the parent", function () {
-      expect(given.fromNode.getNextNode()).toMatchObject({
-        name: "node2"
-      });
-    });
-  });
-  context("with includeChildren is false", function () {
-    context("with an open parent node", function () {
-      given("fromNode", function () {
-        return given.tree.getNodeByNameMustExist("node1");
-      });
-      beforeEach(function () {
-        given.fromNode.is_open = true;
-      });
-      it("returns the next sibling", function () {
-        expect(given.fromNode.getNextNode(false)).toMatchObject({
-          name: "node2"
-        });
-      });
-    });
-  });
-});
-describe("getNextVisibleNode", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("with a parent node", function () {
-    given("fromNode", function () {
-      return given.tree.getNodeByNameMustExist("node1");
-    });
-    context("when the parent node is closed", function () {
-      it("returns the next sibling", function () {
-        expect(given.fromNode.getNextVisibleNode()).toMatchObject({
-          name: "node2"
-        });
-      });
-    });
-    context("when the parent node is open", function () {
-      beforeEach(function () {
-        given.fromNode.is_open = true;
-      });
-      it("returns the first child", function () {
-        expect(given.fromNode.getNextVisibleNode()).toMatchObject({
-          name: "child1"
-        });
-      });
-    });
-  });
-  context("with the node is the last child", function () {
-    given("fromNode", function () {
-      return given.tree.getNodeByNameMustExist("child2");
-    });
-    it("returns the next sibling of the parent", function () {
-      expect(given.fromNode.getNextVisibleNode()).toMatchObject({
-        name: "node2"
-      });
-    });
-  });
-  context("with the tree node", function () {
-    given("fromNode", function () {
-      return given.tree;
-    });
-    it("returns null", function () {
-      expect(given.fromNode.getNextVisibleNode()).toBeNull();
-    });
-  });
-});
-describe("getNextSibling", function () {
-  var given = (0, _givens["default"])();
-  given("node1", function () {
-    return given.tree.getNodeByNameMustExist("node1");
-  });
-  given("node2", function () {
-    return given.tree.getNodeByNameMustExist("node2");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("with a tree", function () {
-    it("returns null", function () {
-      expect(given.tree.getNextSibling()).toBeNull();
-    });
-  });
-  context("when the node is the last child", function () {
-    it("returns null", function () {
-      expect(given.node2.getNextSibling()).toBeNull();
-    });
-  });
-  context("when the node is the first child", function () {
-    it("returns the second child", function () {
-      expect(given.node1.getNextSibling()).toBe(given.node2);
-    });
-  });
-});
-describe("getNodeByCallback", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("when a matching node exists", function () {
-    it("returns the node", function () {
-      expect(given.tree.getNodeByCallback(function (node) {
-        return node.name.startsWith("chi");
-      })).toMatchObject({
-        name: "child1"
-      });
-    });
-  });
-  context("when no matching node exists", function () {
-    it("returns null", function () {
-      expect(given.tree.getNodeByCallback(function () {
-        return false;
-      })).toBeNull();
-    });
-  });
-});
-describe("getNodeByName", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("when the node exists", function () {
-    it("returns the node", function () {
-      expect(given.tree.getNodeByName("child1")).toMatchObject({
-        id: 125,
-        name: "child1"
-      });
-    });
-  });
-  context("when the node doesn't exist", function () {
-    it("returns null", function () {
-      expect(given.tree.getNodeByName("non-existing")).toBeNull();
-    });
-  });
-});
-describe("getNodeByNameMustExist", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("when the node exists", function () {
-    it("returns the node", function () {
-      expect(given.tree.getNodeByNameMustExist("child1")).toMatchObject({
-        id: 125,
-        name: "child1"
-      });
-    });
-  });
-  context("when the node doesn't exist", function () {
-    it("throws an exception", function () {
-      expect(function () {
-        return given.tree.getNodeByNameMustExist("non-existing");
-      }).toThrow("Node with name non-existing not found");
-    });
-  });
-});
-describe("getParent", function () {
-  var given = (0, _givens["default"])();
-  given("child1", function () {
-    return given.tree.getNodeByNameMustExist("child1");
-  });
-  given("node1", function () {
-    return given.tree.getNodeByNameMustExist("node1");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("with a tree", function () {
-    it("returns null", function () {
-      expect(given.tree.getParent()).toBeNull();
-    });
-  });
-  context("with a node on the first level", function () {
-    it("returns null", function () {
-      expect(given.node1.getParent()).toBeNull();
-    });
-  });
-  context("with a node on the second level", function () {
-    it("returns the parent", function () {
-      expect(given.child1.getParent()).toMatchObject({
-        name: "node1"
-      });
-    });
-  });
-});
-describe("getPreviousNode", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  it("returns null with a tree node", function () {
-    expect(given.tree.getPreviousNode()).toBeNull();
-  });
-  it("returns the last child of the previous sibling when the previous node is closed and has children", function () {
-    given.tree.getNodeByNameMustExist("node2").is_open = false;
-    var node2 = given.tree.getNodeByNameMustExist("node2");
-    expect(node2.getPreviousNode()).toMatchObject({
-      name: "child2"
-    });
-  });
-  it("returns the last child of the previous sibling when the previous node is open and has children", function () {
-    given.tree.getNodeByNameMustExist("node2").is_open = true;
-    var node2 = given.tree.getNodeByNameMustExist("node2");
-    expect(node2.getPreviousNode()).toMatchObject({
-      name: "child2"
-    });
-  });
-  it("returns the first child if a node is the second child", function () {
-    var child2 = given.tree.getNodeByNameMustExist("child2");
-    expect(child2.getPreviousNode()).toMatchObject({
-      name: "child1"
-    });
-  });
-  it("returns the parent with a node that is the first child", function () {
-    var node3 = given.tree.getNodeByNameMustExist("node3");
-    expect(node3.getPreviousNode()).toMatchObject({
-      name: "node2"
-    });
-  });
-});
-describe("getPreviousVisibleNode", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  it("returns null with a tree node", function () {
-    expect(given.tree.getPreviousVisibleNode()).toBeNull();
-  });
-  it("returns the previous sibling when the previous sibling is closed and has children", function () {
-    given.tree.getNodeByNameMustExist("node2").is_open = false;
-    var node2 = given.tree.getNodeByNameMustExist("node2");
-    expect(node2.getPreviousVisibleNode()).toMatchObject({
-      name: "node1"
-    });
-  });
-  it("returns the last child of the previous sibling when the previous sibling is open and has children", function () {
-    given.tree.getNodeByNameMustExist("node1").is_open = true;
-    var node2 = given.tree.getNodeByNameMustExist("node2");
-    expect(node2.getPreviousVisibleNode()).toMatchObject({
-      name: "child2"
-    });
-  });
-  it("returns the first child if a node is the second child", function () {
-    var child2 = given.tree.getNodeByNameMustExist("child2");
-    expect(child2.getPreviousVisibleNode()).toMatchObject({
-      name: "child1"
-    });
-  });
-  it("returns the parent when a node is the first child", function () {
-    var node3 = given.tree.getNodeByNameMustExist("node3");
-    expect(node3.getPreviousVisibleNode()).toMatchObject({
-      name: "node2"
-    });
-  });
-});
-describe("getPreviousSibling", function () {
-  var given = (0, _givens["default"])();
-  given("node1", function () {
-    return given.tree.getNodeByNameMustExist("node1");
-  });
-  given("node2", function () {
-    return given.tree.getNodeByNameMustExist("node2");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("with a tree", function () {
-    it("returns null", function () {
-      expect(given.tree.getPreviousSibling()).toBeNull();
-    });
-  });
-  context("when the node is the first child", function () {
-    it("returns null", function () {
-      expect(given.node1.getPreviousSibling()).toBeNull();
-    });
-  });
-  context("when the node is the second child", function () {
-    it("returns the first child", function () {
-      expect(given.node2.getPreviousSibling()).toBe(given.node1);
-    });
-  });
-});
-describe("hasChildren", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return new _node.Node();
-  });
-  context("when a node has children", function () {
-    beforeEach(function () {
-      given.node.addChild(new _node.Node("child1"));
-    });
-    it("returns true", function () {
-      expect(given.node.hasChildren()).toBe(true);
-    });
-  });
-  context("when a node doesn't have children", function () {
-    it("returns false", function () {
-      expect(given.node.hasChildren()).toBe(false);
-    });
-  });
-});
-describe("initFromData", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node();
-  });
-  beforeEach(function () {
-    given.tree.initFromData({
-      name: "node1",
-      id: 1,
-      children: [{
-        name: "child1",
-        id: 2
-      }, {
-        name: "child2",
-        id: 3
-      }]
-    });
-  });
-  it("loads the data", function () {
-    expect(given.tree).toMatchObject({
-      id: 1,
-      name: "node1",
-      children: [expect.objectContaining({
-        id: 2,
-        name: "child1"
-      }), expect.objectContaining({
-        id: 3,
-        name: "child2"
-      })]
-    });
-  });
-});
-describe("isFolder", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return new _node.Node();
-  });
-  context("when the node has no children", function () {
-    it("returns false", function () {
-      expect(given.node.isFolder()).toBe(false);
-    });
-    context("when the node is loaded on demand", function () {
-      beforeEach(function () {
-        given.node.load_on_demand = true;
-      });
-      it("returns false", function () {
-        expect(given.node.isFolder()).toBe(true);
-      });
-    });
-  });
-  context("when the node has a child", function () {
-    beforeEach(function () {
-      given.node.append("child1");
-    });
-    it("returns false", function () {
-      expect(given.node.isFolder()).toBe(true);
-    });
-  });
-});
-describe("iterate", function () {
-  var given = (0, _givens["default"])();
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  given("visited", function () {
-    return [];
-  });
-  beforeEach(function () {
-    given.tree.iterate(given.visitor);
-  });
-  context("when the visitor function returns true", function () {
-    var visitAllNodes = function visitAllNodes(node, level) {
-      given.visited.push([node.name, level]);
-      return true;
-    };
-    given("visitor", function () {
-      return visitAllNodes;
-    });
-    it("visits all nodes", function () {
-      expect(given.visited).toEqual([["node1", 0], ["child1", 1], ["child2", 1], ["node2", 0], ["node3", 1], ["child3", 2]]);
-    });
-  });
-  context("when the visitor function returns false", function () {
-    var visitNodes = function visitNodes(node, level) {
-      given.visited.push([node.name, level]);
-      return false;
-    };
-    given("visitor", function () {
-      return visitNodes;
-    });
-    it("stops the iteration for the current node", function () {
-      expect(given.visited).toEqual([["node1", 0], ["node2", 0]]);
-    });
-  });
-});
-describe("loadFromData", function () {
-  it("creates a tree", function () {
-    var tree = new _node.Node().loadFromData(_exampleData["default"]);
-    expect(tree.children).toEqual([expect.objectContaining({
-      id: 123,
-      intProperty: 1,
-      name: "node1",
-      strProperty: "1",
-      children: [expect.objectContaining({
-        id: 125,
-        name: "child1"
-      }), expect.objectContaining({
-        id: 126,
-        name: "child2"
-      })]
-    }), expect.objectContaining({
-      id: 124,
-      intProperty: 3,
-      name: "node2",
-      strProperty: "3",
-      children: [expect.objectContaining({
-        id: 127,
-        name: "node3"
-      })]
-    })]);
-  });
-  it("sets isEmptyFolder to true for a node when it is has an empty children attribute", function () {
-    var data = [{
-      name: "test1",
-      children: []
-    }];
-    var tree = new _node.Node().loadFromData(data);
-    expect(tree.children[0].isEmptyFolder).toBe(true);
-  });
-  it("sets isEmptyFolder to false for a node when it doesn't have a children attribute", function () {
-    var data = [{
-      name: "test1"
-    }];
-    var tree = new _node.Node().loadFromData(data);
-    expect(tree.children[0].isEmptyFolder).toBe(false);
-  });
-  it("sets isEmptyFolder to false for a node when it has a children attribute that is not empty", function () {
-    var data = [{
-      name: "test1",
-      children: ["child1"]
-    }];
-    var tree = new _node.Node().loadFromData(data);
-    expect(tree.children[0].isEmptyFolder).toBe(false);
-  });
-});
-describe("moveNode", function () {
-  var given = (0, _givens["default"])();
-  given("child1", function () {
-    return given.tree.getNodeByNameMustExist("child1");
-  });
-  given("child2", function () {
-    return given.tree.getNodeByNameMustExist("child2");
-  });
-  given("node1", function () {
-    return given.tree.getNodeByNameMustExist("node1");
-  });
-  given("node2", function () {
-    return given.tree.getNodeByNameMustExist("node2");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  context("when moving after a node", function () {
-    it("moves the node", function () {
-      expect(given.tree.moveNode(given.child2, given.node2, _node.Position.After)).toBe(true);
-      expect(given.tree).toMatchObject({
-        name: "",
-        children: [expect.objectContaining({
-          name: "node1",
-          children: [expect.objectContaining({
-            name: "child1"
-          })]
-        }), expect.objectContaining({
-          name: "node2"
-        }), expect.objectContaining({
-          name: "child2"
-        })]
-      });
-    });
-    context("when the target is the root node", function () {
-      it("returns false", function () {
-        expect(given.tree.moveNode(given.child2, given.tree, _node.Position.After)).toBe(false);
-      });
-    });
-  });
-  context("when moving inside a node", function () {
-    it("moves the node", function () {
-      expect(given.tree.moveNode(given.child1, given.node2, _node.Position.Inside)).toBe(true);
-      expect(given.tree).toMatchObject({
-        name: "",
-        children: [expect.objectContaining({
-          name: "node1",
-          children: [expect.objectContaining({
-            name: "child2"
-          })]
-        }), expect.objectContaining({
-          name: "node2",
-          children: [expect.objectContaining({
-            name: "child1"
-          }), expect.objectContaining({
-            name: "node3"
-          })]
-        })]
-      });
-    });
-  });
-  context("when moving before a node", function () {
-    it("moves the node", function () {
-      expect(given.tree.moveNode(given.child2, given.child1, _node.Position.Before)).toBe(true);
-      expect(given.tree).toMatchObject({
-        name: "",
-        children: [expect.objectContaining({
-          name: "node1",
-          children: [expect.objectContaining({
-            name: "child2"
-          }), expect.objectContaining({
-            name: "child1"
-          })]
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-    context("when the target is the root node", function () {
-      it("returns false", function () {
-        expect(given.tree.moveNode(given.child2, given.tree, _node.Position.Before)).toBe(false);
-      });
-    });
-  });
-  context("when the moved node is a parent of the target node", function () {
-    it("doesn't move the node", function () {
-      expect(given.tree.moveNode(given.node1, given.child1, _node.Position.Before)).toBe(false);
-      expect(given.tree).toMatchObject({
-        children: [expect.objectContaining({
-          name: "node1",
-          children: [expect.objectContaining({
-            name: "child1"
-          }), expect.objectContaining({
-            name: "child2"
-          })]
-        }), expect.objectContaining({
-          name: "node2"
-        })]
-      });
-    });
-  });
-  context("with position None", function () {
-    it("returns false", function () {
-      expect(given.tree.moveNode(given.child2, given.node2, _node.Position.None)).toBe(false);
-    });
-  });
-});
-describe("prepend", function () {
-  var given = (0, _givens["default"])();
-  given("node", function () {
-    return new _node.Node("node1");
-  });
-  it("prepends a node", function () {
-    given.node.prepend("child2");
-    given.node.prepend("child1");
-    expect(given.node).toMatchObject({
-      name: "node1",
-      children: [expect.objectContaining({
-        name: "child1"
-      }), expect.objectContaining({
-        name: "child2"
-      })]
-    });
-  });
-  context("when prepending a node with children", function () {
-    it("adds the children", function () {
-      given.node.prepend({
-        name: "new node",
-        children: ["newchild1", "newchild2"]
-      });
-      expect(given.node).toMatchObject({
-        children: [expect.objectContaining({
-          name: "new node",
-          children: [expect.objectContaining({
-            name: "newchild1"
-          }), expect.objectContaining({
-            name: "newchild2"
-          })]
-        })]
-      });
-    });
-  });
-  it("sets the isEmptyFolder attribute to true when the node data has empty children", function () {
-    given.node.prepend({
-      name: "test1",
-      children: []
-    });
-    expect(given.node.children[0].isEmptyFolder).toBe(true);
-  });
-});
-describe("remove", function () {
-  var given = (0, _givens["default"])();
-  given("child1", function () {
-    return given.tree.getNodeByNameMustExist("child1");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  beforeEach(function () {
-    given.child1.remove();
-  });
-  it("removes the node", function () {
-    expect(given.tree).toMatchObject({
-      children: [expect.objectContaining({
-        name: "node1",
-        children: [expect.objectContaining({
-          name: "child2"
-        })]
-      }), expect.objectContaining({
-        name: "node2"
-      })]
-    });
-  });
-});
-describe("removeChild", function () {
-  var given = (0, _givens["default"])();
-  given("child1", function () {
-    return given.tree.getNodeByNameMustExist("child1");
-  });
-  given("node1", function () {
-    return given.tree.getNodeByNameMustExist("node1");
-  });
-  given("tree", function () {
-    return new _node.Node().loadFromData(_exampleData["default"]);
-  });
-  beforeEach(function () {
-    given.node1.removeChild(given.child1);
-  });
-  it("removes the child", function () {
-    expect(given.node1.children).toEqual([expect.objectContaining({
-      name: "child2"
-    })]);
-  });
-});