Merge lp:~kalikiana/u1db-qt/upstream-tests into lp:u1db-qt

[Cris Dywan]

First attempt at implementing Python U1Db class for unit tests

Unmerged revisions

68. By Cris Dywan on 2013-08-27

First attempt at implementing Python U1Db class for unit tests

=== added file 'tests/__init__.py'
=== added file 'tests/bridged.py'
--- tests/bridged.py	1970-01-01 00:00:00 +0000
+++ tests/bridged.py	2013-08-27 10:28:13 +0000
@@ -0,0 +1,486 @@
+import atexit
+import functools
+import inspect
+import json
+import os
+
+from u1db import (
+    Database as DbInterface,
+    SyncTarget as SyncTargetInterface,
+    Document,
+    errors
+)
+from tools import js_bridge
+
+
+_js_bridge = None
+
+XHR_IMPL = [
+    'platform/core.js',
+    'platform/rhino.js',
+    'console.js',
+    'dom.js',
+    'event.js',
+    'html.js',
+    'timer.js',
+    'xhr.js'
+    ]
+
+
+def get_u1db_js_bridge():
+    global _js_bridge
+    if _js_bridge is None:
+        _js_bridge = js_bridge.JsBridge()
+        if _js_bridge.rhino:
+            for xhr_impl_bit in XHR_IMPL:
+                _js_bridge.load(os.path.join('tests',
+                                             'dist-env-js', xhr_impl_bit))
+        _js_bridge.load('oauth/sha1.js')
+        _js_bridge.load('oauth/oauth.js')
+        _js_bridge.load('u1db.js')
+        _js_bridge._orig_globals = _js_bridge.global_names()
+        _js_bridge._check_escaped = os.getenv('CHECK_ESCAPED') is not None
+        atexit.register(_js_bridge.quit)
+    return _js_bridge
+
+
+to_js = json.dumps
+
+
+def apply_content(doc, content):
+    if content is None:
+        doc.set_json(None)
+    else:
+        doc.content = content
+
+
+def doc_from_dic(val):
+    doc = Document(doc_id=val['doc_id'], rev=val['rev'],
+                   has_conflicts=val['has_conflicts'])
+    apply_content(doc, val['content'])
+    return doc
+
+
+class BridgedJsObject(object):
+
+    # medium level interface
+
+    def _check_for_escaped(self):
+        if self._js_bridge._check_escaped:
+            orig_globals = self._js_bridge._orig_globals
+            cur_globals = self._js_bridge.global_names()
+            if cur_globals != orig_globals:
+                raise Exception("escaped vars: %r" %
+                          cur_globals.symmetric_difference(orig_globals))
+
+    _count = 1
+
+    def _fresh_count(self):
+        c = self._count
+        BridgedJsObject._count += 1
+        return c
+
+    def _make_db(self, dbname):
+        dbvar = "db%d" % self._fresh_count()
+        self._js_bridge.retain(dbvar, "new U1DB(%s, true)" % to_js(dbname))
+        self._check_for_escaped()
+        return dbvar
+
+    def _forget_ref(self, var):
+        self._js_bridge.forget([var])
+
+    _forget_db = _forget_ref
+
+    def _make_http_sync_target(self, url):
+        tgtvar = "tgt%d" % self._fresh_count()
+        self._js_bridge.retain(tgtvar, "new U1DBHTTPSyncTarget(%s)" % to_js(url))
+        self._check_for_escaped()
+        return tgtvar
+
+    _forget_http_sync_target = _forget_ref
+
+    def _make_synchronizer(self, db_ref, tgt_ref):
+        synchronizervar = "synchronizer%d" % self._fresh_count()
+        self._js_bridge.retain(synchronizervar, "new U1DBSynchronizer(%s, %s)" %
+                           (db_ref, tgt_ref))
+        self._check_for_escaped()
+        return synchronizervar
+
+    _forget_synchronizer = _forget_ref
+
+    def _temp_doc_expr(self, doc):
+        return "new U1DBDocument(%s,%s,%s,%s)" % (
+            to_js(doc.doc_id), to_js(doc.rev),
+            to_js(doc.content), to_js(doc.has_conflicts))
+
+    def _make_doc(self, doc):
+        docvar = "doc%d" % self._fresh_count()
+        self._js_bridge.retain(docvar, self._temp_doc_expr(doc))
+        self._check_for_escaped()
+        return docvar
+
+    _forget_doc = _forget_ref
+
+    _nil_cb = "null"
+
+    def _make_cb(self, func):
+        cbvar = "cb%d" % self._fresh_count()
+        self._js_bridge.make_cb(cbvar, func)
+        return cbvar
+
+    def _make_cb_doc(self, func):
+        @functools.wraps(func)
+        def wrap(doc_dic, *args):
+            return func(doc_from_dic(doc_dic), *args)
+        return self._make_cb(wrap)
+
+    def _forget_cb(self, cb_ref):
+        self._js_bridge.forget_cb(cb_ref)
+
+    def _do_invoke(self, ref, meth_name, opts, js_args):
+        if opts:
+            js_args = js_args + [to_js(opts[0])]
+        try:
+            res = self._js_bridge.eval("%s.%s(%s)" % (ref, meth_name,
+                                                  ', '.join(js_args)))
+        except js_bridge.JSError, js_err:
+            if hasattr(errors, js_err.name):
+                if js_err.name == "HTTPError":
+                    raise errors.HTTPError(500, js_err.message) # xxx != 500
+                raise getattr(errors, js_err.name)(js_err.message)
+            raise
+        self._check_for_escaped()
+        return res
+
+    natural_calling = True
+
+    def _invoke(self, ref, meth_name, opts, args):
+        return self._do_invoke(ref, meth_name, opts, map(to_js, args))
+
+    def _invoke_varargs(self, ref, meth_name, opts, args, rest):
+        return self._do_invoke(ref, meth_name, opts,
+                               map(to_js, args+list(rest)))
+
+    def _invoke_ret_tuple(self, ref, meth_name, opts, args):
+        return tuple(self._do_invoke(ref, meth_name, opts, map(to_js, args)))
+
+    def _invoke_ret_doc(self, ref, meth_name, opts, args):
+        dic = self._do_invoke(ref, meth_name, opts, map(to_js, args))
+        if dic is None:
+            return None
+        return doc_from_dic(dic)
+
+    def _invoke_ret_whats_changed(self, ref, meth_name, opts, args):
+        # one single optional arg, like whats_changed
+        if self.natural_calling and not args and opts:
+            if opts[0]:
+                args = [opts[0].values()[0]]
+            opts = None
+        gen, trans_id, changes = self._do_invoke(ref, meth_name, opts,
+                                                 map(to_js, args))
+        return gen, trans_id, map(tuple, changes)
+
+    def _invoke_ret_docs(self, ref, meth_name, opts, args):
+        dics = self._do_invoke(ref, meth_name, opts, map(to_js, args))
+        return map(doc_from_dic, dics)
+
+    def _invoke_varargs_ret_docs(self, ref, meth_name, opts, args, rest):
+        dics = self._do_invoke(ref, meth_name, opts,
+                               map(to_js, args+list(rest)))
+        return map(doc_from_dic, dics)
+
+    def _invoke_ret_tuples(self, ref, meth_name, opts, args):
+        lst = self._do_invoke(ref, meth_name, opts, map(to_js, args))
+        return map(tuple, lst)
+
+    def _invoke_ret_gen_docs(self, ref, meth_name, opts, args):
+        gen, dics = self._do_invoke(ref, meth_name, opts, map(to_js, args))
+        return gen, map(doc_from_dic, dics)
+
+    def _invoke_doc(self, ref, meth_name, opts, doc_ref, args):
+        return self._do_invoke(ref, meth_name, opts, [doc_ref] + map(to_js,
+                                                                    args))
+
+    def _invoke_doc_ret_tuple(self, ref, meth_name, opts, doc_ref, args):
+        return tuple(self._do_invoke(ref, meth_name, opts,
+                                     [doc_ref] + map(to_js, args)))
+
+    def _read_into_doc(self, doc_ref, doc):
+        doc.rev, doc.has_conflicts, content = self._js_bridge.eval(
+            "[%s.rev, %s.has_conflicts, %s.content]" % ((doc_ref,)*3))
+        apply_content(doc, content)
+
+    def _invoke_sync_exchange(self, ref, docs_by_generations,
+                              source_replica_uid,
+                              last_known_generation, last_known_trans_id,
+                              return_doc_cb_ref, ensure_cb_ref):
+        docs_by_gen_exprs = []
+        for doc, gen, trans_id in docs_by_generations:
+            docs_by_gen_exprs.append("[%s, %s, %s]" % (
+                self._temp_doc_expr(doc), to_js(gen), to_js(trans_id)))
+        docs_by_gen_expr = "[%s]" % ', '.join(docs_by_gen_exprs)
+        return tuple(self._do_invoke(ref, 'sync_exchange', None,
+                               [docs_by_gen_expr,
+                                to_js(source_replica_uid),
+                                to_js(last_known_generation),
+                                to_js(last_known_trans_id),
+                                return_doc_cb_ref,
+                                ensure_cb_ref]))
+
+    def _invoke_cb(self, ref, meth_name, cb_ref):
+        return self._do_invoke(ref, meth_name, None, [cb_ref]) 
+
+    # end of medium level interface
+
+    def _parse_opts(self, opt_spec, *args):
+        if opt_spec is None:
+            return args, None
+        opt_args, defl_vals = opt_spec
+        opt = len(defl_vals)
+        opts, defl = {}, {}
+        for argname, argval, argdefl in zip(opt_args, args[-opt:], defl_vals):
+            if argval != argdefl:
+                opts[argname] = argval
+            else:
+                defl[argname] = argdefl
+        return args[:-opt], (opts, defl)
+
+    def _bridge_meth(self, name, opts, args):
+        return self._invoke(self._ref, name, opts, args)
+
+    def _bridge_meth_doc(self, name, opts, args, ret_kind=None):
+        invoke = self._invoke_doc
+        if ret_kind != None:
+            invoke = getattr(self, '_invoke_doc_ret_%s' % ret_kind)
+        doc = args[0]
+        doc_ref = self._make_doc(doc)
+        try:
+            res = invoke(self._ref, name, opts, doc_ref, args[1:])
+            self._read_into_doc(doc_ref, doc)
+            return res
+        finally:
+            self._forget_doc(doc_ref)
+
+    _bridge_meth_doc_conv = _bridge_meth_doc
+
+    def _bridge_meth_conv(self, name, opts, args, ret_kind):
+        invoke = getattr(self, '_invoke_ret_%s' % ret_kind)
+        return invoke(self._ref, name, opts, args)
+
+    def _bridge_meth_varargs(self, name, opts, args, rest, ret_kind=None):
+        invoke = self._invoke_varargs
+        if ret_kind != None:
+            invoke = getattr(self, '_invoke_varargs_ret_%s' % ret_kind)
+        return invoke(self._ref, name, opts, args, rest)
+
+    _bridge_meth_varargs_conv = _bridge_meth_varargs
+
+    def _bridge_meth_sync_exchange(self, docs_by_generations,
+                                   source_replica_uid,
+                                   last_known_generation, last_known_trans_id,
+                                   return_doc_cb, ensure_callback):
+        return_doc_cb_ref = self._make_cb_doc(return_doc_cb)
+        if ensure_callback is not None:
+            ensure_cb_ref = self._make_cb(ensure_callback)
+        else:
+            ensure_cb_ref = self._nil_cb
+        try:
+            return self._invoke_sync_exchange(self._ref, docs_by_generations,
+                                              source_replica_uid,
+                                              last_known_generation,
+                                              last_known_trans_id,
+                                              return_doc_cb_ref,
+                                              ensure_cb_ref)
+        finally:
+            if ensure_callback is not None:
+                self._forget_cb(ensure_cb_ref)
+            self._forget_cb(return_doc_cb_ref)
+
+
+_BRIDGE_METH_TEMPL = """
+def bridge_meth(self, %(args)s):
+    args, opts = self._parse_opts(%(opt_spec)r, %(args)s)
+    return self._bridge_meth%(sign)s(%(name)r, opts, args%(conv)s)
+"""
+
+
+def _complete_interface(interface_cls, bridge_cls, prot_exposed, skip, ret):
+    for name, val in interface_cls.__dict__.items():
+        if name.startswith('_') and name not in prot_exposed:
+            continue
+        if name in skip:
+            continue
+        if name in bridge_cls.__dict__:
+            continue
+        spec = inspect.getargspec(getattr(interface_cls, name))
+        assert spec.args[0] == 'self'
+        args = spec.args[1:]
+        if spec.varargs:
+            assert spec.keywords is None
+            assert False, "*args, not supported yet"
+        else:
+            opt_spec = None
+            if spec.defaults:
+                opt_spec = (args[-len(spec.defaults):], spec.defaults)
+        sign = ''
+        if args and args[0] == 'doc':
+            sign += '_doc'
+        ret_kind = ret.get(name)
+        if ret_kind:
+            sign += '_conv'
+            conv = ", %r" % ret_kind
+        else:
+            conv = ''
+        def_code = _BRIDGE_METH_TEMPL % dict(name=name, opt_spec=opt_spec,
+                                             sign=sign, args=', '.join(args),
+                                             conv=conv)
+        ns = {}
+        exec  def_code in ns
+        bridge_meth = ns['bridge_meth']
+        bridge_meth.__name__ = name
+        bridge_meth.func_defaults = spec.defaults
+        setattr(bridge_cls, name, bridge_meth)
+
+
+class BridgedJsDatabase(BridgedJsObject):
+
+    def __init__(self, replica_uid):
+        self._js_bridge = get_u1db_js_bridge()
+        self._ref = self._make_db(replica_uid)
+
+    def _forget(self):
+        self._forget_db(self._ref)
+
+    def delete_db(self):
+        return self._bridge_meth('delete_db', None, [])
+
+    # testing/internal api
+
+    def _get_transaction_log(self):
+        return self._bridge_meth('_get_transaction_log', None, [])
+
+    def _validate_source(self, other_replica_uid, other_generation,
+                         other_transaction_id):
+        return self._bridge_meth('_validate_source', None,
+                                 [other_replica_uid, other_generation,
+                                  other_transaction_id])
+
+    def validate_gen_and_trans_id(self, generation, trans_id):
+        return self._bridge_meth('validate_gen_and_trans_id', None,
+                                 [generation, trans_id])
+
+    def _get_generation_info(self):
+        return self._bridge_meth_conv('_get_generation_info',
+                                      None, [], ret_kind='tuple')
+
+    def create_index(self, name, *index_expressions):
+        return self._bridge_meth_varargs('create_index', None,
+                                         [name], index_expressions)
+
+    def get_from_index(self, name, *keys):
+        return self._bridge_meth_varargs_conv('get_from_index',
+                                              None, [name], keys,
+                                              ret_kind='docs')
+
+    def get_range_from_index(self, name, start_keys, end_keys=None):
+        return self._bridge_meth_conv('get_range_from_index',
+                                      None, [name, start_keys, end_keys],
+                                      ret_kind='docs')
+
+
+_complete_interface(DbInterface, BridgedJsDatabase,
+                    prot_exposed=set([
+                           '_put_doc_if_newer',
+                           '_get_replica_gen_and_trans_id',
+                           '_set_replica_gen_and_trans_id',
+                           ]),
+                    skip=set(['set_document_factory',]),
+                    ret={
+                        'create_doc_from_json': 'doc',
+                        'create_doc': 'doc',
+                        'get_doc': 'doc',
+                        'get_doc_conflicts': 'docs',
+                        'get_docs': 'docs',
+                        'get_all_docs': 'gen_docs',
+                        'whats_changed': 'whats_changed',
+                        '_get_replica_gen_and_trans_id': 'tuple',
+                        '_put_doc_if_newer': 'tuple',
+                        'list_indexes': 'tuples',
+                        'get_index_keys': 'tuples'
+                        })
+
+
+class BridgedJsHTTPSyncTarget(BridgedJsObject):
+
+    def __init__(self, url):
+        self._js_bridge = get_u1db_js_bridge()
+        self._ref = self._make_http_sync_target(url)
+        self._cb_ref = None
+
+    def _forget(self):
+        if self._cb_ref:
+            self._forget_cb(self._cb_ref)
+        self._forget_http_sync_target(self._ref)
+
+    def set_oauth_credentials(self, consumer_key, consumer_secret,
+                              token_key, token_secret):
+        self._bridge_meth('set_oauth_credentials', None,
+                          [consumer_key, consumer_secret,
+                           token_key, token_secret])
+
+    def sync_exchange(self, docs_by_generations, source_replica_uid,
+                      last_known_generation, last_known_trans_id,
+                      return_doc_cb, ensure_callback=None):
+        return self._bridge_meth_sync_exchange(docs_by_generations,
+                                               source_replica_uid,
+                                               last_known_generation,
+                                               last_known_trans_id,
+                                               return_doc_cb,
+                                               ensure_callback)
+
+    # testing/internal api
+
+    def _set_trace_hook_shallow(self, cb):
+        self._cb_ref = self._make_cb(cb)
+        self._invoke_cb(self._ref, '_set_trace_hook_shallow', self._cb_ref)
+
+
+_complete_interface(SyncTargetInterface, BridgedJsHTTPSyncTarget,
+                    prot_exposed=set(),
+                    skip=set(),
+                    ret = {
+                        'get_sync_info': 'tuple',
+                        })
+
+
+class BridgedJsSynchronizer(BridgedJsObject):
+
+    def __init__(self, bridged_source_db, bridged_target):
+        self._js_bridge = get_u1db_js_bridge()
+        self._ref = self._make_synchronizer(bridged_source_db._ref,
+                                            bridged_target._ref)
+
+    def _forget(self):
+        self._forget_synchronizer(self._ref)
+
+    def sync(self):
+        return self._bridge_meth('sync', None, [])
+
+
+def make_database(test, replica_uid):
+    db = BridgedJsDatabase(replica_uid)
+    def cleanup():
+        db.delete_db()
+        db._forget()
+    test.addCleanup(cleanup)
+    return db
+
+def make_http_sync_target(test, path):
+    target = BridgedJsHTTPSyncTarget(test.getURL(path))
+    test.addCleanup(target._forget)
+    return target
+
+def make_synchronizer(test, source, target):
+    synchronizer = BridgedJsSynchronizer(source, target)
+    test.addCleanup(synchronizer._forget)
+    return synchronizer

=== added file 'tests/setup.py'
--- tests/setup.py	1970-01-01 00:00:00 +0000
+++ tests/setup.py	2013-08-27 10:28:13 +0000
@@ -0,0 +1,6 @@
+from distutils.core import setup, Extension
+
+modul = Extension("u1dbqt", sources=["tests/qt-backend-wrapper.cpp"])
+setup(name = "U1DbQt", version = "1.0",
+      description = "", ext_modules = [modul])
+

=== added file 'tests/test-bridged.py'
--- tests/test-bridged.py	1970-01-01 00:00:00 +0000
+++ tests/test-bridged.py	2013-08-27 10:28:13 +0000
@@ -0,0 +1,186 @@
+import os
+
+from u1db import (
+    errors,
+    sync,
+    tests,
+    )
+from u1db.tests import (
+    test_backends,
+    test_remote_sync_target,
+    test_sync,
+    )
+from u1db.remote.cors_middleware import CORSMiddleware
+
+from tools import serving
+
+from bridged import (
+    get_u1db_js_bridge,
+    BridgedJsObject,
+    make_database,
+    make_http_sync_target,
+    make_synchronizer,
+    )
+
+_test_count = 0
+
+def setUp(self):
+    if FLAG:
+        global _test_count
+        _test_count += 1
+        get_u1db_js_bridge().flag("#%d %s" % (_test_count, self.id().split('.', 2)[2]))
+    super(self.__class__, self).setUp()
+
+def startServer(self):
+    app = self.make_app()
+    bridge = get_u1db_js_bridge()
+    if not SAME_ORIGIN or bridge.rhino:
+        (self.server_thread, self.server,
+         self.base_url) = serving.serve(app, 0, log_server=LOG_SERVER)
+        self.addCleanup(self.server_thread.join)
+        self.addCleanup(self.server.shutdown)
+    else:
+        self.server = bridge.get_server()
+        self.base_url = bridge.get_base_url()
+        bridge.set_fallback_app(app)
+    if getattr(app, 'base_url', 1) is None:
+        app.base_url = self.base_url
+
+SCENARIOS = [("jsbridged", {
+        "make_database_for_test": make_database,
+        })]
+
+def skip_test(test):
+    test.skipTest("skipped: not applicable/relevant")
+
+class BridgedAllDatabaseTests(test_backends.AllDatabaseTests):
+    scenarios = SCENARIOS
+    setUp = setUp
+
+class BridgedLocalDatabaseTests(test_backends.LocalDatabaseTests):
+    accept_fixed_trans_id = True
+    scenarios = SCENARIOS
+    setUp = setUp
+
+class BridgedLocalDatabaseValidateSourceGenTests(test_backends.LocalDatabaseValidateSourceGenTests):
+    scenarios = SCENARIOS
+    setUp = setUp
+
+class BridgedLocalDatabaseValidateGenNTransIdTests(test_backends.LocalDatabaseValidateGenNTransIdTests):
+    scenarios = SCENARIOS
+    setUp = setUp
+    test_validate_gen_and_trans_id_invalid_gen = skip_test
+
+class BridgedLocalDatabaseWithConflictsTests(test_backends.LocalDatabaseWithConflictsTests):
+    accept_fixed_trans_id = True
+    scenarios = SCENARIOS
+    setUp = setUp
+
+class BridgedDatabaseIndexTests(test_backends.DatabaseIndexTests):
+    scenarios = SCENARIOS
+    setUp = setUp
+
+class MyCORSMiddleware(CORSMiddleware):
+    _base_url = None
+
+    @property
+    def base_url(self):
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, value):
+        self.app.base_url = self._base_url = value
+
+def make_http_app(state):
+    app = test_remote_sync_target.make_http_app(state)
+    bridge = get_u1db_js_bridge()
+    if not SAME_ORIGIN:
+        return MyCORSMiddleware(app, ['*'])
+    return app
+
+def make_oauth_http_app(state):
+    app = test_remote_sync_target.make_oauth_http_app(state)
+    bridge = get_u1db_js_bridge()
+    if not SAME_ORIGIN:
+        return MyCORSMiddleware(app, ['*'])
+    return app
+
+def oauth_http_sync_target(test, path):
+    st = make_http_sync_target(test, '~/' + path)
+    st.set_oauth_credentials(tests.consumer1.key, tests.consumer1.secret,
+                             tests.token1.key, tests.token1.secret)
+    return st
+
+class BridgedTestHttpSyncTarget(test_remote_sync_target.TestRemoteSyncTargets):
+    startServer = startServer
+    setUp = setUp
+
+    scenarios = [
+        ('http', {'make_app_with_state': make_http_app,
+                  'make_document_for_test': tests.make_document_for_test,
+                  'sync_target': make_http_sync_target}),
+        ('oauth_http', {'make_app_with_state':
+                        make_oauth_http_app,
+                        'make_document_for_test': tests.make_document_for_test,
+                        'sync_target': oauth_http_sync_target}),
+        ]
+
+    if not SAME_ORIGIN:
+        failure_scenario_exceptions = (errors.UserQuotaExceeded,
+                                       errors.UserQuotaExceeded)
+
+def copy_database_for_test(test, db):
+    if isinstance(db, BridgedJsObject):
+        test.skipTest("js dbs cannot be copied")
+    return test_sync.copy_database_for_http_test(test, db)
+
+def sync_for_test(test, db_source, db_target, trace_hook=None, trace_hook_shallow=None):
+    if isinstance(db_source, BridgedJsObject):
+        if trace_hook:
+            test.skipTest("full trace hook not supported by http target")
+        path = test._http_at[db_target]
+        target = make_http_sync_target(test, path)
+        if trace_hook_shallow:
+            target._set_trace_hook_shallow(trace_hook_shallow)
+        return make_synchronizer(test, db_source, target).sync()
+    target = db_target.get_sync_target()
+    target._set_trace_hook_shallow(trace_hook or trace_hook_shallow)
+    return sync.Synchronizer(db_source, target).sync()
+
+class BridgedDatabaseSyncTests(test_sync.DatabaseSyncTests):
+    accept_fixed_trans_id = True
+    startServer = startServer
+
+    scenarios = [('jshttp', {
+        'make_database_for_test': None, # see create_database_for_role
+        'copy_database_for_test': copy_database_for_test,
+        'make_document_for_test': tests.make_document_for_test,
+        'make_app_with_state': make_http_app,
+        'do_sync': sync_for_test,
+    })]
+
+    def create_database_for_role(self, replica_uid, sync_role):
+        if sync_role == 'source':
+            js_db = make_database(self, replica_uid)
+            js_db._replica_uid = replica_uid
+            return js_db
+        return test_sync.make_database_for_http_test(self, replica_uid)
+
+    setUp = setUp
+    test_optional_sync_preserve_json = skip_test
+
+class BridgedTestDbSync(test_sync.TestDbSync):
+    startServer = startServer
+    scenarios = [
+        ('jshttp', {
+            'make_app_with_state': make_http_app,
+            'make_database_for_test': make_database,
+            }),
+        ('jsoauthhttp', {
+            'make_app_with_state': make_oauth_http_app,
+            'make_database_for_test': make_database,
+            'oauth': True
+            })]
+    setUp = setUp
+
+load_tests = tests.load_with_scenarios