Pull node updates for checked-in resources

10 files changed, 762 insertions, 166 deletions

diff --git a/tests/__init__.py b/tests/__init__.py
index e1c3222..32bc3ea 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -24,10 +24,12 @@ from sugar_network.toolkit import http, mountpoints, Option, gbus, i18n, languag
 from sugar_network.toolkit.router import Router, Request, Response
 from sugar_network.toolkit.coroutine import this
 from sugar_network.client import IPCConnection, journal, routes as client_routes, model as client_model
+from sugar_network.client.model import Volume as LocalVolume
 from sugar_network.client.injector import Injector
 from sugar_network.client.routes import ClientRoutes
 from sugar_network.client.auth import SugarCreds
 from sugar_network import db, client, node, toolkit, model
+from sugar_network.db import routes as db_routes
 from sugar_network.model.user import User
 from sugar_network.model.context import Context
 from sugar_network.node.model import Context as MasterContext
@@ -103,6 +105,8 @@ class Test(unittest.TestCase):
         client.cache_lifetime.value = 0
         client.keyfile.value = join(root, 'data', UID)
         client_routes._RECONNECT_TIMEOUT = 0
+        client_routes._SYNC_TIMEOUT = 30
+        db_routes._GROUPED_DIFF_LIMIT = 1024
         journal._ds_root = tmpdir + '/datastore'
         mountpoints._connects.clear()
         mountpoints._found.clear()
@@ -141,6 +145,7 @@ class Test(unittest.TestCase):
         this.volume = None
         this.call = None
         this.broadcast = lambda x: x
+        this.localcast = lambda x: x
         this.injector = None
         this.principal = None
 
@@ -287,12 +292,14 @@ class Test(unittest.TestCase):
         this.call = self.node_router.call
         return self.node_volume
 
-    def fork_master(self, classes=None, routes=MasterRoutes):
+    def fork_master(self, classes=None, routes=MasterRoutes, cb=None):
         if classes is None:
             classes = master.RESOURCES
 
         def node():
             volume = NodeVolume('master', classes)
+            if cb is not None:
+                cb(volume)
             node = coroutine.WSGIServer(('127.0.0.1', 7777), Router(routes(volume=volume, auth=SugarAuth('master'))))
             node.serve_forever()
 
@@ -314,10 +321,7 @@ class Test(unittest.TestCase):
     def start_online_client(self, classes=None):
         self.fork_master(classes)
         this.injector = Injector('client/cache')
-        if classes:
-            home_volume = db.Volume('client', classes)
-        else:
-            home_volume = client_model.Volume('client')
+        home_volume = LocalVolume('client', classes)
         self.client_routes = ClientRoutes(home_volume, SugarCreds(client.keyfile.value))
         self.client_routes.connect(client.api.value)
         self.wait_for_events(self.client_routes, event='inline', state='online').wait()
diff --git a/tests/units/client/injector.py b/tests/units/client/injector.py
index 7170758..b266cda 100755
--- a/tests/units/client/injector.py
+++ b/tests/units/client/injector.py
@@ -14,6 +14,7 @@ from __init__ import tests
 from sugar_network import db, client
 from sugar_network.client import Connection, keyfile, api, packagekit, injector as injector_, model
 from sugar_network.client.injector import _PreemptivePool, Injector
+from sugar_network.client.model import Volume as LocalVolume
 from sugar_network.client.auth import SugarCreds
 from sugar_network.toolkit.coroutine import this
 from sugar_network.toolkit import http, lsb_release
@@ -349,7 +350,8 @@ class InjectorTest(tests.Test):
         assert not exists('releases/2')
 
     def test_solve(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -382,7 +384,8 @@ class InjectorTest(tests.Test):
         self.assertEqual([client.api.value, 'stable', 0, solution], json.load(file('client/solutions/context')))
 
     def test_solve_FailInOffline(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = None
@@ -403,7 +406,8 @@ class InjectorTest(tests.Test):
         self.assertRaises(http.ServiceUnavailable, injector._solve, 'context', 'stable')
 
     def test_solve_ReuseCachedSolution(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -420,13 +424,14 @@ class InjectorTest(tests.Test):
             ]))), cmd='submit', initial=True)
 
         assert 'context' in injector._solve('context', 'stable')
-        volume['context'].delete('context')
+        conn.delete(['context', 'context'])
         assert 'context' in injector._solve('context', 'stable')
         os.unlink('client/solutions/context')
         self.assertRaises(http.NotFound, injector._solve, 'context', 'stable')
 
     def test_solve_InvalidateCachedSolution(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = 'http://127.0.0.1:7777'
@@ -492,7 +497,8 @@ class InjectorTest(tests.Test):
         self.assertEqual(['http://localhost:7777', 'stable', 2], json.load(file('client/solutions/context'))[:-1])
 
     def test_solve_ForceUsingStaleCachedSolutionInOffline(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -519,7 +525,8 @@ class InjectorTest(tests.Test):
         self.assertRaises(http.ServiceUnavailable, injector._solve, 'context', 'stable')
 
     def test_download_SetExecPermissions(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -552,7 +559,8 @@ class InjectorTest(tests.Test):
         assert not os.access(path + 'test/file2', os.X_OK)
 
     def test_checkin(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -603,7 +611,8 @@ class InjectorTest(tests.Test):
             [i for i in injector.checkin('context')])
 
     def test_checkin_PreemptivePool(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -660,7 +669,8 @@ class InjectorTest(tests.Test):
         self.assertEqual([], this.volume['context']['context']['pins'])
 
     def test_checkin_Refresh(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -694,7 +704,8 @@ class InjectorTest(tests.Test):
         assert exists('client/releases/%s' % release2)
 
     def test_launch(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -742,7 +753,8 @@ class InjectorTest(tests.Test):
             [i for i in injector.launch('context', activity_id='activity_id')])
 
     def test_launch_PreemptivePool(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -783,7 +795,8 @@ class InjectorTest(tests.Test):
         self.assertEqual(len(activity_info), injector._pool._du)
 
     def test_launch_DonntAcquireCheckins(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector('client')
         injector.api = client.api.value
@@ -810,7 +823,8 @@ class InjectorTest(tests.Test):
         assert injector._pool._du == 0
 
     def test_launch_RefreshCheckins(self):
-        self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector(tests.tmpdir + '/client')
         injector.api = client.api.value
@@ -862,7 +876,26 @@ class InjectorTest(tests.Test):
         self.assertEqual('2', file('client/releases/%s/output' % release2).read())
 
     def test_launch_InstallDeps(self):
-        volume = self.start_master()
+
+        def master_cb(volume):
+            distro = '%s-%s' % (lsb_release.distributor_id(), lsb_release.release())
+            volume['context'].create({
+                'guid': 'package1', 'type': ['package'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
+                    'resolves': {
+                        distro: {'version': [[1], 0], 'packages': ['pkg1', 'pkg2']},
+                        },
+                    },
+                })
+            volume['context'].create({
+                'guid': 'package2', 'type': ['package'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
+                    'resolves': {
+                        distro: {'version': [[1], 0], 'packages': ['pkg3', 'pkg4']},
+                        },
+                    },
+                })
+
+        self.fork_master(cb=master_cb)
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector(tests.tmpdir + '/client')
         injector.api = client.api.value
@@ -878,21 +911,6 @@ class InjectorTest(tests.Test):
             'license = Public Domain',
             'requires = package1; package2',
             ]))), cmd='submit', initial=True)
-        distro = '%s-%s' % (lsb_release.distributor_id(), lsb_release.release())
-        volume['context'].create({
-            'guid': 'package1', 'type': ['package'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                'resolves': {
-                    distro: {'version': [[1], 0], 'packages': ['pkg1', 'pkg2']},
-                    },
-                },
-            })
-        volume['context'].create({
-            'guid': 'package2', 'type': ['package'], 'title': {}, 'summary': {}, 'description': {}, 'releases': {
-                'resolves': {
-                    distro: {'version': [[1], 0], 'packages': ['pkg3', 'pkg4']},
-                    },
-                },
-            })
 
         packages = []
         self.override(packagekit, 'install', lambda names: packages.extend(names))
@@ -902,14 +920,15 @@ class InjectorTest(tests.Test):
         self.assertEqual(['pkg1', 'pkg2', 'pkg3', 'pkg4'], sorted(packages))
 
     def test_launch_Document(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector(tests.tmpdir + '/client')
         injector.api = client.api.value
         injector.seqno = 1
 
-        volume['context'].create({'guid': 'book', 'type': ['book'], 'title': {}, 'summary': {}, 'description': {}})
-        book = conn.upload(['context'], 'book', cmd='submit', context='book', version='1', license='Public Domain')
+        book_context = conn.post(['context'], {'type': ['book'], 'title': {}, 'summary': {}, 'description': {}})
+        book = conn.upload(['context'], 'book', cmd='submit', context=book_context, version='1', license='Public Domain')
 
         app = conn.upload(['context'], self.zips(
             ('topdir/activity/activity.info', '\n'.join([
@@ -929,21 +948,22 @@ class InjectorTest(tests.Test):
 
         self.assertEqual(
                 {'event': 'launch', 'state': 'exit'},
-                [i for i in injector.launch('book', activity_id='activity_id', app='app')][-1])
+                [i for i in injector.launch(book_context, activity_id='activity_id', app='app')][-1])
 
         self.assertEqual(
                 '-b app -a activity_id -u %s/client/releases/%s' % (tests.tmpdir, book),
                 file('client/releases/%s/output' % app).read())
 
     def test_launch_DocumentWithDetectingAppByMIMEType(self):
-        volume = self.start_master()
+        self.fork_master()
+        this.volume = LocalVolume('client')
         conn = Connection(creds=SugarCreds(keyfile.value))
         injector = Injector(tests.tmpdir + '/client')
         injector.api = client.api.value
         injector.seqno = 1
 
-        volume['context'].create({'guid': 'book', 'type': ['book'], 'title': {}, 'summary': {}, 'description': {}})
-        book = conn.upload(['context'], 'book', cmd='submit', context='book', version='1', license='Public Domain')
+        book_context = conn.post(['context'], {'type': ['book'], 'title': {}, 'summary': {}, 'description': {}})
+        book = conn.upload(['context'], 'book', cmd='submit', context=book_context, version='1', license='Public Domain')
 
         app = conn.upload(['context'], self.zips(
             ('topdir/activity/activity.info', '\n'.join([
@@ -964,7 +984,7 @@ class InjectorTest(tests.Test):
         self.override(injector_, '_app_by_mimetype', lambda mime_type: 'app')
         self.assertEqual(
                 {'event': 'launch', 'state': 'exit'},
-                [i for i in injector.launch('book', activity_id='activity_id')][-1])
+                [i for i in injector.launch(book_context, activity_id='activity_id')][-1])
 
         self.assertEqual(
                 '-b app -a activity_id -u %s/client/releases/%s' % (tests.tmpdir, book),
diff --git a/tests/units/client/routes.py b/tests/units/client/routes.py
index 6072571..9145b42 100755
--- a/tests/units/client/routes.py
+++ b/tests/units/client/routes.py
@@ -12,7 +12,7 @@ from os.path import exists
 from __init__ import tests
 
 from sugar_network import db, client, toolkit
-from sugar_network.client import journal, IPCConnection, cache_limit, cache_lifetime, api, injector, routes
+from sugar_network.client import journal, Connection, IPCConnection, cache_limit, cache_lifetime, api, injector, routes
 from sugar_network.client.model import Volume
 from sugar_network.client.injector import Injector
 from sugar_network.client.routes import ClientRoutes
@@ -81,25 +81,19 @@ class RoutesTest(tests.Test):
                 ]),
             ], header={'to': '127.0.0.1:7777', 'from': 'slave'})), params={'cmd': 'push'})
 
-        self.assertEqual([
-            {'guid': '1'},
-            {'guid': '2'},
-            ],
-            ipc.get(['context'], query='йцу')['result'])
-        self.assertEqual([
-            {'guid': '1'},
-            {'guid': '2'},
-            ],
-            ipc.get(['context'], query='qwe')['result'])
+        self.assertEqual(
+                sorted(['1', '2']),
+                sorted([i['guid'] for i in ipc.get(['context'], query='йцу')['result']]))
+        self.assertEqual(
+                sorted(['1', '2']),
+                sorted([i['guid'] for i in ipc.get(['context'], query='qwe')['result']]))
 
-        self.assertEqual([
-            {'guid': '2'},
-            ],
-            ipc.get(['context'], query='йцукен')['result'])
-        self.assertEqual([
-            {'guid': '2'},
-            ],
-            ipc.get(['context'], query='qwerty')['result'])
+        self.assertEqual(
+                sorted(['2']),
+                sorted([i['guid'] for i in ipc.get(['context'], query='йцукен')['result']]))
+        self.assertEqual(
+                sorted(['2']),
+                sorted([i['guid'] for i in ipc.get(['context'], query='qwerty')['result']]))
 
     def test_LanguagesFallbackInRequests(self):
         self.start_online_client()
@@ -340,14 +334,12 @@ class RoutesTest(tests.Test):
         self.assertEqual(
                 blob,
                 ipc.request('GET', ['context', guid, 'logo']).content)
-        self.assertEqual({
-            'logo': 'http://127.0.0.1:7777/blobs/%s' % digest,
-            },
-            ipc.get(['context', guid], reply=['logo']))
-        self.assertEqual([{
-            'logo': 'http://127.0.0.1:7777/blobs/%s' % digest,
-            }],
-            ipc.get(['context'], reply=['logo'])['result'])
+        self.assertEqual(
+                'http://127.0.0.1:7777/blobs/%s' % digest,
+                ipc.get(['context', guid], reply=['logo'])['logo'])
+        self.assertEqual(
+                ['http://127.0.0.1:7777/blobs/%s' % digest],
+                [i['logo'] for i in ipc.get(['context'], reply=['logo'])['result']])
 
     def test_OnlinePins(self):
         home_volume = self.start_online_client()
@@ -388,13 +380,9 @@ class RoutesTest(tests.Test):
             'description': 'description',
             })
 
-        self.assertEqual(sorted([
-            {'guid': guid1, 'title': '1', 'pins': []},
-            {'guid': guid2, 'title': '2', 'pins': []},
-            {'guid': guid3, 'title': '3', 'pins': []},
-            {'guid': guid4, 'title': '4', 'pins': []},
-            ]),
-            sorted(ipc.get(['context'], reply=['guid', 'title', 'pins'])['result']))
+        self.assertEqual(
+                sorted([(guid1, []), (guid2, []), (guid3, []), (guid4, [])]),
+                sorted([(i['guid'], i['pins']) for i in ipc.get(['context'], reply=['pins'])['result']]))
         self.assertEqual([
             ],
             ipc.get(['context'], reply=['guid', 'title'], pins='favorite')['result'])
@@ -420,34 +408,25 @@ class RoutesTest(tests.Test):
         home_volume['context'].update(guid2, {'title': {i18n.default_lang(): '2_'}})
         home_volume['context'].update(guid3, {'title': {i18n.default_lang(): '3_'}})
 
-        self.assertEqual(sorted([
-            {'guid': guid1, 'title': '1', 'pins': ['favorite']},
-            {'guid': guid2, 'title': '2', 'pins': ['checkin', 'favorite']},
-            {'guid': guid3, 'title': '3', 'pins': ['checkin']},
-            {'guid': guid4, 'title': '4', 'pins': []},
-            ]),
-            sorted(ipc.get(['context'], reply=['guid', 'title', 'pins'])['result']))
+        self.assertEqual(
+                sorted([(guid1, ['favorite']), (guid2, ['checkin', 'favorite']), (guid3, ['checkin']), (guid4, [])]),
+                sorted([(i['guid'], i['pins']) for i in ipc.get(['context'], reply=['pins'])['result']]))
         self.assertEqual([
             {'guid': guid1, 'title': '1_'},
             {'guid': guid2, 'title': '2_'},
             ],
             ipc.get(['context'], reply=['guid', 'title'], pins='favorite')['result'])
-        self.assertEqual([
-            {'guid': guid2, 'title': '2_'},
-            {'guid': guid3, 'title': '3_'},
-            ],
-            ipc.get(['context'], reply=['guid', 'title'], pins='checkin')['result'])
+
+        self.assertEqual(
+                sorted([(guid2, '2_'), (guid3, '3_')]),
+                sorted([(i['guid'], i['title']) for i in ipc.get(['context'], reply=['guid', 'title'], pins='checkin')['result']]))
 
         ipc.delete(['context', guid1], cmd='favorite')
         ipc.delete(['context', guid2], cmd='checkin')
 
-        self.assertEqual(sorted([
-            {'guid': guid1, 'pins': []},
-            {'guid': guid2, 'pins': ['favorite']},
-            {'guid': guid3, 'pins': ['checkin']},
-            {'guid': guid4, 'pins': []},
-            ]),
-            sorted(ipc.get(['context'], reply=['guid', 'pins'])['result']))
+        self.assertEqual(
+                sorted([(guid1, []), (guid2, ['favorite']), (guid3, ['checkin']), (guid4, [])]),
+                sorted([(i['guid'], i['pins']) for i in ipc.get(['context'], reply=['pins'])['result']]))
         self.assertEqual([
             {'guid': guid2, 'pins': ['favorite']},
             ],
@@ -496,12 +475,9 @@ class RoutesTest(tests.Test):
             {'event': 'checkin', 'state': 'ready'},
             ],
             [i for i in ipc.put(['context', '2'], None, cmd='checkin')])
-        self.assertEqual([
-            {'guid': '1', 'pins': ['favorite']},
-            {'guid': '2', 'pins': ['checkin']},
-            {'guid': '3', 'pins': []},
-            ],
-            ipc.get(['context'], reply=['guid', 'pins'])['result'])
+        self.assertEqual(
+                sorted([('1', ['favorite']), ('2', ['checkin']), ('3', [])]),
+                sorted([(i['guid'], i['pins']) for i in ipc.get(['context'], reply=['guid', 'pins'])['result']]))
 
         self.stop_master()
         self.wait_for_events(event='inline', state='offline').wait()
@@ -692,8 +668,7 @@ class RoutesTest(tests.Test):
         ipc = IPCConnection()
 
         self.assertEqual([
-            {'event': 'checkin', 'state': 'solve'},
-            {'error': 'Context not found', 'event': 'failure', 'exception': 'NotFound'},
+            {'error': 'Resource not found', 'event': 'failure', 'exception': 'NotFound'},
             ],
             [i for i in ipc.put(['context', 'context'], None, cmd='checkin')])
 
@@ -862,11 +837,10 @@ class RoutesTest(tests.Test):
         self.assertEqual('done', events[-1]['event'])
         guid = events[-1]['guid']
 
-        self.assertEqual({
-            'context': 'context',
-            'error': 'error',
-            },
-            ipc.get(['report', guid], reply=['context', 'error']))
+        report = ipc.get(['report', guid], reply=['context', 'error'])
+        self.assertEqual('context', report['context'])
+        self.assertEqual('error', report['error'])
+
         self.assertEqual(sorted([
             'content1',
             'content2',
@@ -1016,7 +990,7 @@ class RoutesTest(tests.Test):
         assert time.time() - ts >= 2
 
         def kill():
-            coroutine.sleep(.5)
+            coroutine.sleep(.4)
             self.waitpid(node_pid)
 
         coroutine.spawn(kill)
@@ -1095,13 +1069,114 @@ class RoutesTest(tests.Test):
         self.assertEqual([{'event': 'pong'}], events)
         assert Routes.subscribe_tries > 2
 
+    def test_PullCheckinsOnGets(self):
+        local_volume = self.start_online_client()
+        local = IPCConnection()
+        remote = Connection(creds=SugarCreds(client.keyfile.value))
+
+        self.assertEqual([[1, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
+
+        guid = remote.post(['context'], {
+            'type': 'activity',
+            'title': '1',
+            'summary': '',
+            'description': '',
+            })
+        local.put(['context', guid], None, cmd='favorite')
+        self.assertEqual('1', remote.get(['context', guid, 'title']))
+        self.assertEqual('1', local.get(['context', guid])['title'])
+        coroutine.sleep(1.1)
+
+        self.assertEqual([[1, 1], [6, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
 
+        remote.put(['context', guid, 'title'], '2')
+        self.assertEqual('2', remote.get(['context', guid, 'title']))
+        self.assertEqual('1', local.get(['context', guid])['title'])
 
+        self.assertEqual([[1, 1], [6, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
 
+        self.assertEqual('2', local.get(['context'], reply='title')['result'][0]['title'])
+        coroutine.sleep(.1)
+        self.assertEqual('2', remote.get(['context', guid, 'title']))
+        self.assertEqual('2', local.get(['context', guid])['title'])
 
+        self.assertEqual([[1, 1], [7, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
 
+    def test_PullCheckinsOnGettingOnline(self):
+        routes._RECONNECT_TIMEOUT = 1
+        routes._SYNC_TIMEOUT = 0
 
+        local_volume = self.start_online_client()
+        local = IPCConnection()
+        remote = Connection(creds=SugarCreds(client.keyfile.value))
+
+        self.assertEqual([[1, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
+
+        guid = remote.post(['context'], {
+            'type': 'activity',
+            'title': '1',
+            'summary': '',
+            'description': '',
+            })
+        local.put(['context', guid], None, cmd='favorite')
+        self.assertEqual('1', remote.get(['context', guid, 'title']))
+        self.assertEqual('1', local.get(['context', guid])['title'])
+        coroutine.sleep(1.1)
+
+        remote.put(['context', guid, 'title'], '2')
+        self.assertEqual('2', remote.get(['context', guid, 'title']))
+        self.assertEqual('1', local.get(['context', guid])['title'])
+        self.assertEqual([[1, 1], [6, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
+
+        self.stop_master()
+        self.wait_for_events(event='inline', state='offline').wait()
+        self.fork_master()
+        self.wait_for_events(event='sync', state='pull').wait()
+
+        self.assertEqual('2', local.get(['context', guid])['title'])
+        self.assertEqual([[1, 1], [7, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
+
+    def test_PullCheckinsOnUpdates(self):
+        local_volume = self.start_online_client()
+        local = IPCConnection()
+        remote = Connection(creds=SugarCreds(client.keyfile.value))
+
+        self.assertEqual([[1, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
+
+        guid = remote.post(['context'], {
+            'type': 'activity',
+            'title': '1',
+            'summary': '1',
+            'description': '',
+            })
+        local.put(['context', guid], None, cmd='favorite')
+        self.assertEqual('1', remote.get(['context', guid, 'title']))
+        self.assertEqual('1', local.get(['context', guid])['title'])
+        coroutine.sleep(1.1)
 
+        remote.put(['context', guid, 'title'], '2')
+        self.assertEqual('2', remote.get(['context', guid, 'title']))
+        self.assertEqual('1', remote.get(['context', guid, 'summary']))
+        self.assertEqual('1', local.get(['context', guid])['title'])
+        self.assertEqual('1', local.get(['context', guid])['summary'])
+        self.assertEqual([[1, 1], [6, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
+
+        local.put(['context', guid, 'summary'], '2')
+        self.assertEqual('2', remote.get(['context', guid, 'title']))
+        self.assertEqual('2', remote.get(['context', guid, 'summary']))
+        self.assertEqual('2', local.get(['context', guid])['title'])
+        self.assertEqual('2', local.get(['context', guid])['summary'])
+        self.assertEqual([[1, 1], [8, None]], self.client_routes._pull_r.value)
+        self.assertEqual(0, local_volume.seqno.value)
 
     def ___test_CachedClientRoutes(self):
         volume = db.Volume('client', RESOURCES, lazy_open=True)
diff --git a/tests/units/db/index.py b/tests/units/db/index.py
index cb144c6..c0072c1 100755
--- a/tests/units/db/index.py
+++ b/tests/units/db/index.py
@@ -420,14 +420,18 @@ class IndexTest(tests.Test):
         post_stored = []
         deleted = []
 
+        def pre_stored_cb(*args):
+            pre_stored.append(args)
+            return {}
+
         db.store('1', {},
-                lambda *args: pre_stored.append(args),
+                pre_stored_cb,
                 lambda *args: post_stored.append(args))
         self.assertEqual(1, len(pre_stored))
         self.assertEqual(1, len(post_stored))
 
         db.store('1', {},
-                lambda *args: pre_stored.append(args),
+                pre_stored_cb,
                 lambda *args: post_stored.append(args))
         self.assertEqual(2, len(pre_stored))
         self.assertEqual(2, len(post_stored))
diff --git a/tests/units/db/resource.py b/tests/units/db/resource.py
index 05aaddf..4bf80b7 100755
--- a/tests/units/db/resource.py
+++ b/tests/units/db/resource.py
@@ -483,6 +483,45 @@ class ResourceTest(tests.Test):
         self.assertEqual('set2!', doc['prop1'])
         self.assertEqual('set2!', doc['prop3'])
 
+    def test_diff_OutputRange(self):
+
+        class Document(db.Resource):
+
+            @db.stored_property()
+            def prop1(self, value):
+                return value
+
+            @db.stored_property()
+            def prop2(self, value):
+                return value
+
+        directory = Directory(tests.tmpdir, Document, IndexWriter, _SessionSeqno(), this.broadcast)
+
+        guid = directory.create({'prop1': '1', 'prop2': '1'})
+        self.utime('db', 0)
+
+        out_r = []
+        self.assertEqual({
+            'guid': {'mtime': 0, 'value': guid},
+            'prop1': {'mtime': 0, 'value': '1'},
+            'prop2': {'mtime': 0, 'value': '1'},
+            },
+            directory[guid].diff([[1, None]], out_r))
+        self.assertEqual([[1, 1]], out_r)
+
+        directory.update(guid, {'prop1': '2'})
+        directory.update(guid, {'prop2': '2'})
+        self.utime('db', 0)
+
+        out_r = []
+        self.assertEqual({
+            'guid': {'mtime': 0, 'value': guid},
+            'prop1': {'mtime': 0, 'value': '2'},
+            'prop2': {'mtime': 0, 'value': '2'},
+            },
+            directory[guid].diff([[1, None]], out_r))
+        self.assertEqual([[1, 3]], out_r)
+
 
 class _SessionSeqno(object):
 
diff --git a/tests/units/db/routes.py b/tests/units/db/routes.py
index 4189502..5d5a547 100755
--- a/tests/units/db/routes.py
+++ b/tests/units/db/routes.py
@@ -3,6 +3,7 @@
 
 import os
 import sys
+import json
 import time
 import shutil
 import hashlib
@@ -16,10 +17,11 @@ src_root = abspath(dirname(__file__))
 from __init__ import tests
 
 from sugar_network import db, toolkit
+from sugar_network.db import routes as db_routes
 from sugar_network.model.user import User
 from sugar_network.toolkit.router import Router, Request, Response, fallbackroute, ACL, File
 from sugar_network.toolkit.coroutine import this
-from sugar_network.toolkit import coroutine, http, i18n
+from sugar_network.toolkit import coroutine, http, i18n, parcel
 
 
 class RoutesTest(tests.Test):
@@ -1942,6 +1944,169 @@ class RoutesTest(tests.Test):
                 [{'event': 'delete', 'resource': 'document', 'guid': guid}],
                 events)
 
+    def test_ObjectDiff(self):
+
+        class Document(db.Resource):
+
+            @db.stored_property()
+            def prop1(self, value):
+                return value
+
+            @db.stored_property()
+            def prop2(self, value):
+                return value
+
+            @db.stored_property(db.Blob)
+            def prop3(self, value):
+                return value
+
+            @db.stored_property(db.Blob)
+            def prop4(self, value):
+                return value
+
+        volume = db.Volume('.', [Document])
+        router = Router(db.Routes(volume))
+
+        volume['document'].create({
+            'guid': 'guid',
+            'prop1': '1',
+            'prop2': 2,
+            'prop3': volume.blobs.post('333', '3/3').digest,
+            })
+        volume['document'].update('guid', {'prop4': volume.blobs.post('4444', '4/4').digest})
+        self.utime('db/document/gu/guid', 1)
+
+        patch = ''.join([i for i in this.call(method='GET', path=['document', 'guid'], cmd='diff')])
+        self.assertEqual([(
+            {'packet': None}, [
+                {'resource': 'document'},
+                {'guid': 'guid', 'patch': {
+                    'guid': {'value': 'guid', 'mtime': 1},
+                    'prop1': {'value': '1', 'mtime': 1},
+                    'prop2': {'value': 2, 'mtime': 1},
+                    'prop3': {'value': hashlib.sha1('333').hexdigest(), 'mtime': 1},
+                    'prop4': {'value': hashlib.sha1('4444').hexdigest(), 'mtime': 1},
+                    }},
+                {'content-type': '4/4', 'content-length': '4', 'x-seqno': '3'},
+                {'content-type': '3/3', 'content-length': '3', 'x-seqno': '1'},
+                {'commit': [[1, 4]]},
+                ],
+            )],
+            [(packet.header, [i.meta if isinstance(i, File) else i for i in packet]) for packet in parcel.decode(StringIO(patch))])
+
+        patch = ''.join([i for i in this.call(method='GET', path=['document', 'guid'], cmd='diff', environ={
+            'HTTP_X_RANGE': json.dumps([[1, 1]]),
+            })])
+        self.assertEqual([(
+            {'packet': None}, [],
+            )],
+            [(packet.header, [i.meta if isinstance(i, File) else i for i in packet]) for packet in parcel.decode(StringIO(patch))])
+
+        patch = ''.join([i for i in this.call(method='GET', path=['document', 'guid'], cmd='diff', environ={
+            'HTTP_X_RANGE': json.dumps([[2, 2]]),
+            })])
+        self.assertEqual([(
+            {'packet': None}, [
+                {'resource': 'document'},
+                {'guid': 'guid', 'patch': {
+                    'guid': {'value': 'guid', 'mtime': 1},
+                    'prop1': {'value': '1', 'mtime': 1},
+                    'prop2': {'value': 2, 'mtime': 1},
+                    'prop3': {'value': hashlib.sha1('333').hexdigest(), 'mtime': 1},
+                    }},
+                {'content-type': '3/3', 'content-length': '3', 'x-seqno': '1'},
+                {'commit': [[1, 2]]},
+                ],
+            )],
+            [(packet.header, [i.meta if isinstance(i, File) else i for i in packet]) for packet in parcel.decode(StringIO(patch))])
+
+        patch = ''.join([i for i in this.call(method='GET', path=['document', 'guid'], cmd='diff', environ={
+            'HTTP_X_RANGE': json.dumps([[3, 3]]),
+            })])
+        self.assertEqual([(
+            {'packet': None}, [],
+            )],
+            [(packet.header, [i.meta if isinstance(i, File) else i for i in packet]) for packet in parcel.decode(StringIO(patch))])
+
+        patch = ''.join([i for i in this.call(method='GET', path=['document', 'guid'], cmd='diff', environ={
+            'HTTP_X_RANGE': json.dumps([[4, 4]]),
+            })])
+        self.assertEqual([(
+            {'packet': None}, [
+                {'resource': 'document'},
+                {'guid': 'guid', 'patch': {
+                    'prop4': {'value': hashlib.sha1('4444').hexdigest(), 'mtime': 1},
+                    }},
+                {'content-type': '4/4', 'content-length': '4', 'x-seqno': '3'},
+                {'commit': [[3, 4]]},
+                ],
+            )],
+            [(packet.header, [i.meta if isinstance(i, File) else i for i in packet]) for packet in parcel.decode(StringIO(patch))])
+
+    def test_GroupedDiff(self):
+
+        class Document(db.Resource):
+
+            @db.stored_property()
+            def prop(self, value):
+                return value
+
+        volume = db.Volume('.', [Document])
+        router = Router(db.Routes(volume))
+
+        volume['document'].create({'guid': '1', 'prop': 'q'})
+        volume['document'].create({'guid': '2', 'prop': 'w'})
+        volume['document'].create({'guid': '3', 'prop': 'w'})
+        volume['document'].create({'guid': '4', 'prop': 'e'})
+        volume['document'].create({'guid': '5', 'prop': 'e'})
+        volume['document'].create({'guid': '6', 'prop': 'e'})
+        self.utime('db/document', 0)
+
+        self.assertEqual({
+            '1': [[1, 1]],
+            '2': [[2, 2]],
+            '3': [[3, 3]],
+            '4': [[4, 4]],
+            '5': [[5, 5]],
+            '6': [[6, 6]],
+            },
+            this.call(method='GET', path=['document'], cmd='diff'))
+
+        self.assertEqual({
+            'q': [[1, 1]],
+            'w': [[2, 3]],
+            'e': [[4, 6]],
+            },
+            this.call(method='GET', path=['document'], cmd='diff', key='prop'))
+
+    def test_GroupedDiffLimit(self):
+        db_routes._GROUPED_DIFF_LIMIT = 2
+
+        class Document(db.Resource):
+            pass
+
+        volume = db.Volume('.', [Document])
+        router = Router(db.Routes(volume))
+
+        volume['document'].create({'guid': '1'})
+        volume['document'].create({'guid': '2'})
+        volume['document'].create({'guid': '3'})
+        volume['document'].create({'guid': '4'})
+        volume['document'].create({'guid': '5'})
+        self.utime('db/document', 0)
+
+        self.assertEqual({
+            '1': [[1, 1]],
+            '2': [[2, 2]],
+            },
+            this.call(method='GET', path=['document'], cmd='diff'))
+
+        self.assertEqual({
+            '3': [[3, 3]],
+            '4': [[4, 4]],
+            },
+            this.call(method='GET', path=['document'], cmd='diff', environ={'HTTP_X_RANGE': json.dumps([[3, None]])}))
+
 
 if __name__ == '__main__':
     tests.main()
diff --git a/tests/units/db/volume.py b/tests/units/db/volume.py
index 22d4782..a770a35 100755
--- a/tests/units/db/volume.py
+++ b/tests/units/db/volume.py
@@ -323,51 +323,6 @@ class VolumeTest(tests.Test):
         self.assertRaises(StopIteration, patch.next)
         self.assertEqual([[4, None]], r)
 
-    def test_clone(self):
-
-        class Document(db.Resource):
-
-            @db.stored_property()
-            def prop1(self, value):
-                return value
-
-            @db.stored_property()
-            def prop2(self, value):
-                return value
-
-            @db.stored_property(db.Blob)
-            def prop3(self, value):
-                return value
-
-            @db.stored_property(db.Blob)
-            def prop4(self, value):
-                return value
-
-        volume = db.Volume('.', [Document])
-
-        volume['document'].create({
-            'guid': 'guid',
-            'prop1': '1',
-            'prop2': 2,
-            'prop3': volume.blobs.post('333', '3/3').digest,
-            'prop4': volume.blobs.post('4444', '4/4').digest,
-            })
-        self.utime('db/document/gu/guid', 1)
-
-        self.assertEqual([
-            {'content-type': '3/3', 'content-length': '3', 'x-seqno': '1'},
-            {'content-type': '4/4', 'content-length': '4', 'x-seqno': '2'},
-            {'resource': 'document'},
-            {'guid': 'guid', 'patch': {
-                'guid': {'value': 'guid', 'mtime': 1},
-                'prop1': {'value': '1', 'mtime': 1},
-                'prop2': {'value': 2, 'mtime': 1},
-                'prop3': {'value': hashlib.sha1('333').hexdigest(), 'mtime': 1},
-                'prop4': {'value': hashlib.sha1('4444').hexdigest(), 'mtime': 1},
-                }},
-            ],
-            [i.meta if isinstance(i, File) else i for i in volume.clone('document', 'guid')])
-
     def test_patch_New(self):
 
         class Document(db.Resource):
@@ -973,6 +928,177 @@ class VolumeTest(tests.Test):
             [dict(i) for i in volume.diff(r, files=['foo'])])
         self.assertEqual([[4, None]], r)
 
+    def test_DoNotShiftSeqnoForLocalProps(self):
+
+        class Document(db.Resource):
+
+            @db.stored_property()
+            def prop1(self, value):
+                return value
+
+            @db.stored_property(acl=ACL.PUBLIC | ACL.LOCAL)
+            def prop2(self, value):
+                return value
+
+        directory = db.Volume('.', [Document])['document']
+
+        directory.create({'guid': '1', 'prop1': '1', 'prop2': '1', 'ctime': 1, 'mtime': 1})
+        self.utime('db/document', 0)
+        self.assertEqual(
+                {'seqno': 1, 'value': 1, 'mtime': 0},
+                directory['1'].meta('seqno'))
+        self.assertEqual(
+                {'seqno': 1, 'value': '1', 'mtime': 0},
+                directory['1'].meta('prop1'))
+        self.assertEqual(
+                {'value': '1', 'mtime': 0},
+                directory['1'].meta('prop2'))
+
+        directory.update('1', {'prop2': '2'})
+        self.utime('db/document', 0)
+        self.assertEqual(
+                {'seqno': 1, 'value': 1, 'mtime': 0},
+                directory['1'].meta('seqno'))
+        self.assertEqual(
+                {'seqno': 1, 'value': '1', 'mtime': 0},
+                directory['1'].meta('prop1'))
+        self.assertEqual(
+                {'value': '2', 'mtime': 0},
+                directory['1'].meta('prop2'))
+
+        directory.update('1', {'prop1': '2'})
+        self.utime('db/document', 0)
+        self.assertEqual(
+                {'seqno': 2, 'value': 2, 'mtime': 0},
+                directory['1'].meta('seqno'))
+        self.assertEqual(
+                {'seqno': 2, 'value': '2', 'mtime': 0},
+                directory['1'].meta('prop1'))
+        self.assertEqual(
+                {'value': '2', 'mtime': 0},
+                directory['1'].meta('prop2'))
+
+    def test_patch_SeqnoLess(self):
+
+        class Document(db.Resource):
+
+            @db.indexed_property(slot=1)
+            def prop(self, value):
+                return value
+
+        volume1 = db.Volume('1', [Document])
+        volume1['document'].create({'guid': '1', 'prop': '1', 'ctime': 1, 'mtime': 1})
+        self.utime('1/db/document/1/1', 1)
+        volume1.blobs.post('1')
+
+        volume2 = db.Volume('2', [Document])
+        volume2.patch(volume1.diff([[1, None]]), shift_seqno=False)
+
+        self.assertEqual(
+                [(1, '1', 1, '1')],
+                [(i['ctime'], i['prop'], i['mtime'], i['guid']) for i in volume2['document'].find()[0]])
+
+        doc = volume2['document'].get('1')
+        self.assertEqual(0, doc.get('seqno'))
+        assert 'seqno' not in doc.meta('guid')
+        assert 'seqno' not in doc.meta('ctime')
+        assert 'seqno' not in doc.meta('mtime')
+        assert 'seqno' not in doc.meta('prop')
+
+        blob = volume2.blobs.get(hashlib.sha1('1').hexdigest())
+        self.assertEqual({
+            'x-seqno': '0',
+            'content-length': '1',
+            'content-type': 'application/octet-stream',
+            },
+            blob.meta)
+        self.assertEqual('1', file(blob.path).read())
+
+    def test_diff_IgnoreSeqnolessUpdates(self):
+
+        class Document(db.Resource):
+
+            @db.stored_property()
+            def prop1(self, value):
+                return value
+
+            @db.stored_property(acl=ACL.PUBLIC | ACL.LOCAL)
+            def prop2(self, value):
+                return value
+
+        volume = db.Volume('.', [Document])
+
+        volume['document'].create({'guid': '1', 'prop1': '1', 'prop2': '1', 'ctime': 1, 'mtime': 1})
+        self.utime('db/document/1/1', 1)
+
+        r = [[1, None]]
+        self.assertEqual([
+            {'resource': 'document'},
+            {'guid': '1', 'patch': {
+                'guid': {'value': '1', 'mtime': 1},
+                'ctime': {'value': 1, 'mtime': 1},
+                'prop1': {'value': '1', 'mtime': 1},
+                'mtime': {'value': 1, 'mtime': 1},
+                }},
+            {'commit': [[1, 1]]},
+            ],
+            [i.meta if isinstance(i, File) else i for i in volume.diff(r)])
+        self.assertEqual([[2, None]], r)
+
+        volume['document'].update('1', {'prop2': '2'})
+        self.utime('db/document/1/1', 1)
+
+        r = [[1, None]]
+        self.assertEqual([
+            {'resource': 'document'},
+            {'guid': '1', 'patch': {
+                'guid': {'value': '1', 'mtime': 1},
+                'ctime': {'value': 1, 'mtime': 1},
+                'prop1': {'value': '1', 'mtime': 1},
+                'mtime': {'value': 1, 'mtime': 1},
+                }},
+            {'commit': [[1, 1]]},
+            ],
+            [i.meta if isinstance(i, File) else i for i in volume.diff(r)])
+        self.assertEqual([[2, None]], r)
+
+        volume['document'].update('1', {'prop1': '2'})
+        self.utime('db/document/1/1', 1)
+
+        r = [[1, None]]
+        self.assertEqual([
+            {'resource': 'document'},
+            {'guid': '1', 'patch': {
+                'guid': {'value': '1', 'mtime': 1},
+                'ctime': {'value': 1, 'mtime': 1},
+                'prop1': {'value': '2', 'mtime': 1},
+                'mtime': {'value': 1, 'mtime': 1},
+                }},
+            {'commit': [[1, 2]]},
+            ],
+            [i.meta if isinstance(i, File) else i for i in volume.diff(r)])
+        self.assertEqual([[3, None]], r)
+
+        self.assertEqual(False, volume['document'].patch('1', {'prop1': {'mtime': 2, 'value': '3'}}, seqno=False))
+        self.assertEqual('3', volume['document']['1']['prop1'])
+        self.utime('db/document/1/1', 1)
+
+        r = [[1, None]]
+        self.assertEqual([
+            {'resource': 'document'},
+            {'guid': '1', 'patch': {
+                'guid': {'value': '1', 'mtime': 1},
+                'ctime': {'value': 1, 'mtime': 1},
+                'mtime': {'value': 1, 'mtime': 1},
+                }},
+            {'commit': [[1, 2]]},
+            ],
+            [i.meta if isinstance(i, File) else i for i in volume.diff(r)])
+        self.assertEqual([[3, None]], r)
+
+
+
+
 
 class _SessionSeqno(object):
 
diff --git a/tests/units/node/slave.py b/tests/units/node/slave.py
index 2b32b70..10e5742 100755
--- a/tests/units/node/slave.py
+++ b/tests/units/node/slave.py
@@ -107,7 +107,6 @@ class SlaveTest(tests.Test):
         self.assertEqual([[7, None]], json.load(file('slave/var/push.ranges')))
 
         coroutine.sleep(1)
-        slave.put(['document', guid1], {'message': 'a'})
         slave.put(['document', guid2], {'message': 'b'})
         slave.put(['document', guid3], {'message': 'c'})
         guid4 = slave.post(['document'], {'message': 'd', 'title': ''})
@@ -119,7 +118,7 @@ class SlaveTest(tests.Test):
             ]),
             sorted(master.get(['document'], reply=['guid', 'message'])['result']))
         self.assertEqual([[6, None]], json.load(file('slave/var/pull.ranges')))
-        self.assertEqual([[12, None]], json.load(file('slave/var/push.ranges')))
+        self.assertEqual([[11, None]], json.load(file('slave/var/push.ranges')))
 
     def test_online_sync_Pull(self):
         self.fork_master([User, self.Document])
@@ -172,7 +171,6 @@ class SlaveTest(tests.Test):
         self.assertEqual([[5, None]], json.load(file('slave/var/push.ranges')))
 
         coroutine.sleep(1)
-        master.put(['document', guid1], {'message': 'a'})
         master.put(['document', guid2], {'message': 'b'})
         master.put(['document', guid3], {'message': 'c'})
         guid4 = master.post(['document'], {'message': 'd', 'title': ''})
@@ -183,7 +181,7 @@ class SlaveTest(tests.Test):
             {'guid': guid4, 'message': 'd'},
             ],
             slave.get(['document'], reply=['guid', 'message'])['result'])
-        self.assertEqual([[12, None]], json.load(file('slave/var/pull.ranges')))
+        self.assertEqual([[11, None]], json.load(file('slave/var/pull.ranges')))
         self.assertEqual([[6, None]], json.load(file('slave/var/push.ranges')))
 
     def test_online_sync_PullBlobs(self):
diff --git a/tests/units/toolkit/parcel.py b/tests/units/toolkit/parcel.py
index 1a24a3f..17fa146 100755
--- a/tests/units/toolkit/parcel.py
+++ b/tests/units/toolkit/parcel.py
@@ -18,7 +18,7 @@ from sugar_network.toolkit import parcel, http, coroutine
 
 class ParcelTest(tests.Test):
 
-    def test_decode(self):
+    def test_decode_Zipped(self):
         stream = zips(
             json.dumps({'foo': 'bar'}) + '\n'
             )
@@ -96,7 +96,85 @@ class ParcelTest(tests.Test):
         self.assertRaises(StopIteration, packets_iter.next)
         self.assertEqual(len(stream.getvalue()), stream.tell())
 
-    def test_decode_WithLimit(self):
+    def test_decode_NotZipped(self):
+        stream = StringIO(
+            json.dumps({'foo': 'bar'}) + '\n'
+            )
+        packets_iter = parcel.decode(stream)
+        self.assertRaises(EOFError, packets_iter.next)
+        self.assertEqual(len(stream.getvalue()), stream.tell())
+
+        stream = StringIO(
+            json.dumps({'foo': 'bar'}) + '\n' +
+            json.dumps({'packet': 1, 'bar': 'foo'}) + '\n'
+            )
+        packets_iter = parcel.decode(stream)
+        with next(packets_iter) as packet:
+            self.assertEqual(1, packet.name)
+            self.assertEqual('foo', packet['bar'])
+            packet_iter = iter(packet)
+            self.assertRaises(EOFError, packet_iter.next)
+        self.assertRaises(EOFError, packets_iter.next)
+        self.assertEqual(len(stream.getvalue()), stream.tell())
+
+        stream = StringIO(
+            json.dumps({'foo': 'bar'}) + '\n' +
+            json.dumps({'packet': 1, 'bar': 'foo'}) + '\n' +
+            json.dumps({'payload': 1}) + '\n'
+            )
+        packets_iter = parcel.decode(stream)
+        with next(packets_iter) as packet:
+            self.assertEqual(1, packet.name)
+            packet_iter = iter(packet)
+            self.assertEqual({'payload': 1}, next(packet_iter))
+            self.assertRaises(EOFError, packet_iter.next)
+        self.assertRaises(EOFError, packets_iter.next)
+        self.assertEqual(len(stream.getvalue()), stream.tell())
+
+        stream = StringIO(
+            json.dumps({'foo': 'bar'}) + '\n' +
+            json.dumps({'packet': 1, 'bar': 'foo'}) + '\n' +
+            json.dumps({'payload': 1}) + '\n' +
+            json.dumps({'packet': 2}) + '\n' +
+            json.dumps({'payload': 2}) + '\n'
+            )
+        packets_iter = parcel.decode(stream)
+        with next(packets_iter) as packet:
+            self.assertEqual(1, packet.name)
+            packet_iter = iter(packet)
+            self.assertEqual({'payload': 1}, next(packet_iter))
+            self.assertRaises(StopIteration, packet_iter.next)
+        with next(packets_iter) as packet:
+            self.assertEqual(2, packet.name)
+            packet_iter = iter(packet)
+            self.assertEqual({'payload': 2}, next(packet_iter))
+            self.assertRaises(EOFError, packet_iter.next)
+        self.assertRaises(EOFError, packets_iter.next)
+        self.assertEqual(len(stream.getvalue()), stream.tell())
+
+        stream = StringIO(
+            json.dumps({'foo': 'bar'}) + '\n' +
+            json.dumps({'packet': 1, 'bar': 'foo'}) + '\n' +
+            json.dumps({'payload': 1}) + '\n' +
+            json.dumps({'packet': 2}) + '\n' +
+            json.dumps({'payload': 2}) + '\n' +
+            json.dumps({'packet': 'last'}) + '\n'
+            )
+        packets_iter = parcel.decode(stream)
+        with next(packets_iter) as packet:
+            self.assertEqual(1, packet.name)
+            packet_iter = iter(packet)
+            self.assertEqual({'payload': 1}, next(packet_iter))
+            self.assertRaises(StopIteration, packet_iter.next)
+        with next(packets_iter) as packet:
+            self.assertEqual(2, packet.name)
+            packet_iter = iter(packet)
+            self.assertEqual({'payload': 2}, next(packet_iter))
+            self.assertRaises(StopIteration, packet_iter.next)
+        self.assertRaises(StopIteration, packets_iter.next)
+        self.assertEqual(len(stream.getvalue()), stream.tell())
+
+    def test_decode_ZippedWithLimit(self):
         payload = zips(
             json.dumps({}) + '\n' +
             json.dumps({'packet': 'first'}) + '\n' +
@@ -114,6 +192,24 @@ class ParcelTest(tests.Test):
             pass
         self.assertEqual(len(payload), stream.tell())
 
+    def test_decode_NotZippedWithLimit(self):
+        payload = StringIO(
+            json.dumps({}) + '\n' +
+            json.dumps({'packet': 'first'}) + '\n' +
+            json.dumps({'packet': 'last'}) + '\n'
+            ).getvalue()
+        tail = '.' * 100
+
+        stream = StringIO(payload + tail)
+        for i in parcel.decode(stream):
+            pass
+        self.assertEqual(len(payload + tail), stream.tell())
+
+        stream = StringIO(payload + tail)
+        for i in parcel.decode(stream, limit=len(payload)):
+            pass
+        self.assertEqual(len(payload), stream.tell())
+
     def test_decode_Empty(self):
         self.assertRaises(http.BadRequest, parcel.decode(StringIO()).next)
 
@@ -254,7 +350,7 @@ class ParcelTest(tests.Test):
         self.assertRaises(StopIteration, packets_iter.next)
         self.assertEqual(len(stream.getvalue()), stream.tell())
 
-    def test_encode(self):
+    def test_encode_Zipped(self):
         stream = ''.join([i for i in parcel.encode([])])
         self.assertEqual(
                 json.dumps({}) + '\n' +
@@ -300,6 +396,52 @@ class ParcelTest(tests.Test):
                 json.dumps({'packet': 'last'}) + '\n',
                 unzips(stream))
 
+    def test_encode_NotZipped(self):
+        stream = ''.join([i for i in parcel.encode([], compresslevel=0)])
+        self.assertEqual(
+                json.dumps({}) + '\n' +
+                json.dumps({'packet': 'last'}) + '\n',
+                stream)
+
+        stream = ''.join([i for i in parcel.encode([(None, None, None)], header={'foo': 'bar'}, compresslevel=0)])
+        self.assertEqual(
+                json.dumps({'foo': 'bar'}) + '\n' +
+                json.dumps({'packet': None}) + '\n' +
+                json.dumps({'packet': 'last'}) + '\n',
+                stream)
+
+        stream = ''.join([i for i in parcel.encode([
+            (1, {}, None),
+            ('2', {'n': 2}, []),
+            ('3', {'n': 3}, iter([])),
+            ], compresslevel=0)])
+        self.assertEqual(
+                json.dumps({}) + '\n' +
+                json.dumps({'packet': 1}) + '\n' +
+                json.dumps({'packet': '2', 'n': 2}) + '\n' +
+                json.dumps({'packet': '3', 'n': 3}) + '\n' +
+                json.dumps({'packet': 'last'})  + '\n',
+                stream)
+
+        stream = ''.join([i for i in parcel.encode([
+            (1, None, [{1: 1}]),
+            (2, None, [{2: 2}, {2: 2}]),
+            (3, None, [{3: 3}, {3: 3}, {3: 3}]),
+            ], compresslevel=0)])
+        self.assertEqual(
+                json.dumps({}) + '\n' +
+                json.dumps({'packet': 1}) + '\n' +
+                json.dumps({1: 1}) + '\n' +
+                json.dumps({'packet': 2}) + '\n' +
+                json.dumps({2: 2}) + '\n' +
+                json.dumps({2: 2}) + '\n' +
+                json.dumps({'packet': 3}) + '\n' +
+                json.dumps({3: 3}) + '\n' +
+                json.dumps({3: 3}) + '\n' +
+                json.dumps({3: 3}) + '\n' +
+                json.dumps({'packet': 'last'}) + '\n',
+                stream)
+
     def test_limited_encode(self):
         RECORD = 1024 * 1024
 
diff --git a/tests/units/toolkit/router.py b/tests/units/toolkit/router.py
index e9ee798..63d4646 100755
--- a/tests/units/toolkit/router.py
+++ b/tests/units/toolkit/router.py
@@ -535,7 +535,7 @@ class RouterTest(tests.Test):
                 ['_afz'],
                 [i for i in router({'REQUEST_METHOD': 'PROBE', 'PATH_INFO': '/'}, lambda *args: None)])
 
-    def test_routes_Post(self):
+    def test_routes_Postroutes(self):
         postroutes = []
 
         class A(object):
@@ -551,24 +551,28 @@ class RouterTest(tests.Test):
             @postroute
             def _(self, result, exception):
                 postroutes.append(('_', result, str(exception)))
+                return result
 
         class B1(A):
 
             @postroute
             def z(self, result, exception):
                 postroutes.append(('z', result, str(exception)))
+                return result
 
         class B2(object):
 
             @postroute
             def f(self, result, exception):
                 postroutes.append(('f', result, str(exception)))
+                return result
 
         class C(B1, B2):
 
             @postroute
             def a(self, result, exception):
                 postroutes.append(('a', result, str(exception)))
+                return result
 
         router = Router(C())
 
@@ -595,6 +599,25 @@ class RouterTest(tests.Test):
             ],
             postroutes)
 
+    def test_routes_UpdateResultInPostroutes(self):
+        postroutes = []
+
+        class A(object):
+
+            @route('OK')
+            def ok(self):
+                return 'ok'
+
+            @postroute
+            def postroute(self, result, exception):
+                return result + '!'
+
+        router = Router(A())
+
+        self.assertEqual(
+                ['ok!'],
+                [i for i in router({'REQUEST_METHOD': 'OK', 'PATH_INFO': '/'}, lambda *args: None)])
+
     def test_routes_WildcardsAsLastResort(self):
 
         class Routes(object):