Keep ctime for aggregated items

4 files changed, 95 insertions, 80 deletions

diff --git a/sugar_network/db/resource.py b/sugar_network/db/resource.py
index 7560024..35ab29b 100644
--- a/sugar_network/db/resource.py
+++ b/sugar_network/db/resource.py
@@ -218,6 +218,7 @@ class Resource(object):
         if seqno and isinstance(prop, Aggregated):
             for agg in value.values():
                 agg['seqno'] = seqno
+                agg['ctime'] = int(time.time())
         if isinstance(prop, Composite):
             orig_value = self.orig(prop.name)
             if orig_value:
diff --git a/tests/units/db/db_routes.py b/tests/units/db/db_routes.py
index fee2b03..997aeec 100755
--- a/tests/units/db/db_routes.py
+++ b/tests/units/db/db_routes.py
@@ -1524,13 +1524,13 @@ class DbRoutesTest(tests.Test):
         self.override(toolkit, 'uuid', lambda: '0')
         self.assertEqual('0', this.call(method='POST', path=['document', guid, 'prop3'], content=0))
         self.assertEqual({
-            '0': {'seqno': 2, 'value': 0},
+            '0': {'seqno': 2, 'ctime': 0, 'value': 0},
             },
             volume['document'].get(guid)['prop3'])
         self.assertEqual([
             {'event': 'update', 'resource': 'document', 'guid': guid, 'props': {
                 'mtime': 0,
-                'prop3': {'0': {'seqno': 2, 'value': 0}},
+                'prop3': {'0': {'seqno': 2, 'ctime': 0, 'value': 0}},
                 }},
             ],
             events)
@@ -1539,8 +1539,8 @@ class DbRoutesTest(tests.Test):
         self.override(toolkit, 'uuid', lambda: '1')
         self.assertEqual('1', this.call(method='POST', path=['document', guid, 'prop3'], content={'foo': 'bar'}))
         self.assertEqual({
-            '0': {'seqno': 2, 'value': 0},
-            '1': {'seqno': 3, 'value': {'foo': 'bar'}},
+            '0': {'seqno': 2, 'ctime': 0, 'value': 0},
+            '1': {'seqno': 3, 'ctime': 1, 'value': {'foo': 'bar'}},
             },
             volume['document'].get(guid)['prop3'])
 
@@ -1548,9 +1548,9 @@ class DbRoutesTest(tests.Test):
         self.override(toolkit, 'uuid', lambda: '2')
         self.assertEqual('2', this.call(method='POST', path=['document', guid, 'prop3'], content=None))
         self.assertEqual({
-            '0': {'seqno': 2, 'value': 0},
-            '1': {'seqno': 3, 'value': {'foo': 'bar'}},
-            '2': {'seqno': 4, 'value': None},
+            '0': {'seqno': 2, 'ctime': 0, 'value': 0},
+            '1': {'seqno': 3, 'ctime': 1, 'value': {'foo': 'bar'}},
+            '2': {'seqno': 4, 'ctime': 2, 'value': None},
             },
             volume['document'].get(guid)['prop3'])
 
@@ -1576,27 +1576,30 @@ class DbRoutesTest(tests.Test):
         agg_guid = this.call(method='POST', path=['document', guid, 'prop1'], content=2)
         del events[:]
         self.assertEqual(
-                {agg_guid: {'seqno': 2, 'value': 2}},
+                {agg_guid: {'seqno': 2, 'ctime': 0, 'value': 2}},
                 volume['document'].get(guid)['prop1'])
         self.assertRaises(http.Forbidden, this.call, method='DELETE', path=['document', guid, 'prop1', agg_guid])
         self.assertEqual(
-                {agg_guid: {'seqno': 2, 'value': 2}},
+                {agg_guid: {'seqno': 2, 'ctime': 0, 'value': 2}},
                 volume['document'].get(guid)['prop1'])
         self.assertEqual([], events)
 
+        self.override(time, 'time', lambda: 1)
         agg_guid = this.call(method='POST', path=['document', guid, 'prop2'], content=3)
         del events[:]
         self.assertEqual(
-                {agg_guid: {'seqno': 3, 'value': 3}},
+                {agg_guid: {'seqno': 3, 'ctime': 1, 'value': 3}},
                 volume['document'].get(guid)['prop2'])
+
+        self.override(time, 'time', lambda: 2)
         this.call(method='DELETE', path=['document', guid, 'prop2', agg_guid])
         self.assertEqual(
-                {agg_guid: {'seqno': 4}},
+                {agg_guid: {'seqno': 4, 'ctime': 2}},
                 volume['document'].get(guid)['prop2'])
         self.assertEqual([
             {'event': 'update', 'resource': 'document', 'guid': guid, 'props': {
-                'mtime': 0,
-                'prop2': {agg_guid: {'seqno': 4}},
+                'mtime': 2,
+                'prop2': {agg_guid: {'seqno': 4, 'ctime': 2}},
                 }},
             ],
             events)
@@ -1617,6 +1620,7 @@ class DbRoutesTest(tests.Test):
         self.assertRaises(http.Forbidden, this.call, method='PUT', path=['document', guid], content={'prop': {}})
 
     def test_AggpropSubtypeCasts(self):
+        self.override(time, 'time', lambda: 0)
 
         class Document(db.Resource):
 
@@ -1637,9 +1641,9 @@ class DbRoutesTest(tests.Test):
         agg3 = this.call(method='POST', path=['document', guid, 'props'], content={'foo': 'bar'})
 
         self.assertEqual({
-            agg1: {'seqno': 2, 'value': -1},
-            agg2: {'seqno': 3, 'value': None},
-            agg3: {'seqno': 4, 'value': {'foo': 'bar'}},
+            agg1: {'seqno': 2, 'ctime': 0, 'value': -1},
+            agg2: {'seqno': 3, 'ctime': 0, 'value': None},
+            agg3: {'seqno': 4, 'ctime': 0, 'value': {'foo': 'bar'}},
             },
             volume['document'][guid]['props'])
         self.assertEqual({
@@ -1712,27 +1716,32 @@ class DbRoutesTest(tests.Test):
         agg_guid = this.call(method='POST', path=['document', guid, 'prop1'], content=1)
         del events[:]
         self.assertEqual(
-                {agg_guid: {'seqno': 2, 'value': 1}},
+                {agg_guid: {'seqno': 2, 'ctime': 0, 'value': 1}},
                 volume['document'].get(guid)['prop1'])
+
+        self.override(time, 'time', lambda: 1)
         self.assertRaises(http.Forbidden, this.call, method='PUT', path=['document', guid, 'prop1', agg_guid], content=2)
         self.assertEqual(
-                {agg_guid: {'seqno': 2, 'value': 1}},
+                {agg_guid: {'seqno': 2, 'ctime': 0, 'value': 1}},
                 volume['document'].get(guid)['prop1'])
         self.assertEqual([], events)
 
+        self.override(time, 'time', lambda: 2)
         agg_guid = this.call(method='POST', path=['document', guid, 'prop2'], content=2)
         del events[:]
         self.assertEqual(
-                {agg_guid: {'seqno': 3, 'value': 2}},
+                {agg_guid: {'seqno': 3, 'ctime': 2, 'value': 2}},
                 volume['document'].get(guid)['prop2'])
+
+        self.override(time, 'time', lambda: 3)
         this.call(method='PUT', path=['document', guid, 'prop2', agg_guid], content=3)
         self.assertEqual(
-                {agg_guid: {'seqno': 4, 'value': 3}},
+                {agg_guid: {'seqno': 4, 'ctime': 3, 'value': 3}},
                 volume['document'].get(guid)['prop2'])
         self.assertEqual([
             {'event': 'update', 'resource': 'document', 'guid': guid, 'props': {
-                'mtime': 0,
-                'prop2': {agg_guid: {'seqno': 4, 'value': 3}},
+                'mtime': 3,
+                'prop2': {agg_guid: {'seqno': 4, 'ctime': 3, 'value': 3}},
                 }},
             ],
             events)
@@ -1755,12 +1764,12 @@ class DbRoutesTest(tests.Test):
 
         this.call(method='PUT', path=['document', guid, 'prop', 'absent'], content='probe')
         self.assertEqual(
-                {'absent': {'seqno': 2, 'value': 'probe'}},
+                {'absent': {'seqno': 2, 'ctime': 0, 'value': 'probe'}},
                 volume['document'].get(guid)['prop'])
         self.assertEqual([
             {'event': 'update', 'resource': 'document', 'guid': guid, 'props': {
                 'mtime': 0,
-                'prop': {'absent': {'seqno': 2, 'value': 'probe'}},
+                'prop': {'absent': {'seqno': 2, 'ctime': 0, 'value': 'probe'}},
                 }},
             ],
             events)
@@ -1798,6 +1807,7 @@ class DbRoutesTest(tests.Test):
         assert not (ACL.ORIGINAL & volume['document'][guid]['prop'][agg_guid2]['author'][tests.UID2]['role'])
 
     def test_AggregatedBlobs(self):
+        self.override(time, 'time', lambda: 0)
 
         class Document(db.Resource):
 
@@ -1815,23 +1825,23 @@ class DbRoutesTest(tests.Test):
 
         agg1 = this.call(method='POST', path=['document', guid, 'blobs'], content='blob1')
         self.assertEqual({
-            agg1: {'seqno': 3, 'value': digest1},
+            agg1: {'seqno': 3, 'ctime': 0, 'value': digest1},
             },
             volume['document'].get(guid)['blobs'])
         assert volume.blobs.get(digest1)
 
         agg2 = this.call(method='POST', path=['document', guid, 'blobs'], content='blob2')
         self.assertEqual({
-            agg1: {'seqno': 3, 'value': digest1},
-            agg2: {'seqno': 5, 'value': digest2},
+            agg1: {'seqno': 3, 'ctime': 0, 'value': digest1},
+            agg2: {'seqno': 5, 'ctime': 0, 'value': digest2},
             },
             volume['document'].get(guid)['blobs'])
         assert volume.blobs.get(digest2)
 
         this.call(method='DELETE', path=['document', guid, 'blobs', agg1])
         self.assertEqual({
-            agg1: {'seqno': 7},
-            agg2: {'seqno': 5, 'value': digest2},
+            agg1: {'seqno': 7, 'ctime': 0},
+            agg2: {'seqno': 5, 'ctime': 0, 'value': digest2},
             },
             volume['document'].get(guid)['blobs'])
         assert not volume.blobs.get(digest1).exists
@@ -1839,8 +1849,8 @@ class DbRoutesTest(tests.Test):
 
         this.call(method='DELETE', path=['document', guid, 'blobs', agg2])
         self.assertEqual({
-            agg1: {'seqno': 7},
-            agg2: {'seqno': 9},
+            agg1: {'seqno': 7, 'ctime': 0},
+            agg2: {'seqno': 9, 'ctime': 0},
             },
             volume['document'].get(guid)['blobs'])
         assert not volume.blobs.get(digest1).exists
@@ -1848,9 +1858,9 @@ class DbRoutesTest(tests.Test):
 
         agg3 = this.call(method='POST', path=['document', guid, 'blobs'], content='blob3')
         self.assertEqual({
-            agg1: {'seqno': 7},
-            agg2: {'seqno': 9},
-            agg3: {'seqno': 11, 'value': digest3},
+            agg1: {'seqno': 7, 'ctime': 0},
+            agg2: {'seqno': 9, 'ctime': 0},
+            agg3: {'seqno': 11, 'ctime': 0, 'value': digest3},
             },
             volume['document'].get(guid)['blobs'])
         assert not volume.blobs.get(digest1).exists
diff --git a/tests/units/node/node_model.py b/tests/units/node/node_model.py
index 9bb758e..6f0b9c7 100755
--- a/tests/units/node/node_model.py
+++ b/tests/units/node/node_model.py
@@ -719,6 +719,7 @@ class NodeModelTest(tests.Test):
         self.assertEqual([[3, None]], r)
 
     def test_diff_volume_AggProps(self):
+        self.override(time, 'time', lambda: 0)
 
         class Document(db.Resource):
 
@@ -740,13 +741,13 @@ class NodeModelTest(tests.Test):
                 'guid': {'value': '1', 'mtime': 1},
                 'ctime': {'value': 1, 'mtime': 1},
                 'mtime': {'value': 1, 'mtime': 1},
-                'prop': {'value': {'1': {'prop': 1}}, 'mtime': 1},
+                'prop': {'value': {'1': {'prop': 1, 'ctime': 0}}, 'mtime': 1},
                 }},
             {'guid': '2', 'patch': {
                 'guid': {'value': '2', 'mtime': 2},
                 'ctime': {'value': 2, 'mtime': 2},
                 'mtime': {'value': 2, 'mtime': 2},
-                'prop': {'value': {'2': {'prop': 2}}, 'mtime': 2},
+                'prop': {'value': {'2': {'prop': 2, 'ctime': 0}}, 'mtime': 2},
                 }},
             {'commit': [[1, 2]]},
             ],
@@ -760,7 +761,7 @@ class NodeModelTest(tests.Test):
                 'guid': {'value': '1', 'mtime': 1},
                 'ctime': {'value': 1, 'mtime': 1},
                 'mtime': {'value': 1, 'mtime': 1},
-                'prop': {'value': {'1': {'prop': 1}}, 'mtime': 1},
+                'prop': {'value': {'1': {'prop': 1, 'ctime': 0}}, 'mtime': 1},
                 }},
             {'commit': [[1, 1]]},
             ],
@@ -774,7 +775,7 @@ class NodeModelTest(tests.Test):
                 'guid': {'value': '2', 'mtime': 2},
                 'ctime': {'value': 2, 'mtime': 2},
                 'mtime': {'value': 2, 'mtime': 2},
-                'prop': {'value': {'2': {'prop': 2}}, 'mtime': 2},
+                'prop': {'value': {'2': {'prop': 2, 'ctime': 0}}, 'mtime': 2},
                 }},
             {'commit': [[2, 2]]},
             ],
@@ -789,11 +790,11 @@ class NodeModelTest(tests.Test):
         self.assertEqual([[3, None]], r)
 
         self.assertEqual({
-            '1': {'seqno': 1, 'prop': 1},
+            '1': {'seqno': 1, 'prop': 1, 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
         self.assertEqual({
-            '2': {'seqno': 2, 'prop': 2},
+            '2': {'seqno': 2, 'prop': 2, 'ctime': 0},
             },
             volume['document'].get('2')['prop'])
 
@@ -802,7 +803,7 @@ class NodeModelTest(tests.Test):
         self.assertEqual([
             {'resource': 'document'},
             {'guid': '2', 'patch': {
-                'prop': {'value': {'2': {}, '3': {'prop': 3}}, 'mtime': int(os.stat('db/document/2/2/prop').st_mtime)},
+                'prop': {'value': {'2': {'ctime': 0}, '3': {'prop': 3, 'ctime': 0}}, 'mtime': int(os.stat('db/document/2/2/prop').st_mtime)},
                 }},
             {'commit': [[3, 3]]},
             ],
@@ -810,8 +811,8 @@ class NodeModelTest(tests.Test):
         self.assertEqual([[4, None]], r)
 
         self.assertEqual({
-            '2': {'seqno': 3},
-            '3': {'seqno': 3, 'prop': 3},
+            '2': {'seqno': 3, 'ctime': 0},
+            '3': {'seqno': 3, 'prop': 3, 'ctime': 0},
             },
             volume['document'].get('2')['prop'])
 
@@ -820,7 +821,7 @@ class NodeModelTest(tests.Test):
         self.assertEqual([
             {'resource': 'document'},
             {'guid': '1', 'patch': {
-                'prop': {'value': {'1': {'foo': 'bar'}}, 'mtime': int(os.stat('db/document/1/1/prop').st_mtime)},
+                'prop': {'value': {'1': {'foo': 'bar', 'ctime': 0}}, 'mtime': int(os.stat('db/document/1/1/prop').st_mtime)},
                 }},
             {'commit': [[4, 4]]},
             ],
@@ -828,7 +829,7 @@ class NodeModelTest(tests.Test):
         self.assertEqual([[5, None]], r)
 
         self.assertEqual({
-            '1': {'seqno': 4, 'foo': 'bar'},
+            '1': {'seqno': 4, 'foo': 'bar', 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
 
@@ -837,7 +838,7 @@ class NodeModelTest(tests.Test):
         self.assertEqual([
             {'resource': 'document'},
             {'guid': '2', 'patch': {
-                'prop': {'value': {'2': {'restore': True}}, 'mtime': int(os.stat('db/document/2/2/prop').st_mtime)},
+                'prop': {'value': {'2': {'restore': True, 'ctime': 0}}, 'mtime': int(os.stat('db/document/2/2/prop').st_mtime)},
                 }},
             {'commit': [[5, 5]]},
             ],
@@ -845,8 +846,8 @@ class NodeModelTest(tests.Test):
         self.assertEqual([[6, None]], r)
 
         self.assertEqual({
-            '2': {'seqno': 5, 'restore': True},
-            '3': {'seqno': 3, 'prop': 3},
+            '2': {'seqno': 5, 'restore': True, 'ctime': 0},
+            '3': {'seqno': 3, 'prop': 3, 'ctime': 0},
             },
             volume['document'].get('2')['prop'])
 
@@ -863,12 +864,13 @@ class NodeModelTest(tests.Test):
         self.assertEqual([[7, None]], r)
 
         self.assertEqual({
-            '2': {'seqno': 5, 'restore': True},
-            '3': {'seqno': 3, 'prop': 3},
+            '2': {'seqno': 5, 'restore': True, 'ctime': 0},
+            '3': {'seqno': 3, 'prop': 3, 'ctime': 0},
             },
             volume['document'].get('2')['prop'])
 
     def test_patch_volume_Aggprops(self):
+        self.override(time, 'time', lambda: 0)
 
         class Document(db.Resource):
 
@@ -885,58 +887,58 @@ class NodeModelTest(tests.Test):
                 'guid': {'mtime': 1, 'value': '1'},
                 'ctime': {'mtime': 1, 'value': 1},
                 'mtime': {'mtime': 1, 'value': 1},
-                'prop': {'mtime': 1, 'value': {'1': {}}},
+                'prop': {'mtime': 1, 'value': {'1': {'ctime': 0}}},
                 }},
             ])
         self.assertEqual({
-            '1': {'seqno': 1},
+            '1': {'seqno': 1, 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
 
         model.patch_volume([
             {'resource': 'document'},
             {'guid': '1', 'patch': {
-                'prop': {'mtime': 1, 'value': {'1': {'probe': False}}},
+                'prop': {'mtime': 1, 'value': {'1': {'probe': False, 'ctime': 0}}},
                 }},
             ])
         self.assertEqual({
-            '1': {'seqno': 1},
+            '1': {'seqno': 1, 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
 
         model.patch_volume([
             {'resource': 'document'},
             {'guid': '1', 'patch': {
-                'prop': {'mtime': 2, 'value': {'1': {'probe': True}}},
+                'prop': {'mtime': 2, 'value': {'1': {'probe': True, 'ctime': 0}}},
                 }},
             ])
         self.assertEqual({
-            '1': {'seqno': 2, 'probe': True},
+            '1': {'seqno': 2, 'probe': True, 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
 
         model.patch_volume([
             {'resource': 'document'},
             {'guid': '1', 'patch': {
-                'prop': {'mtime': 3, 'value': {'2': {'foo': 'bar'}}},
+                'prop': {'mtime': 3, 'value': {'2': {'foo': 'bar', 'ctime': 0}}},
                 }},
             ])
         self.assertEqual({
-            '1': {'seqno': 2, 'probe': True},
-            '2': {'seqno': 3, 'foo': 'bar'},
+            '1': {'seqno': 2, 'probe': True, 'ctime': 0},
+            '2': {'seqno': 3, 'foo': 'bar', 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
 
         model.patch_volume([
             {'resource': 'document'},
             {'guid': '1', 'patch': {
-                'prop': {'mtime': 4, 'value': {'2': {}, '3': {'foo': 'bar'}}},
+                'prop': {'mtime': 4, 'value': {'2': {'ctime': 0}, '3': {'foo': 'bar', 'ctime': 0}}},
                 }},
             ])
         self.assertEqual({
-            '1': {'seqno': 2, 'probe': True},
-            '2': {'seqno': 4},
-            '3': {'seqno': 4, 'foo': 'bar'},
+            '1': {'seqno': 2, 'probe': True, 'ctime': 0},
+            '2': {'seqno': 4, 'ctime': 0},
+            '3': {'seqno': 4, 'foo': 'bar', 'ctime': 0},
             },
             volume['document'].get('1')['prop'])
 
diff --git a/tests/units/node/node_routes.py b/tests/units/node/node_routes.py
index c781792..74bba7b 100755
--- a/tests/units/node/node_routes.py
+++ b/tests/units/node/node_routes.py
@@ -755,6 +755,7 @@ class NodeRoutesTest(tests.Test):
         assert activity_blob == reply.read()
 
     def test_AggpropInsertAccess(self):
+        self.override(time, 'time', lambda: 0)
 
         class Document(db.Resource):
 
@@ -776,19 +777,20 @@ class NodeRoutesTest(tests.Test):
         agg1 = this.call(method='POST', path=['document', guid, 'prop1'], environ=auth_env(tests.UID))
         agg2 = this.call(method='POST', path=['document', guid, 'prop1'], environ=auth_env(tests.UID2))
         self.assertEqual({
-            agg1: {'seqno': 4, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None},
-            agg2: {'seqno': 5, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'value': None},
+            agg1: {'seqno': 4, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None, 'ctime': 0},
+            agg2: {'seqno': 5, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'value': None, 'ctime': 0},
             },
             volume['document'][guid]['prop1'])
 
         agg3 = this.call(method='POST', path=['document', guid, 'prop2'], environ=auth_env(tests.UID))
         self.assertRaises(http. Forbidden, this.call, method='POST', path=['document', guid, 'prop2'], environ=auth_env(tests.UID2))
         self.assertEqual({
-            agg3: {'seqno': 6, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None},
+            agg3: {'seqno': 6, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None, 'ctime': 0},
             },
             volume['document'][guid]['prop2'])
 
     def test_AggpropReplaceAccess(self):
+        self.override(time, 'time', lambda: 0)
 
         class Document(db.Resource):
 
@@ -810,8 +812,8 @@ class NodeRoutesTest(tests.Test):
         agg1 = this.call(method='POST', path=['document', guid, 'prop1'], environ=auth_env(tests.UID))
         agg2 = this.call(method='POST', path=['document', guid, 'prop1'], environ=auth_env(tests.UID2))
         self.assertEqual({
-            agg1: {'seqno': 4, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None},
-            agg2: {'seqno': 5, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'value': None},
+            agg1: {'seqno': 4, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None, 'ctime': 0},
+            agg2: {'seqno': 5, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'value': None, 'ctime': 0},
             },
             volume['document'][guid]['prop1'])
         self.assertRaises(http. Forbidden, this.call, method='PUT', path=['document', guid, 'prop1', agg1], environ=auth_env(tests.UID2))
@@ -820,7 +822,7 @@ class NodeRoutesTest(tests.Test):
         agg3 = this.call(method='POST', path=['document', guid, 'prop2'], environ=auth_env(tests.UID))
         self.assertRaises(http. Forbidden, this.call, method='POST', path=['document', guid, 'prop2'], environ=auth_env(tests.UID2))
         self.assertEqual({
-            agg3: {'seqno': 7, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None},
+            agg3: {'seqno': 7, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'value': None, 'ctime': 0},
             },
             volume['document'][guid]['prop2'])
 
@@ -846,45 +848,45 @@ class NodeRoutesTest(tests.Test):
         agg1 = this.call(method='POST', path=['document', guid, 'prop1'], environ=auth_env(tests.UID), content=True)
         agg2 = this.call(method='POST', path=['document', guid, 'prop1'], environ=auth_env(tests.UID2), content=True)
         self.assertEqual({
-            agg1: {'seqno': 4, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
-            agg2: {'seqno': 5, 'value': True, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}},
+            agg1: {'seqno': 4, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
+            agg2: {'seqno': 5, 'value': True, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'ctime': 0},
             },
             volume['document'][guid]['prop1'])
         self.assertRaises(http.Forbidden, this.call, method='DELETE', path=['document', guid, 'prop1', agg1], environ=auth_env(tests.UID2))
         self.assertRaises(http.Forbidden, this.call, method='DELETE', path=['document', guid, 'prop1', agg2], environ=auth_env(tests.UID))
         self.assertEqual({
-            agg1: {'seqno': 4, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
-            agg2: {'seqno': 5, 'value': True, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}},
+            agg1: {'seqno': 4, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
+            agg2: {'seqno': 5, 'value': True, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'ctime': 0},
             },
             volume['document'][guid]['prop1'])
 
         this.call(method='DELETE', path=['document', guid, 'prop1', agg1], environ=auth_env(tests.UID))
         self.assertEqual({
-            agg1: {'seqno': 6, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
-            agg2: {'seqno': 5, 'value': True, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}},
+            agg1: {'seqno': 6, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
+            agg2: {'seqno': 5, 'value': True, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'ctime': 0},
             },
             volume['document'][guid]['prop1'])
         this.call(method='DELETE', path=['document', guid, 'prop1', agg2], environ=auth_env(tests.UID2))
         self.assertEqual({
-            agg1: {'seqno': 6, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
-            agg2: {'seqno': 7, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}},
+            agg1: {'seqno': 6, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
+            agg2: {'seqno': 7, 'author': {tests.UID2: {'name': 'user2', 'order': 0, 'role': 1}}, 'ctime': 0},
             },
             volume['document'][guid]['prop1'])
 
         agg3 = this.call(method='POST', path=['document', guid, 'prop2'], environ=auth_env(tests.UID), content=True)
         self.assertEqual({
-            agg3: {'seqno': 8, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
+            agg3: {'seqno': 8, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
             },
             volume['document'][guid]['prop2'])
 
         self.assertRaises(http.Forbidden, this.call, method='DELETE', path=['document', guid, 'prop2', agg3], environ=auth_env(tests.UID2))
         self.assertEqual({
-            agg3: {'seqno': 8, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
+            agg3: {'seqno': 8, 'value': True, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
             },
             volume['document'][guid]['prop2'])
         this.call(method='DELETE', path=['document', guid, 'prop2', agg3], environ=auth_env(tests.UID))
         self.assertEqual({
-            agg3: {'seqno': 9, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}},
+            agg3: {'seqno': 9, 'author': {tests.UID: {'name': 'user1', 'order': 0, 'role': 3}}, 'ctime': 0},
             },
             volume['document'][guid]['prop2'])