diff --git a/cosmoz-default-tree.html b/cosmoz-default-tree.html
new file mode 100644
index 0000000..7458c72
--- /dev/null
+++ b/cosmoz-default-tree.html
@@ -0,0 +1,156 @@
+<link rel="import" href="cosmoz-tree.html">
+<script>
+	'use strict';
+
+	window.Cosmoz = window.Cosmoz || {};
+
+	function _objectValues(obj) {
+		return Object.keys(obj).map(function (key) {
+			return obj[key];
+		});
+	}
+
+	/**
+	 * Cosmoz.DefaultTree
+	 *
+	 * @constructor
+	 */
+	Cosmoz.DefaultTree = function (treeData) {
+		Cosmoz.Tree.apply(this, arguments);
+		this._treeData = treeData;
+		this._roots = _objectValues(treeData);
+	};
+
+	Cosmoz.DefaultTree.prototype = Object.create(Cosmoz.Tree.prototype);
+
+	Cosmoz.DefaultTree.prototype.getNodeByProperty = function (propertyName, propertyValue) {
+		if (propertyName === undefined || propertyValue === undefined) {
+			return;
+		}
+
+		if (propertyName === 'pathLocator') {
+			return this._getNodeByPathLocator(propertyValue);
+		}
+
+		return this._searchAllRoots(propertyName, propertyValue);
+	};
+
+	Cosmoz.DefaultTree.prototype.getPath = function (node) {
+		if (node === undefined) {
+			return;
+		}
+		return this._getPathByPathLocator(node.pathLocator);
+	};
+
+	Cosmoz.DefaultTree.prototype.getPathByProperty = function (propertyName, propertyValue) {
+		if (propertyName === undefined || propertyValue === undefined) {
+			return;
+		}
+
+		if (propertyName === 'pathLocator') {
+			return this._getPathByPathLocator(propertyValue);
+		}
+
+		var node = this._searchAllRoots(propertyName, propertyValue);
+		if (node !== undefined) {
+			return this._getPathByPathLocator(node.pathLocator);
+		}
+	};
+
+	Cosmoz.DefaultTree.prototype.getChildren = function (node) {
+		if (node === undefined) {
+			return;
+		}
+		return _objectValues(node.children);
+	};
+
+	Cosmoz.DefaultTree.prototype.getProperty = function (node, propertyName) {
+		if (node === undefined || propertyName === undefined) {
+			return;
+		}
+
+		return node[propertyName];
+	};
+
+	Cosmoz.DefaultTree.prototype._searchAllRoots = function (propertyName, propertyValue) {
+		var i,
+			node;
+
+		for (i = 0; i < this._roots.length; i+=1) {
+			node = this.search(this._roots[i], propertyName, propertyValue);
+			if (node !== undefined) {
+				return node;
+			}
+		}
+	};
+
+	Cosmoz.DefaultTree.prototype._getNodeByPathLocator = function (pathLocator) {
+		var	node,
+			path,
+			i;
+
+		for (i = 0; i < this._roots.length; i+=1) {
+			node = this._roots[i];
+			if (node.pathLocator === pathLocator) {
+				return node;
+			}
+
+			if (pathLocator.indexOf(node.pathLocator + '.') === 0) {
+				path = pathLocator.slice(node.pathLocator.length + 1).split('.');
+				for (i = 0; i < path.length; i+=1) {
+					if (node.children) {
+						node = node.children[path[i]];
+					} else {
+						node = null;
+					}
+					if (node === undefined ||  node === null) {
+						break;
+					}
+				}
+
+				if (node !== undefined && node !== null) {
+					return node;
+				}
+			}
+		}
+	};
+
+	Cosmoz.DefaultTree.prototype._getPathByPathLocator = function (pathLocator) {
+		var	node,
+			path,
+			subPath,
+			i;
+
+		for (i = 0; i < this._roots.length; i+=1) {
+			node = this._roots[i];
+			path = [node];
+
+			if (node.pathLocator === pathLocator) {
+				return path;
+			}
+
+			if (pathLocator.indexOf(node.pathLocator + '.') === 0) {
+				subPath = pathLocator.slice(node.pathLocator.length + 1).split('.');
+				for (i = 0; i < subPath.length; i+=1) {
+					if (node.children) {
+						node = node.children[subPath[i]];
+					} else {
+						node = null;
+					}
+					if (node === undefined ||  node === null) {
+						path = null;
+						break;
+					} else {
+						path.push(node);
+					}
+				}
+
+				if (path !== null) {
+					return path;
+				}
+			}
+		}
+	};
+
+
+</script>
diff --git a/cosmoz-tree.html b/cosmoz-tree.html
index 3244e67..f685429 100644
--- a/cosmoz-tree.html
+++ b/cosmoz-tree.html
@@ -1,123 +1,77 @@
 <script>
 	'use strict';
 
-	if (typeof Cosmoz === 'undefined') {
-		var Cosmoz = {};
-	}
+	window.Cosmoz = window.Cosmoz || {};
+
+
+	/* eslint-disable no-unused-vars */
 
 	/**
+	 * Cosmoz.Tree
 	 *
 	 * @constructor
 	 */
-	Cosmoz.Tree = function (node) {
-		this._node = node;
-		this._flattenedTree = this._flattenTree(node);
-		this._pathLocatorSeparator = '.';
+	Cosmoz.Tree = function () {
+		if (this.constructor === Cosmoz.Tree) {
+			throw new Error('abstract');
+		}
 	};
 
 	Cosmoz.Tree.prototype = {
-
-		constructor: Cosmoz.Tree,
-
-		findNodeById: function (id) {
-			return this._flattenedTree[id];
+		getNodeByProperty: function (propertyName, propertyValue) {
+			throw new Error('Must be implemented in derived object');
 		},
 
-		findNodeByPathLocator: function (pathLocator) {
-			if (!pathLocator) {
-				return;
-			}
-			return pathLocator
-				.split(this._pathLocatorSeparator)
-				.reduce(function (node, part) {
-					if (node.children) {
-						node = node.children;
-					}
-					if (node[part]) {
-						node = node[part];
-					}
-					return node;
-				}, this._node);
+		getPath: function (node) {
+			throw new Error('Must be implemented in derived object');
 		},
 
-		getPath: function (keyId) {
-			if (this.isGuid(keyId)) {
-				return this.getPathByNodeId(keyId);
-			}
-			return this.getPathByLocator(keyId);
+		getPathByProperty: function (propertyName, propertyValue) {
+			throw new Error('Must be implemented in derived object');
 		},
 
-		getPathByNode: function (node) {
-			if (!node || !node.pathLocator) {
-				return;
-			}
-			var currentNode = this._node;
-			return node.pathLocator
-				.split(this._pathLocatorSeparator)
-				.map(function (part) {
-					var ret = currentNode;
-					if (currentNode.children && currentNode.children[part]) {
-						currentNode = currentNode.children[part];
-					}
-					if (currentNode[part]) {
-						currentNode = currentNode[part];
-					}
-					if (ret === currentNode) {
-						return;
-					}
-					return currentNode;
-				})
-				.filter(function (part) {
-					return part !== undefined;
-				});
+		getChildren: function (node) {
+			throw new Error('Must be implemented in derived object');
 		},
 
-		getPathByNodeId: function (nodeId) {
-			var node = this.findNodeById(nodeId);
-			return this.getPathByNode(node);
+		getProperty: function (node, propertyName) {
+			throw new Error('Must be implemented in derived object');
 		},
 
-		getPathByLocator: function (locator) {
-			var node = this.findNodeByPathLocator(locator);
-			return this.getPathByNode(node);
+		getPathString: function (node, textPropertyName, separator) {
+			var path = this.getPath(node);
+			return path.map(function (n) {
+				return this.getProperty(n, textPropertyName);
+			}, this).join(separator);
 		},
 
-		getPathString: function (path, separator) {
-			if (!path || !Array.isArray(path) || path.length < 1) {
-				return;
+		getPathStringByProperty: function (propertyName, propertyValue, textPropertyName, separator) {
+			var node = this.getNodeByProperty(propertyName, propertyValue);
+			if (node !== undefined) {
+				return this.getPathString(node, textPropertyName, separator);
 			}
-			return path.map(function (part) {
-				return part.name;
-			}).join(separator);
-		},
-
-		isGuid: function (input) {  // FIXME: GUID Check
-			return input && input.length === 36;
 		},
 
 		/**
-		 * Utility function to flatten the tree to ease node lookup.
+		 * Basic search for a node by one of its property
 		 */
-		_flattenTree: function (tree, flattened) {
-			if (!flattened) {
-				flattened = {};
-			}
-
-			if (tree === undefined) {
-				return flattened;
+		search: function (node, propertyName, propertyValue) {
+			if (this.getProperty(node, propertyName) === propertyValue) {
+				return node;
 			}
 
-			Object.keys(tree).forEach(function (key) {
-				var node = tree[key];
-				flattened[node.id] = node;
+			var children = this.getChildren(node),
+				i = 0,
+				n;
 
-				if (node.children && Object.keys(node.children).length > 0) {
-					this._flattenTree(node.children, flattened);
+			if (children) {
+				for (i = 0; i < children.length; i+=1) {
+					n = this.search(children[i], propertyName, propertyValue);
+					if (n !== undefined) {
+						return n;
+					}
 				}
-
-			}, this);
-
-			return flattened;
-		},
+			}
+		}
 	};
-</script>
\ No newline at end of file
+</script>
diff --git a/test/cosmoz-tree_test.html b/test/cosmoz-tree_test.html
index 35a5ae1..5a646fd 100644
--- a/test/cosmoz-tree_test.html
+++ b/test/cosmoz-tree_test.html
@@ -1,38 +1,219 @@
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, minimum-scale=1, initial-scale=1, user-scalable=yes">
-
-    <title>cosmoz-tree test</title>
-
-    <script src="../../webcomponentsjs/webcomponents-lite.js"></script>
-    <script src="../../web-component-tester/browser.js"></script>
-
-    <link rel="import" href="../cosmoz-tree.html">
-  </head>
-  <body>
-    <test-fixture id="basic">
-      <template>
-      </template>
-    </test-fixture>
-
-    <script>
-      suite('cosmoz-tree', function() {
-				var nodes;
-				setup(function () {
-					nodes = {
-						1: {
-							name: 'root',
-							pathLocator: '1'
-						}
-					}
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, minimum-scale=1, initial-scale=1, user-scalable=yes">
+
+	<title>cosmoz-tree test</title>
+
+	<script src="../../webcomponentsjs/webcomponents-lite.js"></script>
+	<script src="../../web-component-tester/browser.js"></script>
+
+	<link rel="import" href="../cosmoz-default-tree.html">
+	<link rel="import" href="../../iron-ajax/iron-ajax.html">
+</head>
+<body>
+	<test-fixture id="basic">
+		<template>
+			<iron-ajax auto
+				url="data/basicTree.json"
+				handle-as="json"
+				last-response="{{ basicTree }}">
+			</iron-ajax>
+		</template>
+	</test-fixture>
+
+	<test-fixture id="multiRoot">
+		<template>
+			<iron-ajax auto
+				url="data/multiRootTree.json"
+				handle-as="json"
+				last-response="{{ multiRootTree }}">
+			</iron-ajax>
+		</template>
+	</test-fixture>
+
+	<test-fixture id="missingAncestor">
+		<template>
+			<iron-ajax auto
+				url="data/missingAncestorTree.json"
+				handle-as="json"
+				last-response="{{ missingAncestorTree }}">
+			</iron-ajax>
+		</template>
+	</test-fixture>
+
+	<script>
+	/*global WCT, suite, fixture, setup, suiteSetup, test, Polymer, assert */
+	(function () {
+		'use strict';
+		suite('basic', function () {
+			var basicFixture,
+				basicTree;
+
+			suiteSetup(function (done) {
+				basicFixture = fixture('basic');
+				basicFixture.addEventListener('response', function () {
+					basicTree = new Cosmoz.DefaultTree(basicFixture.lastResponse);
+					done();
+				});
+			});
+
+			test('instantiating a Cosmoz.Tree works', function () {
+				assert.isNotNull(basicTree);
+			});
+
+			test('getNodeById', function () {
+				var
+					root = basicTree.getNodeByProperty('id', '11111111-1111-1111-1111-111111111111'),
+					node2 = basicTree.getNodeByProperty('id', '167d1485-7d4f-4c7d-86cd-a4fb00f31245'),
+					node3 = basicTree.getNodeByProperty('id', '3a7654f1-e3e6-49c7-b6a8-a4fb00f31245'),
+					node4 = basicTree.getNodeByProperty('id', '2b547550-b874-4228-9395-a4fb00f31245');
+				assert.isNotNull(root);
+				assert.isNotNull(node2);
+				assert.isNotNull(node3);
+				assert.isNotNull(node4);
+			});
+			test('getNodeByPathLocator', function () {
+				var
+					root = basicTree.getNodeByProperty('pathLocator', '1'),
+					node2 = basicTree.getNodeByProperty('pathLocator', '1.2'),
+					node3 = basicTree.getNodeByProperty('pathLocatord', '1.2.3'),
+					node4 = basicTree.getNodeByProperty('pathLocator', '1.2.3.301');
+				assert.isNotNull(root);
+				assert.isNotNull(node2);
+				assert.isNotNull(node3);
+				assert.isNotNull(node4);
+			});
+
+			test('getPath', function () {
+				var
+					root = basicTree.getNodeByProperty('id', '11111111-1111-1111-1111-111111111111'),
+					node2 = basicTree.getNodeByProperty('id', '167d1485-7d4f-4c7d-86cd-a4fb00f31245'),
+					node3 = basicTree.getNodeByProperty('id', '3a7654f1-e3e6-49c7-b6a8-a4fb00f31245'),
+					node4 = basicTree.getNodeByProperty('id', '2b547550-b874-4228-9395-a4fb00f31245'),
+					rootPath = basicTree.getPath(root),
+					node2Path = basicTree.getPath(node2),
+					node3Path = basicTree.getPath(node3),
+					node4Path = basicTree.getPath(node4);
+
+				assert.equal(rootPath.length, 1);
+				assert.equal(rootPath[0], root);
+
+				assert.equal(node2Path.length, 2);
+				assert.equal(node2Path[0], root);
+				assert.equal(node2Path[1], node2);
+
+				assert.equal(node3Path.length, 3);
+				assert.equal(node3Path[0], root);
+				assert.equal(node3Path[1], node2);
+				assert.equal(node3Path[2], node3);
+
+				assert.equal(node4Path.length, 2);
+				assert.equal(node4Path[0], root);
+				assert.equal(node4Path[1], node4);
+
+			});
+
+			test('getPathString', function () {
+				var	node301 = basicTree.getNodeByProperty('pathLocator', '1.2.3.301'),
+					node301PathString = basicTree.getPathString(node301, 'name', '/');
+
+				assert.equal(node301PathString, 'Root/Node2/Node3/Node301');
+			});
+		});
+
+		suite('multiRoot', function () {
+			var multiRootFixture,
+				multiRootTree;
+
+			suiteSetup(function (done) {
+				multiRootFixture = fixture('multiRoot');
+				multiRootFixture.addEventListener('response', function () {
+					multiRootTree = new Cosmoz.DefaultTree(multiRootFixture.lastResponse);
+					done();
 				});
-        test('instantiating a Cosmoz.Tree works', function() {
-					var tree = new Cosmoz.Tree(nodes)
-					assert.isNotNull(tree);
-        });
-      });
-    </script>
+			});
+
+			test('instantiating a Cosmoz.Tree works', function () {
+				assert.isNotNull(multiRootTree);
+			});
+
+			test('getNodeByProperty', function () {
+				var node2 = multiRootTree.getNodeByProperty('id', '167d1485-7d4f-4c7d-86cd-a4fb00f31245'),
+					node3 = multiRootTree.getNodeByProperty('id', '3a7654f1-e3e6-49c7-b6a8-a4fb00f31245'),
+					node4 = multiRootTree.getNodeByProperty('id', '2b547550-b874-4228-9395-a4fb00f31245');
+				assert.isNotNull(node2);
+				assert.isNotNull(node3);
+				assert.isNotNull(node4);
+
+			});
+
+			test('getPath', function () {
+				var
+					node2 = multiRootTree.getNodeByProperty('id', '167d1485-7d4f-4c7d-86cd-a4fb00f31245'),
+					node3 = multiRootTree.getNodeByProperty('id', '3a7654f1-e3e6-49c7-b6a8-a4fb00f31245'),
+					node4 = multiRootTree.getNodeByProperty('id', '2b547550-b874-4228-9395-a4fb00f31245'),
+					node2Path = multiRootTree.getPath(node2),
+					node3Path = multiRootTree.getPath(node3),
+					node4Path = multiRootTree.getPath(node4);
+
+				assert.equal(node2Path.length, 1);
+				assert.equal(node2Path[0], node2);
+
+				assert.equal(node3Path.length, 2);
+				assert.equal(node3Path[0], node2);
+				assert.equal(node3Path[1], node3);
+
+				assert.equal(node4Path.length, 1);
+				assert.equal(node4Path[0], node4);
+
+			});
+		});
+
+		suite('missingAncestor', function () {
+			var missingAncestorFixture,
+				missingAncestorTree;
+
+			suiteSetup(function (done) {
+				missingAncestorFixture = fixture('missingAncestor');
+				missingAncestorFixture.addEventListener('response', function () {
+					missingAncestorTree = new Cosmoz.DefaultTree(missingAncestorFixture.lastResponse);
+					done();
+				});
+			});
+
+			test('instantiating a Cosmoz.Tree works', function () {
+				assert.isNotNull(missingAncestorTree);
+			});
+
+			test('getNodeByProperty', function () {
+				var node2 = missingAncestorTree.getNodeByProperty('id', '167d1485-7d4f-4c7d-86cd-a4fb00f31245'),
+					node301 = missingAncestorTree.getNodeByProperty('id', '3a7654f1-e3e6-49c7-b6a8-a4fb00f31245'),
+					node401 = missingAncestorTree.getNodeByProperty('id', '865065da-f44c-472e-a8df-a4fb00f3124b');
+				assert.isNotNull(node2);
+				assert.isNotNull(node301);
+				assert.isNotNull(node401);
+
+			});
+
+			test('getPath', function () {
+				var
+					node301 = missingAncestorTree.getNodeByProperty('id', '3a7654f1-e3e6-49c7-b6a8-a4fb00f31245'),
+					node401 = missingAncestorTree.getNodeByProperty('id', '865065da-f44c-472e-a8df-a4fb00f3124b'),
+					node301Path = missingAncestorTree.getPath(node301),
+					node401Path = missingAncestorTree.getPath(node401);
+
+				assert.equal(node301Path.length, 1);
+				assert.equal(node301Path[0], node301);
+
+				assert.equal(node401Path.length, 2);
+				assert.equal(node401Path[0], node301);
+				assert.equal(node401Path[1], node401);
+
+			});
+		});
+	}());
+	</script>
   </body>
 </html>
diff --git a/test/data/basicTree.json b/test/data/basicTree.json
new file mode 100644
index 0000000..9b19399
--- /dev/null
+++ b/test/data/basicTree.json
@@ -0,0 +1,38 @@
+{
+	"1": {
+		"id": "11111111-1111-1111-1111-111111111111",
+		"name": "Root",
+		"pathLocator": "1",
+		"children": {
+			"2": {
+				"id": "167d1485-7d4f-4c7d-86cd-a4fb00f31245",
+				"name": "Node2",
+				"pathLocator": "1.2",
+				"children": {
+                    "3": {
+                        "id": "3a7654f1-e3e6-49c7-b6a8-a4fb00f31245",
+                        "name": "Node3",
+                        "pathLocator": "1.2.3",
+                        "children": {
+                            "301": {
+                                "id": "3a7654f1-e3e6-49c7-b6a8-a4fb00f31245",
+                                "name": "Node301",
+                                "pathLocator": "1.2.3.301",
+                                "children": {
+
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "4": {
+				"id": "2b547550-b874-4228-9395-a4fb00f31245",
+				"name": "Node4",
+				"pathLocator": "1.4",
+				"children": {}
+            }
+        }
+    }
+}
+
diff --git a/test/data/missingAncestorTree.json b/test/data/missingAncestorTree.json
new file mode 100644
index 0000000..a35104f
--- /dev/null
+++ b/test/data/missingAncestorTree.json
@@ -0,0 +1,24 @@
+{
+    "2": {
+        "id": "167d1485-7d4f-4c7d-86cd-a4fb00f31245",
+        "name": "Node2",
+        "pathLocator": "1.2",
+        "children": {}
+    },
+
+    "301": {
+        "id": "3a7654f1-e3e6-49c7-b6a8-a4fb00f31245",
+        "name": "Node301",
+        "pathLocator": "1.2.3.301",
+        "children": {
+            "401": {
+                "id": "865065da-f44c-472e-a8df-a4fb00f3124b",
+                "name": "Node401",
+                "pathLocator": "1.2.3.301.401",
+                "children": {
+                }
+
+            }
+        }
+    }
+}
diff --git a/test/data/multiRootTree.json b/test/data/multiRootTree.json
new file mode 100644
index 0000000..6e0f355
--- /dev/null
+++ b/test/data/multiRootTree.json
@@ -0,0 +1,22 @@
+{
+
+	"2": {
+        "id": "167d1485-7d4f-4c7d-86cd-a4fb00f31245",
+        "name": "Node2",
+        "pathLocator": "1.2",
+        "children": {
+            "3": {
+                "id": "3a7654f1-e3e6-49c7-b6a8-a4fb00f31245",
+                "name": "Node3",
+                "pathLocator": "1.2.3",
+                "children": {}
+            }
+        }
+    },
+    "4": {
+        "id": "2b547550-b874-4228-9395-a4fb00f31245",
+        "name": "Node4",
+        "pathLocator": "1.4",
+        "children": {}
+    }
+}
diff --git a/test/index.html b/test/index.html
new file mode 100644
index 0000000..b8a6654
--- /dev/null
+++ b/test/index.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<html>
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
+	<title>cosmoz-bottom-bar tests</title>
+	<script src="../../webcomponentsjs/webcomponents-lite.js"></script>
+	<script src="../../web-component-tester/browser.js"></script>
+</head>
+<body>
+	<script>
+	/*global WCT*/
+		WCT.loadSuites([
+			'cosmoz-tree_test.html'
+		]);
+	</script>
+</body>
+</html>