jackrabbit-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mdue...@apache.org
Subject svn commit: r1243491 - in /jackrabbit/sandbox/jackrabbit-microkernel/src: main/java/org/apache/jackrabbit/state/ test/java/org/apache/jackrabbit/ test/java/org/apache/jackrabbit/state/
Date Mon, 13 Feb 2012 12:45:51 GMT
Author: mduerig
Date: Mon Feb 13 12:45:50 2012
New Revision: 1243491

URL: http://svn.apache.org/viewvc?rev=1243491&view=rev
Log:
Microkernel based prototype of JCR implementation (WIP)
- Minor refactorings/clean up

Modified:
    jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java
    jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java
    jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java
    jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java
    jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java

Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/NodeState.java Mon Feb 13 12:45:50 2012
@@ -160,7 +160,7 @@ public class NodeState {
     }
 
     public static NodeState getNodeState(Context sessionContext, Path path) {
-        NodeDelta delta = sessionContext.getTransientSpace().getNode(path);
+        NodeDelta delta = sessionContext.getTransientSpace().getNodeDelta(path);
         return delta == null ? null : getNodeState(sessionContext, delta);
     }
 

Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/main/java/org/apache/jackrabbit/state/TransientSpace.java Mon Feb 13 12:45:50 2012
@@ -87,11 +87,11 @@ public class TransientSpace {
 
     /**
      * @param path
-     * @return the node at the given {@code path}. The node is either a persisted node in the
+     * @return the node delta for the given {@code path}. This is either a persisted node in the
      * revision currently bound to this transient space or a transient node or {@code null}
-     * if no such node exists.
+     * if no such node delta exists.
      */
-    public NodeDelta getNode(Path path) {
+    public NodeDelta getNodeDelta(Path path) {
         return changeTree.getNode(path);
     }
 
@@ -121,6 +121,7 @@ public class TransientSpace {
      */
     public String refresh(boolean keepChanges) {
         if (!keepChanges) {
+            changeLog.clear();
             changeTree.clear();
         }
 

Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/RepositoryTest.java Mon Feb 13 12:45:50 2012
@@ -81,7 +81,7 @@ import static org.junit.Assert.fail;
 
 public class RepositoryTest {
     private static final String NODE_STATE_CACHE_SIZE = "65536";
-    private static final String URL = "fs:target/repository-test/repository";
+    private static final String URL = "fs:target/repository-test/repository;clean";
     // private static final String URL = "mem:";
 
     private static final String TEST_NODE = "test_node";

Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceFuzzTest.java Mon Feb 13 12:45:50 2012
@@ -161,7 +161,7 @@ public class TransientSpaceFuzzTest {
 
             @Override
             void apply(TransientSpace transientSpace) throws ItemExistsException {
-                transientSpace.getNode(parent).addNode(name);
+                transientSpace.getNodeDelta(parent).addNode(name);
             }
 
             @Override
@@ -184,7 +184,7 @@ public class TransientSpaceFuzzTest {
 
             @Override
             void apply(TransientSpace transientSpace) throws ItemNotFoundException {
-                transientSpace.getNode(path.getParent()).removeNode(path.getName());
+                transientSpace.getNodeDelta(path.getParent()).removeNode(path.getName());
             }
 
             @Override
@@ -210,7 +210,7 @@ public class TransientSpaceFuzzTest {
 
             @Override
             void apply(TransientSpace transientSpace) throws RepositoryException {
-                transientSpace.getNode(source.getParent()).moveNode(source.getName(), destination);
+                transientSpace.getNodeDelta(source.getParent()).moveNode(source.getName(), destination);
             }
 
             @Override
@@ -238,7 +238,7 @@ public class TransientSpaceFuzzTest {
 
             @Override
             void apply(TransientSpace transientSpace) throws RepositoryException {
-                transientSpace.getNode(parent).setValue(name, value);
+                transientSpace.getNodeDelta(parent).setValue(name, value);
             }
 
             @Override

Modified: jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java
URL: http://svn.apache.org/viewvc/jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java?rev=1243491&r1=1243490&r2=1243491&view=diff
==============================================================================
--- jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java (original)
+++ jackrabbit/sandbox/jackrabbit-microkernel/src/test/java/org/apache/jackrabbit/state/TransientSpaceTest.java Mon Feb 13 12:45:50 2012
@@ -55,87 +55,87 @@ public class TransientSpaceTest {
 
     @Test
     public void getNotExistingNode() {
-        assertNull(transientSpace.getNode(ROOT.concat("any")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("any")));
     }
     
     @Test
     public void addNode() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("added");
         
         Path addedPath = ROOT.concat("added");
-        NodeDelta added = transientSpace.getNode(addedPath);
+        NodeDelta added = transientSpace.getNodeDelta(addedPath);
         assertEquals(addedPath, added.getPath());
 
         transientSpace.save();
-        added = transientSpace.getNode(addedPath);
+        added = transientSpace.getNodeDelta(addedPath);
         assertEquals(addedPath, added.getPath());
     }
 
     @Test
     public void addNodes() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a").addNode("b").addNode("c");
         transientSpace.save();
 
-        NodeDelta c = transientSpace.getNode(ROOT.concat("a/b/c"));
+        NodeDelta c = transientSpace.getNodeDelta(ROOT.concat("a/b/c"));
         c.addNode("d").addNode("e");
         c.addNode("f");
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/d/e")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/f")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/d/e")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/f")));
 
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/d/e")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("a/b/c/f")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/d/e")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c/f")));
     }
 
     @Test(expected = ItemNotFoundException.class)
     public void removeNotExistingNode() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.removeNode("remove");
         transientSpace.save();
     }
 
     @Test
     public void removeExistingNode() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("added");
         transientSpace.save();
 
         Path addedPath = ROOT.concat("added");
-        assertNotNull(transientSpace.getNode(addedPath));
+        assertNotNull(transientSpace.getNodeDelta(addedPath));
         
-        root = transientSpace.getNode(ROOT);
+        root = transientSpace.getNodeDelta(ROOT);
         root.removeNode("added");
-        assertNull(transientSpace.getNode(addedPath));
+        assertNull(transientSpace.getNodeDelta(addedPath));
         transientSpace.save();
-        assertNull(transientSpace.getNode(addedPath));
+        assertNull(transientSpace.getNodeDelta(addedPath));
     }
 
     @Test
     public void removeTransientNode() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("added");
 
         Path addedPath = ROOT.concat("added");
-        assertNotNull(transientSpace.getNode(addedPath));
+        assertNotNull(transientSpace.getNodeDelta(addedPath));
 
         root.removeNode("added");
-        assertNull(transientSpace.getNode(addedPath));
+        assertNull(transientSpace.getNodeDelta(addedPath));
         transientSpace.save();
-        assertNull(transientSpace.getNode(addedPath));
+        assertNull(transientSpace.getNodeDelta(addedPath));
     }
 
     @Test(expected = ItemNotFoundException.class)
     public void removeRemovedNode() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("added");
         transientSpace.save();
 
         Path addedPath = ROOT.concat("added");
-        NodeDelta added = transientSpace.getNode(addedPath);
+        NodeDelta added = transientSpace.getNodeDelta(addedPath);
         added.addNode("added2");
 
         assertTrue(added.hasNode("added2"));
@@ -146,7 +146,7 @@ public class TransientSpaceTest {
 
     @Test
     public void removeAndAddAgain() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a").addNode("b");
         transientSpace.save();
 
@@ -171,7 +171,7 @@ public class TransientSpaceTest {
 
     @Test
     public void moveAndAddAgain() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a").addNode("b");
         transientSpace.save();
 
@@ -196,7 +196,7 @@ public class TransientSpaceTest {
 
     @Test
     public void removeAfterMove() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a").addNode("b");
         root.addNode("x");
         transientSpace.save();
@@ -205,309 +205,309 @@ public class TransientSpaceTest {
         root.removeNode("a");
 
         assertNull(root.getNode("a"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("x/bm")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("x/bm")));
 
         transientSpace.save();
 
         assertNull(root.getNode("a"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("x/bm")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("x/bm")));
     }
 
     @Test
     public void moveTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target");
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveExisting() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test(expected = ItemNotFoundException.class)
     public void moveNotExistingSource() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source");
         root.addNode("target");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
     }
 
     @Test(expected = PathNotFoundException.class)
     public void moveToNotExistingTarget() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
     }
 
     @Test(expected = ItemExistsException.class)
     public void moveToExistingTarget() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target").addNode("moved");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
     }
 
     @Test
     public void rename() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("source/moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/moved")));
     }
     
     @Test
     public void moveSubTree() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         NodeDelta b = root.addNode("a").addNode("b");
         b.addNode("c").addNode("d");
         NodeDelta w = root.addNode("v").addNode("w");
         w.addNode("x").addNode("y");
         transientSpace.save();
 
-        b = transientSpace.getNode(ROOT.concat("a/b"));
+        b = transientSpace.getNodeDelta(ROOT.concat("a/b"));
         b.moveNode("c", w.getPath().concat("c-moved"));
         
-        assertNull(transientSpace.getNode(ROOT.concat("a/b/c")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("a/b")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("v/w/x/y")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("v/w/c-moved/d")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/x/y")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/c-moved/d")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("a/b/c")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("a/b")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("v/w/x/y")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("v/w/c-moved/d")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("a/b/c")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("a/b")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/x/y")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("v/w/c-moved/d")));
     }
     
     @Test
     public void modifyThenMove() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node").addNode("c");
         root.addNode("target");
         transientSpace.save();
         
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         NodeDelta moveNode = sourceNode.getNode("node");
         moveNode.addNode("a").addNode("b");
         moveNode.removeNode("c");
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
     }
 
     @Test
     public void moveThenModify() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node").addNode("c");
         root.addNode("target");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
-        NodeDelta movedNode = transientSpace.getNode(ROOT.concat("target/moved"));
+        NodeDelta movedNode = transientSpace.getNodeDelta(ROOT.concat("target/moved"));
         movedNode.addNode("a").addNode("b");
         movedNode.removeNode("c");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a/b")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a/b")));
     }
     
     @Test
     public void modifyThenMoveThenModify() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node").addNode("c1");
         root.getNode("source").getNode("node").addNode("c2");
         root.addNode("target");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         NodeDelta moveNode = sourceNode.getNode("node");
         moveNode.addNode("a1").addNode("b1");
         moveNode.removeNode("c1");
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
 
-        NodeDelta movedNode = transientSpace.getNode(ROOT.concat("target/moved"));
+        NodeDelta movedNode = transientSpace.getNodeDelta(ROOT.concat("target/moved"));
         movedNode.addNode("a2").addNode("b2");
         movedNode.removeNode("c2");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a1/b1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a2/b2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a1/b1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a2/b2")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a1/b1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved/c2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved/a2/b2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a1/b1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/c2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved/a2/b2")));
     }
 
     @Test
     public void moveThenDelete() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
         root.getNode("target").removeNode("moved");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveFromAddedThenDelete() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source");
         root.addNode("target");
         transientSpace.save();
 
         root.getNode("source").addNode("node");
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
         root.getNode("target").removeNode("moved");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveToAddedThenDelete() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         transientSpace.save();
 
         root.addNode("target");
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
         root.getNode("target").removeNode("moved");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveFromAddedToAddedThenDelete() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source");
         transientSpace.save();
 
         root.getNode("source").addNode("node");
         root.addNode("target");
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
         root.getNode("target").removeNode("moved");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
     
     @Test
     public void moveMoved() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target1");
         root.addNode("target2");
@@ -518,23 +518,23 @@ public class TransientSpaceTest {
         NodeDelta target1 = root.getNode("target1");
         target1.moveNode("moved1", ROOT.concat("target2/moved2"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
     }
 
     @Test
     public void moveMovedIndirect() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target1");
         root.addNode("target2");
@@ -546,147 +546,147 @@ public class TransientSpaceTest {
         sourceNode.moveNode("node", ROOT.concat("target1/child/node-moved"));
         target1.moveNode("child", ROOT.concat("target2/child-moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/child")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/child-moved/node-moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/child")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/child-moved/node-moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/child")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/child-moved/node-moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/child")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/child-moved/node-moved")));
     }
 
     @Test
     public void moveMovedThenDelete() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target1");
         root.addNode("target2");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target1/moved1"));
         NodeDelta target1 = root.getNode("target1");
         target1.moveNode("moved1", ROOT.concat("target2/moved2"));
         root.getNode("target2").removeNode("moved2");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
     }
 
     @Test
     public void moveMovedThenDeleteTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source");
         transientSpace.save();
         root.getNode("source").addNode("node");
         root.addNode("target1");
         root.addNode("target2");
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target1/moved1"));
         NodeDelta target1 = root.getNode("target1");
         target1.moveNode("moved1", ROOT.concat("target2/moved2"));
         root.getNode("target2").removeNode("moved2");
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
     }
 
     @Test
     public void moveForthAndBack() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target");
         transientSpace.save();
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
         NodeDelta target = root.getNode("target");
         target.moveNode("moved", ROOT.concat("source/node"));
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveForthAndBackTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source");
         root.getNode("source").addNode("node");
         transientSpace.save();
         root.addNode("target");
 
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
         NodeDelta target = root.getNode("target");
         target.moveNode("moved", ROOT.concat("source/node"));
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveFromTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("target");
         transientSpace.save();
 
         root.addNode("source1").addNode("node");
-        NodeDelta sourceNode = transientSpace.getNode(ROOT.concat("source1"));
+        NodeDelta sourceNode = transientSpace.getNodeDelta(ROOT.concat("source1"));
         sourceNode.moveNode("node", ROOT.concat("target/moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveIntoMove() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node1").addNode("child");
         root.getNode("source").addNode("node2");
         root.addNode("target");
@@ -695,20 +695,20 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node1", ROOT.concat("target/moved1"));
         root.getNode("source").moveNode("node2", ROOT.concat("target/moved1/child/moved2"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
 
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
     }
 
     @Test
     public void moveIntoMoveTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node1").addNode("child");
         root.getNode("source").addNode("node2");
         root.addNode("target");
@@ -716,20 +716,20 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node1", ROOT.concat("target/moved1"));
         root.getNode("source").moveNode("node2", ROOT.concat("target/moved1/child/moved2"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
 
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved1/child/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved1/child/moved2")));
     }
 
     @Test
     public void moveOutOfMove() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node1").addNode("child");
         root.addNode("target1");
         root.addNode("target2");
@@ -738,22 +738,22 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node1", ROOT.concat("target1/moved1"));
         root.getNode("target1").getNode("moved1").moveNode("child", ROOT.concat("target2/moved2"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
 
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
     }
 
     @Test
     public void moveMove() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a").addNode("b");
         root.addNode("t1");
         transientSpace.save();
@@ -761,22 +761,22 @@ public class TransientSpaceTest {
         root.moveNode("a", ROOT.concat("t1/am"));
         root.getNode("t1").getNode("am").moveNode("b", ROOT.concat("bm"));
         
-        assertNull(transientSpace.getNode(ROOT.concat("a")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("t1/am")));
-        assertNull(transientSpace.getNode(ROOT.concat("t1/am/b")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("bm")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("a")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("t1/am")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("t1/am/b")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm")));
 
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("a")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("t1/am")));
-        assertNull(transientSpace.getNode(ROOT.concat("t1/am/b")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("bm")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("a")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("t1/am")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("t1/am/b")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm")));
     }
 
     @Test
     public void moveOutOfMoveTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node1").addNode("child");
         root.addNode("target1");
         root.addNode("target2");
@@ -784,22 +784,22 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node1", ROOT.concat("target1/moved1"));
         root.getNode("target1").getNode("moved1").moveNode("child", ROOT.concat("target2/moved2"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
 
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target1/moved1")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1/moved1/child")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved2")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1/moved1/child")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved2")));
     }
 
     @Test
     public void moveMovedParent() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target1");
         root.addNode("target2");
@@ -808,22 +808,22 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node", ROOT.concat("target1/moved"));
         root.moveNode("target1", ROOT.concat("target2/moved-target1"));
         
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved-target1/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved-target1/moved")));
 
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved-target1/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved-target1/moved")));
     }
 
     @Test
     public void moveMovedParentTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target1");
         root.addNode("target2");
@@ -831,21 +831,21 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node", ROOT.concat("target1/moved"));
         root.moveNode("target1", ROOT.concat("target2/moved-target1"));
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target2/moved-target1/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target2/moved-target1/moved")));
 
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target1")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target1")));
     }
 
     @Test
     public void removeMoved() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target");
         transientSpace.save();
@@ -853,40 +853,40 @@ public class TransientSpaceTest {
         root.getNode("source").moveNode("node", ROOT.concat("target/moved"));
         root.removeNode("target");
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
 
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
     }
 
     @Test
     public void removeMovedTransient() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node");
         root.addNode("target");
 
         root.getNode("source").moveNode("node", ROOT.concat("target/moved"));
         root.removeNode("target");
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
 
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node")));
-        assertNull(transientSpace.getNode(ROOT.concat("target")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("target")));
     }
 
     @Test
     public void moveAddedToMove() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("source").addNode("node1");
         transientSpace.save();
 
@@ -894,40 +894,40 @@ public class TransientSpaceTest {
         root.getNode("source").addNode("node2");
         root.getNode("source").moveNode("node2", ROOT.concat("target/moved"));
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
 
         transientSpace.save();
 
-        assertNotNull(transientSpace.getNode(ROOT.concat("source")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node1")));
-        assertNull(transientSpace.getNode(ROOT.concat("source/node2")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/moved")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("source")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node1")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("source/node2")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/moved")));
     }
 
     @Test
     public void moveToAdded() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("node");
         transientSpace.save();
         
         root.addNode("target");
         root.moveNode("node", ROOT.concat("target/node-moved"));
 
-        assertNull(transientSpace.getNode(ROOT.concat("node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/node-moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/node-moved")));
 
         transientSpace.save();
 
-        assertNull(transientSpace.getNode(ROOT.concat("node")));
-        assertNotNull(transientSpace.getNode(ROOT.concat("target/node-moved")));
+        assertNull(transientSpace.getNodeDelta(ROOT.concat("node")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("target/node-moved")));
     }
 
     @Test
     public void moveIntoSameBranch() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a");
         root.addNode("b");
         transientSpace.save();
@@ -937,18 +937,18 @@ public class TransientSpaceTest {
 
         assertNull(root.getNode("a"));
         assertNull(root.getNode("b"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("am/bm")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/bm")));
 
         transientSpace.save();
 
         assertNull(root.getNode("a"));
         assertNull(root.getNode("b"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("am/bm")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/bm")));
     }
 
     @Test
     public void moveIntoSameBranchIndirect() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a");
         root.addNode("b");
         transientSpace.save();
@@ -959,18 +959,18 @@ public class TransientSpaceTest {
 
         assertNull(root.getNode("a"));
         assertNull(root.getNode("b"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("am/c/bm")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/c/bm")));
 
         transientSpace.save();
 
         assertNull(root.getNode("a"));
         assertNull(root.getNode("b"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("am/c/bm")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("am/c/bm")));
     }
 
     @Test
     public void moveToReverse() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("a").addNode("b");
         transientSpace.save();
         
@@ -978,18 +978,18 @@ public class TransientSpaceTest {
         root.moveNode("a", ROOT.concat("bm/am"));
         
         assertNull(root.getNode("a"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("bm/am")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm/am")));
 
         transientSpace.save();
 
         assertNull(root.getNode("a"));
-        assertNotNull(transientSpace.getNode(ROOT.concat("bm/am")));
+        assertNotNull(transientSpace.getNodeDelta(ROOT.concat("bm/am")));
     }
 
     @Test
     public void setPropertyTest() throws RepositoryException {
         // Set property
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.setValue("prop", JsonAtom.number(42));
         transientSpace.save();
         assertThat(mk, propertyHasValue(ROOT.concat("prop"), 42));
@@ -1029,7 +1029,7 @@ public class TransientSpaceTest {
     
     @Test
     public void liveNode() throws RepositoryException {
-        NodeDelta root = transientSpace.getNode(ROOT);
+        NodeDelta root = transientSpace.getNodeDelta(ROOT);
         root.addNode("test");
         transientSpace.save();
 



Mime
View raw message