diff --git a/tests/test_model_sync.py b/tests/test_model_sync.py index 46d4277d..12c3593f 100644 --- a/tests/test_model_sync.py +++ b/tests/test_model_sync.py @@ -35,18 +35,195 @@ import copy import os +import sys from gel._internal import _tracked_list from gel._internal._qbmodel._abstract import _link_set from gel._internal._qbmodel._pydantic._models import GelModel from gel._internal._testbase import _models as tb +from gel._internal._testbase._base import TestAsyncIOClient, TestClient from tests import nested_collections -_T = typing.TypeVar("_T") +if typing.TYPE_CHECKING: + from gel.abstract import Queryable, _T_ql -class TestModelSync(tb.ModelTestCase): +# Model sync tests are run for both blocking and async clients. +# +# To implement this, tests in this file should not call self.client +# directly. Instead, they call the corresponding function from +# `TestBlockingModelSyncBase``. +# +# Test classes should derive from `TestBlockingModelSyncBase` and use the +# `make_async_tests` to automatically create the async versions of the tests. +# +# The async test classes and functions will be created such that: +# +# @make_async_tests +# class TestFoo(TestBlockingModelSyncBase): +# async def test_foo_01(self): +# ... +# +# will be create the async version: +# +# class TestAsyncFoo(TestAsyncModelSyncBase): +# async def test_async_foo_01(self): +# ... +# +# Both base classes (`TestBlockingModelSyncBase` and `TestAsyncModelSyncBase`) +# wrap the client calls in an async function. When adding new functions, +# ensure both classes have the same interface. + + +# Helpers to replicate tests as both blocking and async + + +class TestBlockingModelSyncBase(tb.ModelTestCase): + # Implement functions as async so that the interface is the same as the + # async version. + # + # Add the overloads too to help the type checker. + + async def _save( + self, + *objs: GelModel, + warn_on_large_sync: bool = True, + ) -> None: + self.client.save(*objs) + + async def _sync( + self, + *objs: GelModel, + warn_on_large_sync: bool = True, + ) -> None: + self.client.sync(*objs, warn_on_large_sync=warn_on_large_sync) + + async def _sync_with_client( + self, + client: TestClient, + *objs: GelModel, + warn_on_large_sync: bool = True, + ) -> None: + client.sync(*objs, warn_on_large_sync=warn_on_large_sync) + + @typing.overload + async def _query( + self, + query: Queryable[_T_ql], + /, + **kwargs: typing.Any, + ) -> list[_T_ql]: ... + + @typing.overload + async def _query( + self, + query: str, + /, + *args: typing.Any, + **kwargs: typing.Any, + ) -> list[typing.Any]: ... + + async def _query( + self, + query: str | Queryable[_T_ql], + /, + *args: typing.Any, + **kwargs: typing.Any, + ) -> list[typing.Any] | list[_T_ql]: + return self.client.query(query, *args, **kwargs) + + @typing.overload + async def _query_required_single( + self, query: Queryable[_T_ql], **kwargs: typing.Any + ) -> _T_ql: ... + + @typing.overload + async def _query_required_single( + self, query: str, *args: typing.Any, **kwargs: typing.Any + ) -> typing.Any: ... + + async def _query_required_single( + self, + query: str | Queryable[_T_ql], + *args: typing.Any, + **kwargs: typing.Any, + ) -> _T_ql | typing.Any: + return self.client.query_required_single(query, *args, **kwargs) + + +class TestAsyncModelSyncBase(tb.AsyncModelTestCase): + + async def _save( + self, + *objs: GelModel, + warn_on_large_sync: bool = True, + ) -> None: + await self.client.save(*objs) + + async def _sync( + self, + *objs: GelModel, + warn_on_large_sync: bool = True, + ) -> None: + await self.client.sync(*objs, warn_on_large_sync=warn_on_large_sync) + + async def _sync_with_client( + self, + client: TestAsyncIOClient, + *objs: GelModel, + warn_on_large_sync: bool = True, + ) -> None: + await client.sync(*objs, warn_on_large_sync=warn_on_large_sync) + + async def _query( + self, + query: str | Queryable[_T_ql], + /, + *args: typing.Any, + **kwargs: typing.Any, + ) -> list[typing.Any] | list[_T_ql]: + return await self.client.query(query, *args, **kwargs) + + async def _query_required_single( + self, + query: str | Queryable[_T_ql], + *args: typing.Any, + **kwargs: typing.Any, + ) -> _T_ql | typing.Any: + return await self.client.query_required_single(query, *args, **kwargs) + + +def make_async_tests( + cls: type[TestBlockingModelSyncBase] +) -> type[TestBlockingModelSyncBase]: + """Create a copy of a blocking test case which uses an async client.""" + + new_name = "TestAsync" + cls.__name__[4:] + + new_bases = tuple( + TestAsyncModelSyncBase if base is TestBlockingModelSyncBase else base + for base in cls.__bases__ + ) + + new_attrs = {} + for name, value in vars(cls).items(): + if callable(value) and name.startswith("test_"): + new_attrs["test_async_" + name[5:]] = value + else: + new_attrs[name] = value + + new_cls = type(new_name, new_bases, new_attrs) + setattr(sys.modules[cls.__module__], new_name, new_cls) + + return cls + + +# Start of tests + + +@make_async_tests +class TestModelSync(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = os.path.join( @@ -57,7 +234,7 @@ class TestModelSync(tb.ModelTestCase): os.path.dirname(__file__), "dbsetup", "chemistry.esdl" ) - def test_model_sync_new_obj_computed_01(self): + async def test_model_sync_new_obj_computed_01(self): # Computeds from backlinks but no links set from models.chemistry import default @@ -66,36 +243,36 @@ def test_model_sync_new_obj_computed_01(self): reactor = default.Reactor() # Sync - self.client.sync(reactor) + await self._sync(reactor) # Check that value is initialized self.assertEqual(reactor.total_weight, 0) self.assertEqual(reactor.atom_weights, ()) - def test_model_sync_new_obj_computed_02(self): + async def test_model_sync_new_obj_computed_02(self): # Computeds from links to existing object from models.chemistry import default # Create new objects - hydrogen = self.client.query_required_single( + hydrogen = await self._query_required_single( default.Element.filter(symbol="H").limit(1) ) ref_atom = default.RefAtom(element=hydrogen) # Sync - self.client.sync(ref_atom) + await self._sync(ref_atom) # Check that computed values are fetched self.assertEqual(ref_atom.weight, 1.008) - def test_model_sync_new_obj_computed_03(self): + async def test_model_sync_new_obj_computed_03(self): # Computed from links to existing and new items from models.chemistry import default # Existing objects - helium = self.client.query_required_single( + helium = await self._query_required_single( default.Element.filter(symbol="He").limit(1) ) @@ -104,7 +281,7 @@ def test_model_sync_new_obj_computed_03(self): new_atom = default.Atom(reactor=reactor, element=helium) # Sync - self.client.sync(reactor, new_atom) + await self._sync(reactor, new_atom) # Check that values are fetched self.assertEqual(new_atom.weight, 4.0026) @@ -113,16 +290,16 @@ def test_model_sync_new_obj_computed_03(self): self.assertEqual(reactor.total_weight, 4.0026) self.assertEqual(reactor.atom_weights, (4.0026,)) - def test_model_sync_new_obj_computed_04(self): + async def test_model_sync_new_obj_computed_04(self): # Computed from links to existing and new items from models.chemistry import default # Existing objects - hydrogen = self.client.query_required_single( + hydrogen = await self._query_required_single( default.Element.select(weight=True).filter(symbol="H").limit(1) ) - oxygen = self.client.query_required_single( + oxygen = await self._query_required_single( default.Element.select(weight=True).filter(symbol="O").limit(1) ) @@ -143,7 +320,7 @@ def test_model_sync_new_obj_computed_04(self): oxygen_atoms = [o_1] # Sync - self.client.sync(*hydrogen_atoms, *oxygen_atoms) + await self._sync(*hydrogen_atoms, *oxygen_atoms) # Check that values are fetched self.assertEqual( @@ -182,7 +359,8 @@ def test_model_sync_new_obj_computed_04(self): ) -class TestModelSyncBasic(tb.ModelTestCase): +@make_async_tests +class TestModelSyncBasic(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -197,7 +375,7 @@ class TestModelSyncBasic(tb.ModelTestCase): }; """ - def test_model_sync_basic_01(self): + async def test_model_sync_basic_01(self): # Sync applies ids to new objects from models.TestModelSyncBasic import default @@ -205,12 +383,12 @@ def test_model_sync_basic_01(self): synced = default.O() unsynced = default.O() - self.client.sync(synced) + await self._sync(synced) self.assertTrue(hasattr(synced, "id")) self.assertFalse(hasattr(unsynced, "id")) - def test_model_sync_basic_02(self): + async def test_model_sync_basic_02(self): # Sync applies ids to new objects in graph from models.TestModelSyncBasic import default @@ -222,7 +400,7 @@ def test_model_sync_basic_02(self): b = default.B(a=a) c = default.C(b=b) - self.client.sync(a, b, c) + await self._sync(a, b, c) self.assertTrue(hasattr(a, "id")) self.assertTrue(hasattr(b, "id")) @@ -235,7 +413,7 @@ def test_model_sync_basic_02(self): b = default.B(a=a) c = default.C(b=b) - self.client.sync(c) + await self._sync(c) self.assertTrue(hasattr(a, "id")) self.assertTrue(hasattr(b, "id")) @@ -248,7 +426,7 @@ def test_model_sync_basic_02(self): b = default.B(a=a) c = default.C(b=b) - self.client.sync(a) + await self._sync(a) self.assertTrue(hasattr(a, "id")) self.assertFalse(hasattr(b, "id")) @@ -258,20 +436,20 @@ def test_model_sync_basic_02(self): # sync only C # A and C get ids b = default.B() - self.client.save(b) + await self._save(b) self.assertTrue(hasattr(b, "id")) a = default.A() b.a = a c = default.C(b=b) - self.client.sync(c) + await self._sync(c) self.assertTrue(hasattr(a, "id")) self.assertTrue(hasattr(c, "id")) -class TestModelSyncSingleProp(tb.ModelTestCase): +class TestModelSyncSingleProp(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -345,10 +523,10 @@ class TestModelSyncSingleProp(tb.ModelTestCase): # }; """ - def test_model_sync_single_prop_01(self): + async def test_model_sync_single_prop_01(self): # Insert new object with single prop - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], val: typing.Any, *, @@ -356,15 +534,15 @@ def _testcase( ) -> None: # sync one at a time with_val = model_type(val=val) - self.client.sync(with_val) + await self._sync(with_val) self.assertEqual(with_val.val, val) with_unset = model_type() - self.client.sync(with_unset) + await self._sync(with_unset) self.assertEqual(with_unset.val, default_val) with_none = model_type(val=None) - self.client.sync(with_none) + await self._sync(with_none) self.assertIsNone(with_none.val) # sync all together @@ -372,7 +550,7 @@ def _testcase( with_unset = model_type() with_none = model_type(val=None) - self.client.sync(with_val, with_unset, with_none) + await self._sync(with_val, with_unset, with_none) self.assertEqual(with_val.val, val) self.assertEqual(with_unset.val, default_val) @@ -380,29 +558,29 @@ def _testcase( from models.TestModelSyncSingleProp import default - _testcase(default.A, 1) - _testcase(default.B, [1, 2, 3]) - _testcase(default.C, ("x", 1)) - _testcase(default.E, [("x", 1), ("y", 2), ("z", 3)]) - _testcase(default.F, ("x", [1, 2, 3])) - _testcase(default.G, ("x", ("x", 1))) - _testcase( + await _testcase(default.A, 1) + await _testcase(default.B, [1, 2, 3]) + await _testcase(default.C, ("x", 1)) + await _testcase(default.E, [("x", 1), ("y", 2), ("z", 3)]) + await _testcase(default.F, ("x", [1, 2, 3])) + await _testcase(default.G, ("x", ("x", 1))) + await _testcase( default.H, [("x", [1, 2, 3]), ("y", [4, 5, 6]), ("z", [7, 8, 9])], ) - _testcase( + await _testcase( default.I, ("w", [("x", 1), ("y", 2), ("z", 3)]), ) - _testcase(default.Az, 9, default_val=-1) - _testcase(default.Bz, [1, 2, 3], default_val=[-1]) - _testcase(default.Cz, ("x", 1), default_val=(".", -1)) - _testcase(default.Fz, ("x", [1, 2, 3]), default_val=(".", [-1])) - _testcase(default.Gz, ("x", ("x", 1)), default_val=(".", (".", -1))) + await _testcase(default.Az, 9, default_val=-1) + await _testcase(default.Bz, [1, 2, 3], default_val=[-1]) + await _testcase(default.Cz, ("x", 1), default_val=(".", -1)) + await _testcase(default.Fz, ("x", [1, 2, 3]), default_val=(".", [-1])) + await _testcase(default.Gz, ("x", ("x", 1)), default_val=(".", (".", -1))) @tb.xfail # Adding the types to the schema causes ISE - def test_model_sync_single_prop_01b(self): + async def test_model_sync_single_prop_01b(self): from models.TestModelSyncSingleProp import default self._testcase( @@ -419,26 +597,26 @@ def test_model_sync_single_prop_01b(self): default_val=(".", [(".", -1)]), ) - def test_model_sync_single_prop_02(self): + async def test_model_sync_single_prop_02(self): # Updating existing objects with single props from models.TestModelSyncSingleProp import default - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Any, changed_val: typing.Any, ) -> None: original = model_type(val=initial_val) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(val=True).limit(1) ) - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(val=True).limit(1) ) - mirror_3 = self.client.query_required_single( + mirror_3 = await self._query_required_single( model_type.select(val=False).limit(1) ) @@ -451,7 +629,7 @@ def _testcase( original.val = changed_val # sync some of the objects - self.client.sync(original, mirror_1, mirror_3) + await self._sync(original, mirror_1, mirror_3) # only synced objects with value set get update self.assertEqual(original.val, changed_val) @@ -460,64 +638,64 @@ def _testcase( # self.assertFalse(hasattr(mirror_3, 'val')) # Fail # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) # Change to a new value - _testcase(default.A, 1, 2) - _testcase(default.B, [1], [2]) - _testcase(default.C, ("a", 1), ("b", 2)) - _testcase(default.E, [("a", 1)], [("b", 2)]) - _testcase(default.F, ("a", [1]), ("b", [2])) - _testcase(default.G, ("a", ("a", 1)), ("b", ("b", 2))) - _testcase(default.H, [("a", [1])], [("b", [2])]) - _testcase(default.I, ("a", [("a", 1)]), ("b", [("b", 2)])) + await _testcase(default.A, 1, 2) + await _testcase(default.B, [1], [2]) + await _testcase(default.C, ("a", 1), ("b", 2)) + await _testcase(default.E, [("a", 1)], [("b", 2)]) + await _testcase(default.F, ("a", [1]), ("b", [2])) + await _testcase(default.G, ("a", ("a", 1)), ("b", ("b", 2))) + await _testcase(default.H, [("a", [1])], [("b", [2])]) + await _testcase(default.I, ("a", [("a", 1)]), ("b", [("b", 2)])) # Change to the same value - _testcase(default.A, 1, 1) - _testcase(default.B, [1], [1]) - _testcase(default.C, ("a", 1), ("a", 1)) - _testcase(default.E, [("a", 1)], [("a", 1)]) - _testcase(default.F, ("a", [1]), ("a", [1])) - _testcase(default.G, ("a", ("a", 1)), ("a", ("a", 1))) - _testcase(default.H, [("a", [1])], [("a", [1])]) - _testcase(default.I, ("a", [("a", 1)]), ("a", [("a", 1)])) + await _testcase(default.A, 1, 1) + await _testcase(default.B, [1], [1]) + await _testcase(default.C, ("a", 1), ("a", 1)) + await _testcase(default.E, [("a", 1)], [("a", 1)]) + await _testcase(default.F, ("a", [1]), ("a", [1])) + await _testcase(default.G, ("a", ("a", 1)), ("a", ("a", 1))) + await _testcase(default.H, [("a", [1])], [("a", [1])]) + await _testcase(default.I, ("a", [("a", 1)]), ("a", [("a", 1)])) # Change from None to value - _testcase(default.A, None, 1) - _testcase(default.B, None, [1]) - _testcase(default.C, None, ("a", 1)) - _testcase(default.E, None, [("a", 1)]) - _testcase(default.F, None, ("a", [1])) - _testcase(default.G, None, ("a", ("a", 1))) - _testcase(default.H, None, [("a", [1])]) - _testcase(default.I, None, ("a", [("a", 1)])) + await _testcase(default.A, None, 1) + await _testcase(default.B, None, [1]) + await _testcase(default.C, None, ("a", 1)) + await _testcase(default.E, None, [("a", 1)]) + await _testcase(default.F, None, ("a", [1])) + await _testcase(default.G, None, ("a", ("a", 1))) + await _testcase(default.H, None, [("a", [1])]) + await _testcase(default.I, None, ("a", [("a", 1)])) # Change from value to None - _testcase(default.A, 1, None) - _testcase(default.B, [1], None) - _testcase(default.C, ("a", 1), None) - _testcase(default.E, [("a", 1)], None) - _testcase(default.F, ("a", [1]), None) - _testcase(default.G, ("a", ("a", 1)), None) - _testcase(default.H, [("a", [1])], None) - _testcase(default.I, ("a", [("a", 1)]), None) + await _testcase(default.A, 1, None) + await _testcase(default.B, [1], None) + await _testcase(default.C, ("a", 1), None) + await _testcase(default.E, [("a", 1)], None) + await _testcase(default.F, ("a", [1]), None) + await _testcase(default.G, ("a", ("a", 1)), None) + await _testcase(default.H, [("a", [1])], None) + await _testcase(default.I, ("a", [("a", 1)]), None) # Change from None to None - _testcase(default.A, None, None) - _testcase(default.B, None, None) - _testcase(default.C, None, None) - _testcase(default.E, None, None) - _testcase(default.F, None, None) - _testcase(default.G, None, None) - _testcase(default.H, None, None) - _testcase(default.I, None, None) - - def test_model_sync_single_prop_03(self): + await _testcase(default.A, None, None) + await _testcase(default.B, None, None) + await _testcase(default.C, None, None) + await _testcase(default.E, None, None) + await _testcase(default.F, None, None) + await _testcase(default.G, None, None) + await _testcase(default.H, None, None) + await _testcase(default.I, None, None) + + async def test_model_sync_single_prop_03(self): # Reconciling different changes to single props from models.TestModelSyncSingleProp import default - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Any, changed_val_0: typing.Any, @@ -525,15 +703,15 @@ def _testcase( changed_val_2: typing.Any, ) -> None: original = model_type(val=initial_val) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(val=True).limit(1) ) - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(val=True).limit(1) ) - mirror_3 = self.client.query_required_single( + mirror_3 = await self._query_required_single( model_type.select(val=False).limit(1) ) @@ -548,7 +726,7 @@ def _testcase( mirror_2.val = changed_val_2 # sync some of the objects - self.client.sync(original, mirror_1, mirror_3) + await self._sync(original, mirror_1, mirror_3) # only synced objects are updated self.assertEqual(original.val, changed_val_0) @@ -557,28 +735,32 @@ def _testcase( # self.assertFalse(hasattr(mirror_3, 'val')) # Fail # cleanup - self.client.query(model_type.delete()) - - _testcase(default.A, 1, 2, 3, 4) - _testcase(default.B, [1], [2], [3], [4]) - _testcase(default.C, ("a", 1), ("b", 2), ("c", 3), ("d", 4)) - _testcase(default.E, [("a", 1)], [("b", 2)], [("c", 3)], [("d", 4)]) - _testcase(default.F, ("a", [1]), ("b", [2]), ("c", [3]), ("d", [4])) - _testcase( + await self._query(model_type.delete()) + + await _testcase(default.A, 1, 2, 3, 4) + await _testcase(default.B, [1], [2], [3], [4]) + await _testcase(default.C, ("a", 1), ("b", 2), ("c", 3), ("d", 4)) + await _testcase( + default.E, [("a", 1)], [("b", 2)], [("c", 3)], [("d", 4)] + ) + await _testcase( + default.F, ("a", [1]), ("b", [2]), ("c", [3]), ("d", [4]) + ) + await _testcase( default.G, ("a", ("a", 1)), ("b", ("b", 2)), ("c", ("c", 3)), ("d", ("d", 4)), ) - _testcase( + await _testcase( default.H, [("a", [1])], [("b", [2])], [("c", [3])], [("d", [4])], ) - _testcase( + await _testcase( default.I, ("a", [("a", 1)]), ("b", [("b", 2)]), @@ -587,20 +769,20 @@ def _testcase( ) @tb.xfail - def test_model_sync_single_prop_04(self): + async def test_model_sync_single_prop_04(self): # Changing elements of collection single props # Checks deeply nested collections as well from models.TestModelSyncSingleProp import default - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Any, ) -> None: original = model_type(val=initial_val) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(val=True).limit(1) ) @@ -645,7 +827,7 @@ def _testcase( ) # sync and check objects are updated - self.client.sync(original, mirror_1) + await self._sync(original, mirror_1) self.assertEqual(original.val, expected_val) self.assertEqual(mirror_1.val, expected_val) @@ -655,50 +837,50 @@ def _testcase( ) # cleanup - self.client.query(model_type.delete()) - - _testcase(default.B, [1, 2, 3]) - _testcase(default.C, ("x", 1)) - _testcase(default.E, [("x", 1), ("y", 2), ("z", 3)]) - _testcase(default.F, ("x", [1, 2, 3])) # Fail - _testcase(default.G, ("x", ("x", 1))) - _testcase( + await self._query(model_type.delete()) + + await _testcase(default.B, [1, 2, 3]) + await _testcase(default.C, ("x", 1)) + await _testcase(default.E, [("x", 1), ("y", 2), ("z", 3)]) + await _testcase(default.F, ("x", [1, 2, 3])) # Fail + await _testcase(default.G, ("x", ("x", 1))) + await _testcase( default.H, [("x", [1, 2, 3]), ("y", [4, 5, 6]), ("z", [7, 8, 9])], ) # Fail - _testcase( + await _testcase( default.I, ("w", [("x", 1), ("y", 2), ("z", 3)]), ) # Fail @tb.xfail - def test_model_sync_single_prop_05(self): + async def test_model_sync_single_prop_05(self): # Existing object without prop should not have it fetched from models.TestModelSyncSingleProp import default original = default.A(val=1) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( default.A.select(val=False).limit(1) ) original.val = 2 - self.client.save(original) - self.client.sync(mirror_1) + await self._save(original) + await self._sync(mirror_1) self.assertFalse(hasattr(mirror_1, "val")) # Sync alongside another object with the prop set - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( default.A.select(val=True).limit(1) ) original.val = 3 - self.client.save(original) - self.client.sync(mirror_1, mirror_2) + await self._save(original) + await self._sync(mirror_1, mirror_2) self.assertFalse(hasattr(mirror_1, "val")) # Fail -class TestModelSyncComputedSingleProp(tb.ModelTestCase): +class TestModelSyncComputedSingleProp(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -756,254 +938,254 @@ class TestModelSyncComputedSingleProp(tb.ModelTestCase): }; """ - def test_model_sync_computed_single_prop_constant_01(self): + async def test_model_sync_computed_single_prop_constant_01(self): # Create new from models.TestModelSyncComputedSingleProp import default original = default.FromConstant() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 1) - def test_model_sync_computed_single_prop_constant_02(self): + async def test_model_sync_computed_single_prop_constant_02(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromConstant()) - mirror = self.client.query_required_single( + await self._sync(default.FromConstant()) + mirror = await self._query_required_single( default.FromConstant.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_single_prop_01(self): + async def test_model_sync_computed_single_prop_from_single_prop_01(self): # Create new, expr prop is None from models.TestModelSyncComputedSingleProp import default original = default.FromSingleProp() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, None) - def test_model_sync_computed_single_prop_from_single_prop_02(self): + async def test_model_sync_computed_single_prop_from_single_prop_02(self): # Create new, expr prop has value from models.TestModelSyncComputedSingleProp import default original = default.FromSingleProp(n=1) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_single_prop_03(self): + async def test_model_sync_computed_single_prop_from_single_prop_03(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromSingleProp()) - mirror = self.client.query_required_single( + await self._sync(default.FromSingleProp()) + mirror = await self._query_required_single( default.FromSingleProp.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_single_prop_04(self): + async def test_model_sync_computed_single_prop_from_single_prop_04(self): # Update with val set, initially None from models.TestModelSyncComputedSingleProp import default original = default.FromSingleProp() - self.client.sync(original) + await self._sync(original) original.n = 9 - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_single_prop_05(self): + async def test_model_sync_computed_single_prop_from_single_prop_05(self): # Update with val set, initially not None from models.TestModelSyncComputedSingleProp import default original = default.FromSingleProp(n=1) - self.client.sync(original) + await self._sync(original) original.n = 9 - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_multi_prop_01(self): + async def test_model_sync_computed_single_prop_from_multi_prop_01(self): # Create new, expr prop is empty from models.TestModelSyncComputedSingleProp import default original = default.FromMultiProp() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 1) - def test_model_sync_computed_single_prop_from_multi_prop_02(self): + async def test_model_sync_computed_single_prop_from_multi_prop_02(self): # Create new, expr prop has values from models.TestModelSyncComputedSingleProp import default original = default.FromMultiProp(n=[1, 2, 3]) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 7) - def test_model_sync_computed_single_prop_from_multi_prop_03(self): + async def test_model_sync_computed_single_prop_from_multi_prop_03(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromMultiProp()) - mirror = self.client.query_required_single( + await self._sync(default.FromMultiProp()) + mirror = await self._query_required_single( default.FromMultiProp.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_multi_prop_04(self): + async def test_model_sync_computed_single_prop_from_multi_prop_04(self): # Update with val set, initially empty from models.TestModelSyncComputedSingleProp import default original = default.FromMultiProp() - self.client.sync(original) + await self._sync(original) original.n = [7, 8, 9] - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 25) - def test_model_sync_computed_single_prop_from_multi_prop_05(self): + async def test_model_sync_computed_single_prop_from_multi_prop_05(self): # Update with val set, initially has values from models.TestModelSyncComputedSingleProp import default original = default.FromMultiProp(n=[1, 2, 3]) - self.client.sync(original) + await self._sync(original) original.n = [7, 8, 9] - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 25) - def test_model_sync_computed_single_prop_from_single_link_01(self): + async def test_model_sync_computed_single_prop_from_single_link_01(self): # Create new, expr prop is None from models.TestModelSyncComputedSingleProp import default original = default.FromSingleLink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, None) - def test_model_sync_computed_single_prop_from_single_link_02(self): + async def test_model_sync_computed_single_prop_from_single_link_02(self): # Create new, target already exists from models.TestModelSyncComputedSingleProp import default target = default.Target(val=1) - self.client.save(target) + await self._save(target) original = default.FromSingleLink(target=target) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_single_link_03(self): + async def test_model_sync_computed_single_prop_from_single_link_03(self): # Create new, target created alongside object from models.TestModelSyncComputedSingleProp import default target = default.Target(val=1) original = default.FromSingleLink(target=target) - self.client.sync(original, target) + await self._sync(original, target) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_single_link_04(self): + async def test_model_sync_computed_single_prop_from_single_link_04(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromSingleLink()) - mirror = self.client.query_required_single( + await self._sync(default.FromSingleLink()) + mirror = await self._query_required_single( default.FromSingleLink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_single_link_05(self): + async def test_model_sync_computed_single_prop_from_single_link_05(self): # Update with val set, initially target is None from models.TestModelSyncComputedSingleProp import default target = default.Target(val=9) original = default.FromSingleLink() - self.client.sync(original, target) + await self._sync(original, target) original.target = target - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_single_link_06(self): + async def test_model_sync_computed_single_prop_from_single_link_06(self): # Update with val set, initially target is set # target val changes from models.TestModelSyncComputedSingleProp import default target = default.Target(val=1) - self.client.save(target) + await self._save(target) original = default.FromSingleLink(target=target) - self.client.sync(original) + await self._sync(original) target.val = 9 - self.client.sync(original, target) + await self._sync(original, target) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_single_link_07(self): + async def test_model_sync_computed_single_prop_from_single_link_07(self): # Update with val set, initially target is set # target changes from models.TestModelSyncComputedSingleProp import default target_a = default.Target(val=1) - self.client.save(target_a) + await self._save(target_a) original = default.FromSingleLink(target=target_a) - self.client.sync(original) + await self._sync(original) target_b = default.Target(val=9) original.target = target_b - self.client.sync(original, target_b) + await self._sync(original, target_b) self.assertEqual(original.val, 10) - def test_model_sync_computed_multi_prop_from_multi_link_01(self): + async def test_model_sync_computed_multi_prop_from_multi_link_01(self): # Create new, expr prop is None from models.TestModelSyncComputedSingleProp import default original = default.FromMultiLink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 1) - def test_model_sync_computed_multi_prop_from_multi_link_02(self): + async def test_model_sync_computed_multi_prop_from_multi_link_02(self): # Create new, target already exists from models.TestModelSyncComputedSingleProp import default @@ -1011,14 +1193,14 @@ def test_model_sync_computed_multi_prop_from_multi_link_02(self): target_a = default.Target(val=1) target_b = default.Target(val=2) target_c = default.Target(val=3) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 7) - def test_model_sync_computed_multi_prop_from_multi_link_03(self): + async def test_model_sync_computed_multi_prop_from_multi_link_03(self): # Create new, target created alongside object from models.TestModelSyncComputedSingleProp import default @@ -1027,24 +1209,24 @@ def test_model_sync_computed_multi_prop_from_multi_link_03(self): target_b = default.Target(val=2) target_c = default.Target(val=3) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original, target_a, target_b, target_c) + await self._sync(original, target_a, target_b, target_c) self.assertEqual(original.val, 7) - def test_model_sync_computed_multi_prop_from_multi_link_04(self): + async def test_model_sync_computed_multi_prop_from_multi_link_04(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromMultiLink()) - mirror = self.client.query_required_single( + await self._sync(default.FromMultiLink()) + mirror = await self._query_required_single( default.FromMultiLink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_multi_link_05(self): + async def test_model_sync_computed_multi_prop_from_multi_link_05(self): # Update with val set, initially target is empty from models.TestModelSyncComputedSingleProp import default @@ -1052,17 +1234,17 @@ def test_model_sync_computed_multi_prop_from_multi_link_05(self): target_a = default.Target(val=7) target_b = default.Target(val=8) target_c = default.Target(val=9) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink() - self.client.sync(original) + await self._sync(original) original.target = [target_a, target_b, target_c] - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 25) - def test_model_sync_computed_multi_prop_from_multi_link_06(self): + async def test_model_sync_computed_multi_prop_from_multi_link_06(self): # Update with val set, initially target has values # target val changes @@ -1071,19 +1253,19 @@ def test_model_sync_computed_multi_prop_from_multi_link_06(self): target_a = default.Target(val=1) target_b = default.Target(val=2) target_c = default.Target(val=3) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original) + await self._sync(original) target_a.val = 7 target_b.val = 8 target_c.val = 9 - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 25) - def test_model_sync_computed_multi_prop_from_multi_link_07(self): + async def test_model_sync_computed_multi_prop_from_multi_link_07(self): # Update with val set, initially target has values # target changes @@ -1092,84 +1274,96 @@ def test_model_sync_computed_multi_prop_from_multi_link_07(self): target_a = default.Target(val=1) target_b = default.Target(val=2) target_c = default.Target(val=3) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original) + await self._sync(original) target_d = default.Target(val=7) target_e = default.Target(val=8) target_f = default.Target(val=9) original.target = [target_d, target_e, target_f] - self.client.sync(original, target_d, target_e, target_f) + await self._sync(original, target_d, target_e, target_f) self.assertEqual(original.val, 25) - def test_model_sync_computed_single_prop_from_exclusive_backlink_01(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_01( + self, + ): # Create new, no source from models.TestModelSyncComputedSingleProp import default original = default.FromExclusiveBacklink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, None) - def test_model_sync_computed_single_prop_from_exclusive_backlink_02(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_02( + self, + ): # Create new, source already exists from models.TestModelSyncComputedSingleProp import default source = default.ExclusiveSource(val=1) - self.client.save(source) + await self._save(source) original = default.FromExclusiveBacklink() source.target = original - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_exclusive_backlink_03(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_03( + self, + ): # Create new, source created alongside object from models.TestModelSyncComputedSingleProp import default original = default.FromExclusiveBacklink() source = default.ExclusiveSource(val=1, target=original) - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_exclusive_backlink_04(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_04( + self, + ): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromExclusiveBacklink()) - mirror = self.client.query_required_single( + await self._sync(default.FromExclusiveBacklink()) + mirror = await self._query_required_single( default.FromExclusiveBacklink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_exclusive_backlink_05(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_05( + self, + ): # Update with val set, initially no source from models.TestModelSyncComputedSingleProp import default source = default.ExclusiveSource(val=9) - self.client.save(source) + await self._save(source) original = default.FromExclusiveBacklink() - self.client.sync(original) + await self._sync(original) source.target = original - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_exclusive_backlink_06(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_06( + self, + ): # Update with val set, initially no source # source val changes @@ -1177,14 +1371,16 @@ def test_model_sync_computed_single_prop_from_exclusive_backlink_06(self): original = default.FromExclusiveBacklink() source = default.ExclusiveSource(val=1, target=original) - self.client.sync(original, source) + await self._sync(original, source) source.val = 9 - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_exclusive_backlink_07(self): + async def test_model_sync_computed_single_prop_from_exclusive_backlink_07( + self, + ): # Update with val set, initially has source # source changes @@ -1192,26 +1388,30 @@ def test_model_sync_computed_single_prop_from_exclusive_backlink_07(self): original = default.FromExclusiveBacklink() source_a = default.ExclusiveSource(val=1, target=original) - self.client.sync(original, source_a) + await self._sync(original, source_a) source_a.target = None - self.client.sync(source_a) + await self._sync(source_a) source_b = default.ExclusiveSource(val=9, target=original) - self.client.sync(original, source_b) + await self._sync(original, source_b) self.assertEqual(original.val, 10) - def test_model_sync_computed_single_prop_from_single_backlink_01(self): + async def test_model_sync_computed_single_prop_from_single_backlink_01( + self, + ): # Create new, no sources from models.TestModelSyncComputedSingleProp import default original = default.FromSingleBacklink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 1) - def test_model_sync_computed_single_prop_from_single_backlink_02(self): + async def test_model_sync_computed_single_prop_from_single_backlink_02( + self, + ): # Create new, sources already exists from models.TestModelSyncComputedSingleProp import default @@ -1219,17 +1419,19 @@ def test_model_sync_computed_single_prop_from_single_backlink_02(self): source_a = default.SingleSource(val=1) source_b = default.SingleSource(val=2) source_c = default.SingleSource(val=3) - self.client.save(source_a, source_b, source_c) + await self._save(source_a, source_b, source_c) original = default.FromSingleBacklink() source_a.target = original source_b.target = original source_c.target = original - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, 7) - def test_model_sync_computed_single_prop_from_single_backlink_03(self): + async def test_model_sync_computed_single_prop_from_single_backlink_03( + self, + ): # Create new, sources created alongside object from models.TestModelSyncComputedSingleProp import default @@ -1238,24 +1440,28 @@ def test_model_sync_computed_single_prop_from_single_backlink_03(self): source_a = default.SingleSource(val=1, target=original) source_b = default.SingleSource(val=2, target=original) source_c = default.SingleSource(val=3, target=original) - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, 7) - def test_model_sync_computed_single_prop_from_single_backlink_04(self): + async def test_model_sync_computed_single_prop_from_single_backlink_04( + self, + ): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromSingleBacklink()) - mirror = self.client.query_required_single( + await self._sync(default.FromSingleBacklink()) + mirror = await self._query_required_single( default.FromSingleBacklink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_single_backlink_05(self): + async def test_model_sync_computed_single_prop_from_single_backlink_05( + self, + ): # Update with val set, initially no sources from models.TestModelSyncComputedSingleProp import default @@ -1263,19 +1469,21 @@ def test_model_sync_computed_single_prop_from_single_backlink_05(self): source_a = default.SingleSource(val=7) source_b = default.SingleSource(val=8) source_c = default.SingleSource(val=9) - self.client.save(source_a, source_b, source_c) + await self._save(source_a, source_b, source_c) original = default.FromSingleBacklink() - self.client.sync(original) + await self._sync(original) source_a.target = original source_b.target = original source_c.target = original - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, 25) - def test_model_sync_computed_single_prop_from_single_backlink_06(self): + async def test_model_sync_computed_single_prop_from_single_backlink_06( + self, + ): # Update with val set, initially no sources # source vals changes @@ -1285,16 +1493,18 @@ def test_model_sync_computed_single_prop_from_single_backlink_06(self): source_a = default.SingleSource(val=1, target=original) source_b = default.SingleSource(val=2, target=original) source_c = default.SingleSource(val=3, target=original) - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) source_a.val = 7 source_b.val = 8 source_c.val = 9 - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, 25) - def test_model_sync_computed_single_prop_from_single_backlink_07(self): + async def test_model_sync_computed_single_prop_from_single_backlink_07( + self, + ): # Update with val set, initially has sources # sources change @@ -1304,106 +1514,106 @@ def test_model_sync_computed_single_prop_from_single_backlink_07(self): source_a = default.SingleSource(val=1) source_b = default.SingleSource(val=2) source_c = default.SingleSource(val=3) - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) source_a.target = None source_b.target = None source_c.target = None - self.client.sync(source_a, source_b, source_c) + await self._sync(source_a, source_b, source_c) source_d = default.SingleSource(val=7, target=original) source_e = default.SingleSource(val=8, target=original) source_f = default.SingleSource(val=9, target=original) - self.client.sync(original, source_d, source_e, source_f) + await self._sync(original, source_d, source_e, source_f) self.assertEqual(original.val, 25) - def test_model_sync_computed_single_prop_from_stable_expr_01(self): + async def test_model_sync_computed_single_prop_from_stable_expr_01(self): # Create new, expr prop is None from models.TestModelSyncComputedSingleProp import default original = default.FromStableExpr() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, 1) - def test_model_sync_computed_single_prop_from_stable_expr_02(self): + async def test_model_sync_computed_single_prop_from_stable_expr_02(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromStableExpr()) - mirror = self.client.query_required_single( + await self._sync(default.FromStableExpr()) + mirror = await self._query_required_single( default.FromStableExpr.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_stable_expr_03(self): + async def test_model_sync_computed_single_prop_from_stable_expr_03(self): # Update with val set, initially None from models.TestModelSyncComputedSingleProp import default original = default.FromStableExpr() - self.client.sync(original) + await self._sync(original) # This increments val by 1 other = default.FromStableExpr() - self.client.sync(original, other) + await self._sync(original, other) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_global_01(self): + async def test_model_sync_computed_single_prop_from_global_01(self): # Create new, global is None from models.TestModelSyncComputedSingleProp import default original = default.FromGlobal() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, None) - def test_model_sync_computed_single_prop_from_global_02(self): + async def test_model_sync_computed_single_prop_from_global_02(self): # Create new, global has value from models.TestModelSyncComputedSingleProp import default sess_client = self.client.with_globals({"default::SomeGlobal": 1}) original = default.FromGlobal() - sess_client.sync(original) + await self._sync_with_client(sess_client, original) self.assertEqual(original.val, 2) - def test_model_sync_computed_single_prop_from_global_03(self): + async def test_model_sync_computed_single_prop_from_global_03(self): # Update without val set does not fetch it from models.TestModelSyncComputedSingleProp import default - self.client.sync(default.FromGlobal()) - mirror = self.client.query_required_single( + await self._sync(default.FromGlobal()) + mirror = await self._query_required_single( default.FromGlobal.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_single_prop_from_global_04(self): + async def test_model_sync_computed_single_prop_from_global_04(self): # Update with val set, initially None from models.TestModelSyncComputedSingleProp import default sess_client = self.client.with_globals({"default::SomeGlobal": 1}) original = default.FromGlobal() - sess_client.sync(original) + await self._sync_with_client(sess_client, original) sess_client = self.client.with_globals({"default::SomeGlobal": 9}) - sess_client.sync(original) + await self._sync_with_client(sess_client, original) self.assertEqual(original.val, 10) -class TestModelSyncMultiProp(tb.ModelTestCase): +class TestModelSyncMultiProp(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -1434,7 +1644,7 @@ class TestModelSyncMultiProp(tb.ModelTestCase): }; """ - def _base_change_testcase( + async def _base_change_testcase( self, model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], @@ -1444,15 +1654,15 @@ def _base_change_testcase( expected_val = copy.deepcopy(expected_val) original = model_type(val=initial_val) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(val=True).limit(1) ) - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(val=True).limit(1) ) - mirror_3 = self.client.query_required_single( + mirror_3 = await self._query_required_single( model_type.select(val=False).limit(1) ) @@ -1466,7 +1676,7 @@ def _base_change_testcase( change_original(original) # sync some of the objects - self.client.sync(original, mirror_1, mirror_3) + await self._sync(original, mirror_1, mirror_3) # only synced objects with value set get update self.assertEqual(original.val, expected_val) @@ -1475,14 +1685,14 @@ def _base_change_testcase( # self.assertEqual(mirror_3.val, []) # Fail # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) - def test_model_sync_multi_prop_01(self): + async def test_model_sync_multi_prop_01(self): # Insert new object with multi prop from models.TestModelSyncMultiProp import default - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], val: typing.Any, *, @@ -1493,15 +1703,15 @@ def _testcase( # sync one at a time with_val = model_type(val=val) - self.client.sync(with_val) + await self._sync(with_val) self.assertEqual(with_val.val, val) with_unset = model_type() - self.client.sync(with_unset) + await self._sync(with_unset) self.assertEqual(with_unset.val, default_val) with_empty = model_type(val=[]) - self.client.sync(with_empty) + await self._sync(with_empty) self.assertEqual(with_empty.val, []) # sync all together @@ -1509,32 +1719,32 @@ def _testcase( with_unset = model_type() with_empty = model_type(val=[]) - self.client.sync(with_val, with_unset, with_empty) + await self._sync(with_val, with_unset, with_empty) self.assertEqual(with_val.val, val) self.assertEqual(with_unset.val, default_val) self.assertEqual(with_empty.val, []) # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) - _testcase(default.A, [1, 2, 3]) - _testcase(default.B, [[1], [2, 2], [3, 3, 3]]) - _testcase(default.C, [("a", 1), ("b", 2), ("c", 3)]) + await _testcase(default.A, [1, 2, 3]) + await _testcase(default.B, [[1], [2, 2], [3, 3, 3]]) + await _testcase(default.C, [("a", 1), ("b", 2), ("c", 3)]) - _testcase(default.Az, [1, 2, 3], default_val=[-1, -2, -3]) - _testcase( + await _testcase(default.Az, [1, 2, 3], default_val=[-1, -2, -3]) + await _testcase( default.Bz, [[1], [2, 2], [3, 3, 3]], default_val=[[-1], [-2, -2], [-3, -3, -3]], ) - _testcase( + await _testcase( default.Cz, [("a", 1), ("b", 2), ("c", 3)], default_val=[(".", -1), (".", -2), (".", -3)], ) - def test_model_sync_multi_prop_02(self): + async def test_model_sync_multi_prop_02(self): # Updating existing objects with multi props # Set prop to new value @@ -1546,12 +1756,12 @@ def change(original: GelModel): return change - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], changed_val: typing.Collection[typing.Any], ) -> None: - self._base_change_testcase( + await self._base_change_testcase( model_type, initial_val, _get_assign_val_func(changed_val), @@ -1560,43 +1770,43 @@ def _testcase( from models.TestModelSyncMultiProp import default - _testcase(default.A, [], []) - _testcase(default.A, [], [1, 2, 3]) - _testcase(default.A, [1, 2, 3], []) - _testcase(default.A, [1, 2, 3], [2, 3, 4]) - _testcase(default.A, [1, 2, 3], [4, 5, 6]) - - _testcase(default.B, [], []) - _testcase(default.B, [], [[]]) - _testcase(default.B, [], [[1], [2, 2], [3, 3, 3]]) - _testcase(default.B, [[1], [2, 2], [3, 3, 3]], []) - _testcase(default.B, [[1], [2, 2], [3, 3, 3]], [[]]) - _testcase( + await _testcase(default.A, [], []) + await _testcase(default.A, [], [1, 2, 3]) + await _testcase(default.A, [1, 2, 3], []) + await _testcase(default.A, [1, 2, 3], [2, 3, 4]) + await _testcase(default.A, [1, 2, 3], [4, 5, 6]) + + await _testcase(default.B, [], []) + await _testcase(default.B, [], [[]]) + await _testcase(default.B, [], [[1], [2, 2], [3, 3, 3]]) + await _testcase(default.B, [[1], [2, 2], [3, 3, 3]], []) + await _testcase(default.B, [[1], [2, 2], [3, 3, 3]], [[]]) + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [[2, 2], [3, 3, 3], [4, 4, 4, 4]], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [[4], [5, 5], [6, 6, 6]], ) - _testcase(default.C, [], []) - _testcase(default.C, [], [("a", 1), ("b", 2), ("c", 3)]) - _testcase(default.C, [("a", 1), ("b", 2), ("c", 3)], []) - _testcase( + await _testcase(default.C, [], []) + await _testcase(default.C, [], [("a", 1), ("b", 2), ("c", 3)]) + await _testcase(default.C, [("a", 1), ("b", 2), ("c", 3)], []) + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [("b", 2), ("c", 3), ("d", 4)], ) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [("d", 4), ("e", 5), ("f", 6)], ) - def test_model_sync_multi_prop_03(self): + async def test_model_sync_multi_prop_03(self): # Updating existing objects with multi props # Tracked list insert @@ -1609,14 +1819,14 @@ def change(original: GelModel): return change - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], insert_pos: int, insert_val: typing.Any, expected_val: typing.Collection[typing.Any], ) -> None: - self._base_change_testcase( + await self._base_change_testcase( model_type, initial_val, _get_insert_val_func(insert_pos, insert_val), @@ -1625,19 +1835,19 @@ def _testcase( from models.TestModelSyncMultiProp import default - _testcase(default.A, [], 0, 9, [9]) - _testcase(default.A, [1, 2, 3], 2, 9, [1, 2, 3, 9]) + await _testcase(default.A, [], 0, 9, [9]) + await _testcase(default.A, [1, 2, 3], 2, 9, [1, 2, 3, 9]) - _testcase(default.B, [], 0, [], [[]]) - _testcase(default.B, [], 0, [9], [[9]]) - _testcase( + await _testcase(default.B, [], 0, [], [[]]) + await _testcase(default.B, [], 0, [9], [[9]]) + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], 2, [], [[1], [2, 2], [3, 3, 3], []], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], 2, @@ -1645,8 +1855,8 @@ def _testcase( [[1], [2, 2], [3, 3, 3], [9]], ) - _testcase(default.C, [], 0, ("i", 9), [("i", 9)]) - _testcase( + await _testcase(default.C, [], 0, ("i", 9), [("i", 9)]) + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], 2, @@ -1654,7 +1864,7 @@ def _testcase( [("a", 1), ("b", 2), ("c", 3), ("i", 9)], ) - def test_model_sync_multi_prop_04(self): + async def test_model_sync_multi_prop_04(self): # Updating existing objects with multi props # Tracked list extend @@ -1666,13 +1876,13 @@ def change(original: GelModel): return change - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], extend_vals: typing.Collection[typing.Any], expected_val: typing.Collection[typing.Any], ) -> None: - self._base_change_testcase( + await self._base_change_testcase( model_type, initial_val, _get_extend_val_func(extend_vals), @@ -1681,75 +1891,75 @@ def _testcase( from models.TestModelSyncMultiProp import default - _testcase(default.A, [], [], []) - _testcase(default.A, [], [1], [1]) - _testcase(default.A, [1, 2, 3], [], [1, 2, 3]) - _testcase(default.A, [1, 2, 3], [1, 2, 3], [1, 2, 3, 1, 2, 3]) - _testcase(default.A, [1, 2, 3], [2, 3, 4], [1, 2, 3, 2, 3, 4]) - _testcase(default.A, [1, 2, 3], [4, 5, 6], [1, 2, 3, 4, 5, 6]) - - _testcase(default.B, [], [], []) - _testcase(default.B, [], [[]], [[]]) - _testcase(default.B, [], [[1]], [[1]]) - _testcase( + await _testcase(default.A, [], [], []) + await _testcase(default.A, [], [1], [1]) + await _testcase(default.A, [1, 2, 3], [], [1, 2, 3]) + await _testcase(default.A, [1, 2, 3], [1, 2, 3], [1, 2, 3, 1, 2, 3]) + await _testcase(default.A, [1, 2, 3], [2, 3, 4], [1, 2, 3, 2, 3, 4]) + await _testcase(default.A, [1, 2, 3], [4, 5, 6], [1, 2, 3, 4, 5, 6]) + + await _testcase(default.B, [], [], []) + await _testcase(default.B, [], [[]], [[]]) + await _testcase(default.B, [], [[1]], [[1]]) + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [], [[1], [2, 2], [3, 3, 3]], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [[]], [[1], [2, 2], [3, 3, 3], []], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [[1], [2, 2], [3, 3, 3]], [[1], [2, 2], [3, 3, 3], [1], [2, 2], [3, 3, 3]], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [[2, 2], [3, 3, 3], [4, 4, 4, 4]], [[1], [2, 2], [3, 3, 3], [2, 2], [3, 3, 3], [4, 4, 4, 4]], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [[4], [5], [6]], [[1], [2, 2], [3, 3, 3], [4], [5], [6]], ) - _testcase(default.C, [], [], []) - _testcase(default.C, [], [("a", 1)], [("a", 1)]) - _testcase( + await _testcase(default.C, [], [], []) + await _testcase(default.C, [], [("a", 1)], [("a", 1)]) + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [], [("a", 1), ("b", 2), ("c", 3)], ) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [("a", 1), ("b", 2), ("c", 3)], [("a", 1), ("b", 2), ("c", 3), ("a", 1), ("b", 2), ("c", 3)], ) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [("b", 2), ("c", 3), ("d", 4)], [("a", 1), ("b", 2), ("c", 3), ("b", 2), ("c", 3), ("d", 4)], ) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [("d", 4), ("e", 5), ("f", 6)], [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5), ("f", 6)], ) - def test_model_sync_multi_prop_05(self): + async def test_model_sync_multi_prop_05(self): # Updating existing objects with multi props # Tracked list append @@ -1761,13 +1971,13 @@ def change(original: GelModel): return change - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], append_val: typing.Any, expected_val: typing.Collection[typing.Any], ) -> None: - self._base_change_testcase( + await self._base_change_testcase( model_type, initial_val, _get_append_val_func(append_val), @@ -1776,61 +1986,61 @@ def _testcase( from models.TestModelSyncMultiProp import default - _testcase(default.A, [], 1, [1]) - _testcase(default.A, [1, 2, 3], 2, [1, 2, 3, 2]) - _testcase(default.A, [1, 2, 3], 4, [1, 2, 3, 4]) + await _testcase(default.A, [], 1, [1]) + await _testcase(default.A, [1, 2, 3], 2, [1, 2, 3, 2]) + await _testcase(default.A, [1, 2, 3], 4, [1, 2, 3, 4]) - _testcase( + await _testcase( default.B, [], [], [[]], ) - _testcase( + await _testcase( default.B, [], [1], [[1]], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [], [[1], [2, 2], [3, 3, 3], []], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [2, 2], [[1], [2, 2], [3, 3, 3], [2, 2]], ) - _testcase( + await _testcase( default.B, [[1], [2, 2], [3, 3, 3]], [4, 4, 4, 4], [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]], ) - _testcase( + await _testcase( default.C, [], ("a", 1), [("a", 1)], ) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], ("b", 2), [("a", 1), ("b", 2), ("c", 3), ("b", 2)], ) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], ("d", 4), [("a", 1), ("b", 2), ("c", 3), ("d", 4)], ) - def test_model_sync_multi_prop_06(self): + async def test_model_sync_multi_prop_06(self): # Updating existing objects with multi props # Tracked list pop @@ -1840,12 +2050,12 @@ def change(original: GelModel): return change - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], expected_val: typing.Collection[typing.Any], ) -> None: - self._base_change_testcase( + await self._base_change_testcase( model_type, initial_val, _get_pop_val_func(), @@ -1854,17 +2064,17 @@ def _testcase( from models.TestModelSyncMultiProp import default - _testcase(default.A, [1, 2, 3], [1, 2]) + await _testcase(default.A, [1, 2, 3], [1, 2]) - _testcase(default.B, [[1], [2, 2], [3, 3, 3]], [[1], [2, 2]]) + await _testcase(default.B, [[1], [2, 2], [3, 3, 3]], [[1], [2, 2]]) - _testcase( + await _testcase( default.C, [("a", 1), ("b", 2), ("c", 3)], [("a", 1), ("b", 2)], ) - def test_model_sync_multi_prop_07(self): + async def test_model_sync_multi_prop_07(self): # Updating existing objects with single props # Clear prop @@ -1874,11 +2084,11 @@ def change(original: GelModel): return change - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Collection[typing.Any], ) -> None: - self._base_change_testcase( + await self._base_change_testcase( model_type, initial_val, _get_clear_val_func(), @@ -1887,20 +2097,20 @@ def _testcase( from models.TestModelSyncMultiProp import default - _testcase(default.A, []) - _testcase(default.A, [1, 2, 3]) + await _testcase(default.A, []) + await _testcase(default.A, [1, 2, 3]) - _testcase(default.B, []) - _testcase(default.B, [[1], [2, 2], [3, 3, 3]]) + await _testcase(default.B, []) + await _testcase(default.B, [[1], [2, 2], [3, 3, 3]]) - _testcase(default.C, []) - _testcase(default.C, [("a", 1), ("b", 2), ("c", 3)]) + await _testcase(default.C, []) + await _testcase(default.C, [("a", 1), ("b", 2), ("c", 3)]) @tb.xfail - def test_model_sync_multi_prop_08(self): + async def test_model_sync_multi_prop_08(self): # Existing object without prop should not have it fetched - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_val: typing.Any, changed_val_0: typing.Any, @@ -1908,48 +2118,52 @@ def _testcase( changed_val_2: typing.Any, ): original = model_type(val=initial_val) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(val=False).limit(1) ) original.val = changed_val_0 - self.client.save(original) - self.client.sync(mirror_1) + await self._save(original) + await self._sync(mirror_1) self.assertEqual(mirror_1.val._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.val._items, []) # Sync alongside another object with the prop set - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(val=True).limit(1) ) original.val = changed_val_1 - self.client.save(original) - self.client.sync(mirror_1, mirror_2) + await self._save(original) + await self._sync(mirror_1, mirror_2) self.assertEqual(mirror_1.val._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.val._items, []) # Sync alongside another object with the prop changed - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(targets=True).limit(1) ) mirror_2.val = changed_val_2 - self.client.save(original) - self.client.sync(mirror_1, mirror_2) + await self._save(original) + await self._sync(mirror_1, mirror_2) self.assertEqual(mirror_1.targets._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.targets._items, []) # Fail # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) from models.TestModelSyncMultiProp import default - _testcase(default.A, [1], [2], [3], [4]) - _testcase(default.B, [[1]], [[2, 2]], [[3, 3, 3]], [[4, 4, 4, 4]]) - _testcase(default.C, [("a", 1)], [("b", 2)], [("c", 3)], [("d", 4)]) + await _testcase(default.A, [1], [2], [3], [4]) + await _testcase( + default.B, [[1]], [[2, 2]], [[3, 3, 3]], [[4, 4, 4, 4]] + ) + await _testcase( + default.C, [("a", 1)], [("b", 2)], [("c", 3)], [("d", 4)] + ) -class TestModelSyncComputedMultiProp(tb.ModelTestCase): +class TestModelSyncComputedMultiProp(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -2013,254 +2227,254 @@ class TestModelSyncComputedMultiProp(tb.ModelTestCase): }; """ - def test_model_sync_computed_multi_prop_constant_01(self): + async def test_model_sync_computed_multi_prop_constant_01(self): # Create new from models.TestModelSyncComputedMultiProp import default original = default.FromConstant() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (1, 2, 3)) - def test_model_sync_computed_multi_prop_constant_02(self): + async def test_model_sync_computed_multi_prop_constant_02(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromConstant()) - mirror = self.client.query_required_single( + await self._sync(default.FromConstant()) + mirror = await self._query_required_single( default.FromConstant.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_single_prop_01(self): + async def test_model_sync_computed_multi_prop_from_single_prop_01(self): # Create new, expr prop is None from models.TestModelSyncComputedMultiProp import default original = default.FromSingleProp() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, ()) - def test_model_sync_computed_multi_prop_from_single_prop_02(self): + async def test_model_sync_computed_multi_prop_from_single_prop_02(self): # Create new, expr prop has value from models.TestModelSyncComputedMultiProp import default original = default.FromSingleProp(n=1) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_single_prop_03(self): + async def test_model_sync_computed_multi_prop_from_single_prop_03(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromSingleProp()) - mirror = self.client.query_required_single( + await self._sync(default.FromSingleProp()) + mirror = await self._query_required_single( default.FromSingleProp.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_single_prop_04(self): + async def test_model_sync_computed_multi_prop_from_single_prop_04(self): # Update with val set, initially None from models.TestModelSyncComputedMultiProp import default original = default.FromSingleProp() - self.client.sync(original) + await self._sync(original) original.n = 9 - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_single_prop_05(self): + async def test_model_sync_computed_multi_prop_from_single_prop_05(self): # Update with val set, initially not None from models.TestModelSyncComputedMultiProp import default original = default.FromSingleProp(n=1) - self.client.sync(original) + await self._sync(original) original.n = 9 - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_multi_prop_01(self): + async def test_model_sync_computed_multi_prop_from_multi_prop_01(self): # Create new, expr prop is empty from models.TestModelSyncComputedMultiProp import default original = default.FromMultiProp() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 1) - def test_model_sync_computed_multi_prop_from_multi_prop_02(self): + async def test_model_sync_computed_multi_prop_from_multi_prop_02(self): # Create new, expr prop has values from models.TestModelSyncComputedMultiProp import default original = default.FromMultiProp(n=[1, 2, 3]) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 7) - def test_model_sync_computed_multi_prop_from_multi_prop_03(self): + async def test_model_sync_computed_multi_prop_from_multi_prop_03(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromMultiProp()) - mirror = self.client.query_required_single( + await self._sync(default.FromMultiProp()) + mirror = await self._query_required_single( default.FromMultiProp.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_multi_prop_04(self): + async def test_model_sync_computed_multi_prop_from_multi_prop_04(self): # Update with val set, initially empty from models.TestModelSyncComputedMultiProp import default original = default.FromMultiProp() - self.client.sync(original) + await self._sync(original) original.n = [7, 8, 9] - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_multi_prop_05(self): + async def test_model_sync_computed_multi_prop_from_multi_prop_05(self): # Update with val set, initially has values from models.TestModelSyncComputedMultiProp import default original = default.FromMultiProp(n=[1, 2, 3]) - self.client.sync(original) + await self._sync(original) original.n = [7, 8, 9] - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_single_link_01(self): + async def test_model_sync_computed_multi_prop_from_single_link_01(self): # Create new, expr prop is None from models.TestModelSyncComputedMultiProp import default original = default.FromSingleLink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, ()) - def test_model_sync_computed_multi_prop_from_single_link_02(self): + async def test_model_sync_computed_multi_prop_from_single_link_02(self): # Create new, target already exists from models.TestModelSyncComputedMultiProp import default target = default.Target(val=1) - self.client.save(target) + await self._save(target) original = default.FromSingleLink(target=target) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_single_link_03(self): + async def test_model_sync_computed_multi_prop_from_single_link_03(self): # Create new, target created alongside object from models.TestModelSyncComputedMultiProp import default target = default.Target(val=1) original = default.FromSingleLink(target=target) - self.client.sync(original, target) + await self._sync(original, target) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_single_link_04(self): + async def test_model_sync_computed_multi_prop_from_single_link_04(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromSingleLink()) - mirror = self.client.query_required_single( + await self._sync(default.FromSingleLink()) + mirror = await self._query_required_single( default.FromSingleLink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_single_link_05(self): + async def test_model_sync_computed_multi_prop_from_single_link_05(self): # Update with val set, initially target is None from models.TestModelSyncComputedMultiProp import default target = default.Target(val=9) original = default.FromSingleLink() - self.client.sync(original, target) + await self._sync(original, target) original.target = target - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_single_link_06(self): + async def test_model_sync_computed_multi_prop_from_single_link_06(self): # Update with val set, initially target is set # target val changes from models.TestModelSyncComputedMultiProp import default target = default.Target(val=1) - self.client.save(target) + await self._save(target) original = default.FromSingleLink(target=target) - self.client.sync(original) + await self._sync(original) target.val = 9 - self.client.sync(original, target) + await self._sync(original, target) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_single_link_07(self): + async def test_model_sync_computed_multi_prop_from_single_link_07(self): # Update with val set, initially target is set # target changes from models.TestModelSyncComputedMultiProp import default target_a = default.Target(val=1) - self.client.save(target_a) + await self._save(target_a) original = default.FromSingleLink(target=target_a) - self.client.sync(original) + await self._sync(original) target_b = default.Target(val=9) original.target = target_b - self.client.sync(original, target_b) + await self._sync(original, target_b) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_multi_link_01(self): + async def test_model_sync_computed_multi_prop_from_multi_link_01(self): # Create new, expr prop is None from models.TestModelSyncComputedMultiProp import default original = default.FromMultiLink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 1) - def test_model_sync_computed_multi_prop_from_multi_link_02(self): + async def test_model_sync_computed_multi_prop_from_multi_link_02(self): # Create new, target already exists from models.TestModelSyncComputedMultiProp import default @@ -2268,14 +2482,14 @@ def test_model_sync_computed_multi_prop_from_multi_link_02(self): target_a = default.Target(val=1) target_b = default.Target(val=2) target_c = default.Target(val=3) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 7) - def test_model_sync_computed_multi_prop_from_multi_link_03(self): + async def test_model_sync_computed_multi_prop_from_multi_link_03(self): # Create new, target created alongside object from models.TestModelSyncComputedMultiProp import default @@ -2284,24 +2498,24 @@ def test_model_sync_computed_multi_prop_from_multi_link_03(self): target_b = default.Target(val=2) target_c = default.Target(val=3) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original, target_a, target_b, target_c) + await self._sync(original, target_a, target_b, target_c) self.assertEqual(original.val, (9,) * 7) - def test_model_sync_computed_multi_prop_from_multi_link_04(self): + async def test_model_sync_computed_multi_prop_from_multi_link_04(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromMultiLink()) - mirror = self.client.query_required_single( + await self._sync(default.FromMultiLink()) + mirror = await self._query_required_single( default.FromMultiLink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_multi_link_05(self): + async def test_model_sync_computed_multi_prop_from_multi_link_05(self): # Update with val set, initially target is empty from models.TestModelSyncComputedMultiProp import default @@ -2309,17 +2523,17 @@ def test_model_sync_computed_multi_prop_from_multi_link_05(self): target_a = default.Target(val=7) target_b = default.Target(val=8) target_c = default.Target(val=9) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink() - self.client.sync(original) + await self._sync(original) original.target = [target_a, target_b, target_c] - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_multi_link_06(self): + async def test_model_sync_computed_multi_prop_from_multi_link_06(self): # Update with val set, initially target has values # target val changes @@ -2328,19 +2542,19 @@ def test_model_sync_computed_multi_prop_from_multi_link_06(self): target_a = default.Target(val=1) target_b = default.Target(val=2) target_c = default.Target(val=3) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original) + await self._sync(original) target_a.val = 7 target_b.val = 8 target_c.val = 9 - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_multi_link_07(self): + async def test_model_sync_computed_multi_prop_from_multi_link_07(self): # Update with val set, initially target has values # target changes @@ -2349,84 +2563,96 @@ def test_model_sync_computed_multi_prop_from_multi_link_07(self): target_a = default.Target(val=1) target_b = default.Target(val=2) target_c = default.Target(val=3) - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) original = default.FromMultiLink(target=[target_a, target_b, target_c]) - self.client.sync(original) + await self._sync(original) target_d = default.Target(val=7) target_e = default.Target(val=8) target_f = default.Target(val=9) original.target = [target_d, target_e, target_f] - self.client.sync(original, target_d, target_e, target_f) + await self._sync(original, target_d, target_e, target_f) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_01(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_01( + self, + ): # Create new, no source from models.TestModelSyncComputedMultiProp import default original = default.FromExclusiveBacklink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, ()) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_02(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_02( + self, + ): # Create new, source already exists from models.TestModelSyncComputedMultiProp import default source = default.ExclusiveSource(val=1) - self.client.save(source) + await self._save(source) original = default.FromExclusiveBacklink() source.target = original - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_03(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_03( + self, + ): # Create new, source created alongside object from models.TestModelSyncComputedMultiProp import default original = default.FromExclusiveBacklink() source = default.ExclusiveSource(val=1, target=original) - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_04(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_04( + self, + ): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromExclusiveBacklink()) - mirror = self.client.query_required_single( + await self._sync(default.FromExclusiveBacklink()) + mirror = await self._query_required_single( default.FromExclusiveBacklink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_05(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_05( + self, + ): # Update with val set, initially no source from models.TestModelSyncComputedMultiProp import default source = default.ExclusiveSource(val=9) - self.client.save(source) + await self._save(source) original = default.FromExclusiveBacklink() - self.client.sync(original) + await self._sync(original) source.target = original - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_06(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_06( + self, + ): # Update with val set, initially no source # source val changes @@ -2434,14 +2660,16 @@ def test_model_sync_computed_multi_prop_from_exclusive_backlink_06(self): original = default.FromExclusiveBacklink() source = default.ExclusiveSource(val=1, target=original) - self.client.sync(original, source) + await self._sync(original, source) source.val = 9 - self.client.sync(original, source) + await self._sync(original, source) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_exclusive_backlink_07(self): + async def test_model_sync_computed_multi_prop_from_exclusive_backlink_07( + self, + ): # Update with val set, initially has source # source changes @@ -2449,26 +2677,30 @@ def test_model_sync_computed_multi_prop_from_exclusive_backlink_07(self): original = default.FromExclusiveBacklink() source_a = default.ExclusiveSource(val=1, target=original) - self.client.sync(original, source_a) + await self._sync(original, source_a) source_a.target = None - self.client.sync(source_a) + await self._sync(source_a) source_b = default.ExclusiveSource(val=9, target=original) - self.client.sync(original, source_b) + await self._sync(original, source_b) self.assertEqual(original.val, (9,) * 10) - def test_model_sync_computed_multi_prop_from_single_backlink_01(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_01( + self, + ): # Create new, no sources from models.TestModelSyncComputedMultiProp import default original = default.FromSingleBacklink() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 1) - def test_model_sync_computed_multi_prop_from_single_backlink_02(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_02( + self, + ): # Create new, sources already exists from models.TestModelSyncComputedMultiProp import default @@ -2476,17 +2708,19 @@ def test_model_sync_computed_multi_prop_from_single_backlink_02(self): source_a = default.SingleSource(val=1) source_b = default.SingleSource(val=2) source_c = default.SingleSource(val=3) - self.client.save(source_a, source_b, source_c) + await self._save(source_a, source_b, source_c) original = default.FromSingleBacklink() source_a.target = original source_b.target = original source_c.target = original - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, (9,) * 7) - def test_model_sync_computed_multi_prop_from_single_backlink_03(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_03( + self, + ): # Create new, sources created alongside object from models.TestModelSyncComputedMultiProp import default @@ -2495,24 +2729,28 @@ def test_model_sync_computed_multi_prop_from_single_backlink_03(self): source_a = default.SingleSource(val=1, target=original) source_b = default.SingleSource(val=2, target=original) source_c = default.SingleSource(val=3, target=original) - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, (9,) * 7) - def test_model_sync_computed_multi_prop_from_single_backlink_04(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_04( + self, + ): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromSingleBacklink()) - mirror = self.client.query_required_single( + await self._sync(default.FromSingleBacklink()) + mirror = await self._query_required_single( default.FromSingleBacklink.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_single_backlink_05(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_05( + self, + ): # Update with val set, initially no sources from models.TestModelSyncComputedMultiProp import default @@ -2520,19 +2758,21 @@ def test_model_sync_computed_multi_prop_from_single_backlink_05(self): source_a = default.SingleSource(val=7) source_b = default.SingleSource(val=8) source_c = default.SingleSource(val=9) - self.client.save(source_a, source_b, source_c) + await self._save(source_a, source_b, source_c) original = default.FromSingleBacklink() - self.client.sync(original) + await self._sync(original) source_a.target = original source_b.target = original source_c.target = original - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_single_backlink_06(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_06( + self, + ): # Update with val set, initially no sources # source vals changes @@ -2542,16 +2782,18 @@ def test_model_sync_computed_multi_prop_from_single_backlink_06(self): source_a = default.SingleSource(val=1, target=original) source_b = default.SingleSource(val=2, target=original) source_c = default.SingleSource(val=3, target=original) - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) source_a.val = 7 source_b.val = 8 source_c.val = 9 - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_single_backlink_07(self): + async def test_model_sync_computed_multi_prop_from_single_backlink_07( + self, + ): # Update with val set, initially has sources # sources change @@ -2561,106 +2803,106 @@ def test_model_sync_computed_multi_prop_from_single_backlink_07(self): source_a = default.SingleSource(val=1) source_b = default.SingleSource(val=2) source_c = default.SingleSource(val=3) - self.client.sync(original, source_a, source_b, source_c) + await self._sync(original, source_a, source_b, source_c) source_a.target = None source_b.target = None source_c.target = None - self.client.sync(source_a, source_b, source_c) + await self._sync(source_a, source_b, source_c) source_d = default.SingleSource(val=7, target=original) source_e = default.SingleSource(val=8, target=original) source_f = default.SingleSource(val=9, target=original) - self.client.sync(original, source_d, source_e, source_f) + await self._sync(original, source_d, source_e, source_f) self.assertEqual(original.val, (9,) * 25) - def test_model_sync_computed_multi_prop_from_stable_expr_01(self): + async def test_model_sync_computed_multi_prop_from_stable_expr_01(self): # Create new, expr prop is None from models.TestModelSyncComputedMultiProp import default original = default.FromStableExpr() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, (9,) * 1) - def test_model_sync_computed_multi_prop_from_stable_expr_02(self): + async def test_model_sync_computed_multi_prop_from_stable_expr_02(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromStableExpr()) - mirror = self.client.query_required_single( + await self._sync(default.FromStableExpr()) + mirror = await self._query_required_single( default.FromStableExpr.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_stable_expr_03(self): + async def test_model_sync_computed_multi_prop_from_stable_expr_03(self): # Update with val set, initially None from models.TestModelSyncComputedMultiProp import default original = default.FromStableExpr() - self.client.sync(original) + await self._sync(original) # This increments val by 1 other = default.FromStableExpr() - self.client.sync(original, other) + await self._sync(original, other) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_global_01(self): + async def test_model_sync_computed_multi_prop_from_global_01(self): # Create new, global is None from models.TestModelSyncComputedMultiProp import default original = default.FromGlobal() - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, ()) - def test_model_sync_computed_multi_prop_from_global_02(self): + async def test_model_sync_computed_multi_prop_from_global_02(self): # Create new, global has value from models.TestModelSyncComputedMultiProp import default sess_client = self.client.with_globals({"default::SomeGlobal": 1}) original = default.FromGlobal() - sess_client.sync(original) + await self._sync_with_client(sess_client, original) self.assertEqual(original.val, (9,) * 2) - def test_model_sync_computed_multi_prop_from_global_03(self): + async def test_model_sync_computed_multi_prop_from_global_03(self): # Update without val set does not fetch it from models.TestModelSyncComputedMultiProp import default - self.client.sync(default.FromGlobal()) - mirror = self.client.query_required_single( + await self._sync(default.FromGlobal()) + mirror = await self._query_required_single( default.FromGlobal.select(val=False).limit(1) ) - self.client.sync(mirror) + await self._sync(mirror) self.assertFalse(hasattr(mirror, 'val')) - def test_model_sync_computed_multi_prop_from_global_04(self): + async def test_model_sync_computed_multi_prop_from_global_04(self): # Update with val set, initially None from models.TestModelSyncComputedMultiProp import default sess_client = self.client.with_globals({"default::SomeGlobal": 1}) original = default.FromGlobal() - sess_client.sync(original) + await self._sync_with_client(sess_client, original) sess_client = self.client.with_globals({"default::SomeGlobal": 9}) - sess_client.sync(original) + await self._sync_with_client(sess_client, original) self.assertEqual(original.val, (9,) * 10) -class TestModelSyncSingleLink(tb.ModelTestCase): +class TestModelSyncSingleLink(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -2725,10 +2967,10 @@ def _check_links_equal( expected.__linkprops__, ) - def test_model_sync_single_link_01(self): + async def test_model_sync_single_link_01(self): # Insert new object with single link - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_target: typing.Any, *, @@ -2741,15 +2983,15 @@ def _testcase( # sync one at a type with_target = model_type(target=initial_target) - self.client.sync(with_target) + await self._sync(with_target) self._check_links_equal(with_target.target, expected_target) with_none = model_type(target=None) - self.client.sync(with_none) + await self._sync(with_none) self._check_links_equal(with_none.target, None) with_unset = model_type() - self.client.sync(with_unset) + await self._sync(with_unset) if dml_default_type: self.assertNotEqual(with_unset.target, expected_target) self.assertEqual(type(with_unset.target), dml_default_type) @@ -2761,7 +3003,7 @@ def _testcase( with_none = model_type(target=None) with_unset = model_type() - self.client.sync(with_target, with_none, with_unset) + await self._sync(with_target, with_none, with_unset) self._check_links_equal(with_target.target, expected_target) self._check_links_equal(with_none.target, None) @@ -2772,49 +3014,51 @@ def _testcase( self._check_links_equal(with_unset.target, default_target) # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) from models.TestModelSyncSingleLink import default target = default.Target() - self.client.save(target) + await self._save(target) - _testcase(default.Source, target) + await _testcase(default.Source, target) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target, lprop=1), ) # Passing unwrapped target as link with props automatically wraps # it in a proxy model. - _testcase( + await _testcase( default.SourceWithProp, target, expected_target=default.SourceWithProp.target.link(target), ) - _testcase(default.SourceWithDefault, target, default_target=target) + await _testcase( + default.SourceWithDefault, target, default_target=target + ) - _testcase( + await _testcase( default.SourceWithDefaultAndProp, default.SourceWithDefaultAndProp.target.link(target), default_target=default.SourceWithDefaultAndProp.target.link( target ), ) - _testcase( + await _testcase( default.SourceWithDefaultAndProp, default.SourceWithDefaultAndProp.target.link(target, lprop=1), default_target=default.SourceWithDefaultAndProp.target.link( target ), ) - _testcase( + await _testcase( default.SourceWithDefaultAndProp, target, expected_target=default.SourceWithDefaultAndProp.target.link( @@ -2825,35 +3069,35 @@ def _testcase( ), ) - _testcase( + await _testcase( default.SourceWithDmlDefault, target, dml_default_type=default.Target2, ) # Linkprop with default - _testcase( + await _testcase( default.SourceWithPropWithDefault, target, expected_target=default.SourceWithPropWithDefault.target.link( target, lprop=-1 ), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target), expected_target=default.SourceWithPropWithDefault.target.link( target, lprop=-1 ), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target, lprop=None), expected_target=default.SourceWithPropWithDefault.target.link( target, lprop=None ), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target, lprop=1), expected_target=default.SourceWithPropWithDefault.target.link( @@ -2861,10 +3105,10 @@ def _testcase( ), ) - def test_model_sync_single_link_02(self): + async def test_model_sync_single_link_02(self): # Updating existing objects with single link - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_target: typing.Any, changed_target: typing.Any, @@ -2874,15 +3118,15 @@ def _testcase( expected_target = changed_target original = model_type(target=initial_target) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(target=True).limit(1) ) - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(target=True).limit(1) ) - mirror_3 = self.client.query_required_single( + mirror_3 = await self._query_required_single( model_type.select(target=False).limit(1) ) @@ -2895,7 +3139,7 @@ def _testcase( original.target = changed_target # sync some of the objects - self.client.sync(original, mirror_1, mirror_3) + await self._sync(original, mirror_1, mirror_3) # only synced objects with value set get update self._check_links_equal(original.target, expected_target) @@ -2904,58 +3148,58 @@ def _testcase( self.assertFalse(hasattr(mirror_3, 'val')) # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) from models.TestModelSyncSingleLink import default target_a = default.Target() target_b = default.Target() - self.client.save(target_a, target_b) + await self._save(target_a, target_b) # Change to/from None - _testcase(default.Source, None, target_b) - _testcase(default.Source, target_a, None) + await _testcase(default.Source, None, target_b) + await _testcase(default.Source, target_a, None) - _testcase( + await _testcase( default.SourceWithProp, None, default.SourceWithProp.target.link(target_b), ) - _testcase( + await _testcase( default.SourceWithProp, None, default.SourceWithProp.target.link(target_b, lprop=1), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a), None, ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), None, ) # Change to a new value - _testcase(default.Source, target_a, target_b) + await _testcase(default.Source, target_a, target_b) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a), default.SourceWithProp.target.link(target_b), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), default.SourceWithProp.target.link(target_b), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a), default.SourceWithProp.target.link(target_b, lprop=1), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), default.SourceWithProp.target.link(target_b, lprop=1), @@ -2963,13 +3207,13 @@ def _testcase( # Passing unwrapped target as link with props automatically wraps # it in a proxy model. - _testcase( + await _testcase( default.SourceWithProp, None, target_b, default.SourceWithProp.target.link(target_b), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a), target_b, @@ -2977,50 +3221,50 @@ def _testcase( ) # only changing lprop - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a), default.SourceWithProp.target.link(target_a, lprop=2), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), default.SourceWithProp.target.link(target_a), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), default.SourceWithProp.target.link(target_a, lprop=2), ) # Change to the same value - _testcase(default.Source, None, None) - _testcase(default.Source, target_a, target_a) - _testcase( + await _testcase(default.Source, None, None) + await _testcase(default.Source, target_a, target_a) + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a), default.SourceWithProp.target.link(target_a), ) - _testcase( + await _testcase( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), default.SourceWithProp.target.link(target_a, lprop=1), ) # Linkprop with default - _testcase( + await _testcase( default.SourceWithPropWithDefault, None, target_a, default.SourceWithPropWithDefault.target.link(target_a, lprop=-1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, None, default.SourceWithPropWithDefault.target.link(target_a), default.SourceWithPropWithDefault.target.link(target_a, lprop=-1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, None, default.SourceWithPropWithDefault.target.link( @@ -3030,25 +3274,25 @@ def _testcase( target_a, lprop=None ), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, None, default.SourceWithPropWithDefault.target.link(target_a, lprop=1), default.SourceWithPropWithDefault.target.link(target_a, lprop=1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), target_a, default.SourceWithPropWithDefault.target.link(target_a, lprop=-1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), default.SourceWithPropWithDefault.target.link(target_a), default.SourceWithPropWithDefault.target.link(target_a, lprop=-1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), default.SourceWithPropWithDefault.target.link( @@ -3058,25 +3302,25 @@ def _testcase( target_a, lprop=None ), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), default.SourceWithPropWithDefault.target.link(target_a, lprop=1), default.SourceWithPropWithDefault.target.link(target_a, lprop=1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), target_b, default.SourceWithPropWithDefault.target.link(target_b, lprop=-1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), default.SourceWithPropWithDefault.target.link(target_b), default.SourceWithPropWithDefault.target.link(target_b, lprop=-1), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), default.SourceWithPropWithDefault.target.link( @@ -3086,14 +3330,14 @@ def _testcase( target_b, lprop=None ), ) - _testcase( + await _testcase( default.SourceWithPropWithDefault, default.SourceWithPropWithDefault.target.link(target_a, lprop=9), default.SourceWithPropWithDefault.target.link(target_b, lprop=1), default.SourceWithPropWithDefault.target.link(target_b, lprop=1), ) - def _testcase_03( + async def _testcase_03( self, model_type: typing.Type[GelModel], initial_target: typing.Any, @@ -3102,15 +3346,15 @@ def _testcase_03( changed_target_2: typing.Any, ) -> None: original = model_type(target=initial_target) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(target=True).limit(1) ) - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(target=True).limit(1) ) - mirror_3 = self.client.query_required_single( + mirror_3 = await self._query_required_single( model_type.select(target=False).limit(1) ) @@ -3125,7 +3369,7 @@ def _testcase_03( mirror_2.target = changed_target_2 # sync some of the objects - self.client.sync(original, mirror_1, mirror_3) + await self._sync(original, mirror_1, mirror_3) # only synced objects are updated self._check_links_equal(original.target, changed_target_0) @@ -3134,9 +3378,9 @@ def _testcase_03( self.assertFalse(hasattr(mirror_3, 'val')) # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) - def test_model_sync_single_link_03(self): + async def test_model_sync_single_link_03(self): # Reconciling different changes to single link from models.TestModelSyncSingleLink import default @@ -3145,9 +3389,9 @@ def test_model_sync_single_link_03(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) - self._testcase_03( + await self._testcase_03( default.Source, target_a, target_b, @@ -3156,7 +3400,7 @@ def test_model_sync_single_link_03(self): ) @tb.xfail - def test_model_sync_single_link_03a(self): + async def test_model_sync_single_link_03a(self): # ISE on sync() # gel.errors.InternalServerError: more than one row returned by a # subquery used as an expression @@ -3166,9 +3410,9 @@ def test_model_sync_single_link_03a(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) - self._testcase_03( + await self._testcase_03( default.SourceWithProp, default.SourceWithProp.target.link(target_a), default.SourceWithProp.target.link(target_b), @@ -3177,7 +3421,7 @@ def test_model_sync_single_link_03a(self): ) @tb.xfail - def test_model_sync_single_link_03b(self): + async def test_model_sync_single_link_03b(self): # ISE on sync() # gel.errors.InternalServerError: more than one row returned by a # subquery used as an expression @@ -3187,9 +3431,9 @@ def test_model_sync_single_link_03b(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) - self._testcase_03( + await self._testcase_03( default.SourceWithProp, default.SourceWithProp.target.link(target_a, lprop=1), default.SourceWithProp.target.link(target_a, lprop=2), @@ -3198,7 +3442,7 @@ def test_model_sync_single_link_03b(self): ) @tb.xfail - def test_model_sync_single_link_04(self): + async def test_model_sync_single_link_04(self): # Existing object without link should not have it fetched from models.TestModelSyncSingleLink import default @@ -3207,7 +3451,7 @@ def test_model_sync_single_link_04(self): changed_target_0 = default.Target() changed_target_1 = default.Target() changed_target_2 = default.Target() - self.client.save( + await self._save( initial_target, changed_target_0, changed_target_1, @@ -3215,48 +3459,48 @@ def test_model_sync_single_link_04(self): ) original = default.Source(target=initial_target) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( default.Source.select(target=False).limit(1) ) original.target = changed_target_0 - self.client.save(original) - self.client.sync(mirror_1) + await self._save(original) + await self._sync(mirror_1) self.assertFalse(hasattr(mirror_1, "target")) # Sync alongside another object with the prop set - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( default.Source.select(target=True).limit(1) ) original.target = changed_target_1 - self.client.save(original) - self.client.sync(mirror_1, mirror_2) # Error here + await self._save(original) + await self._sync(mirror_1, mirror_2) # Error here self.assertFalse(hasattr(mirror_1, "target")) # Sync alongside another object with the prop changed - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( default.Source.select(targets=True).limit(1) ) mirror_2.target = changed_target_2 - self.client.sync(mirror_1, mirror_2) + await self._sync(mirror_1, mirror_2) self.assertEqual(mirror_1.targets._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.targets._items, []) - def test_model_sync_single_link_05(self): + async def test_model_sync_single_link_05(self): # Updating linkprops without changing the proxy model objects from models.TestModelSyncSingleLink import default target_a = default.Target() - self.client.save(target_a) + await self._save(target_a) initial_target = default.SourceWithManyProps.target.link( target_a, a=1, b=2, c=3, d=4 ) original = default.SourceWithManyProps(target=initial_target) - self.client.save(original) + await self._save(original) self._check_links_equal(original.target, initial_target) @@ -3268,11 +3512,11 @@ def test_model_sync_single_link_05(self): target_a, a=1, b=9, c=None, d=4 ) - self.client.sync(original) + await self._sync(original) self._check_links_equal(original.target, expected_target) -class TestModelSyncMultiLink(tb.ModelTestCase): +class TestModelSyncMultiLink(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -3315,7 +3559,7 @@ def _check_multilinks_equal( for a in actual: self.assertEqual(a.__linkprops__, expected_lprops[a.id]) - def _base_testcase( + async def _base_testcase( self, model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], @@ -3325,7 +3569,7 @@ def _base_testcase( expected_targets = set(expected_targets) original = model_type(targets=initial_targets) - self.client.save(original) + await self._save(original) self._check_multilinks_equal(original.targets, initial_targets) @@ -3333,15 +3577,15 @@ def _base_testcase( change_original(original) # sync some of the objects - self.client.sync(original) + await self._sync(original) # only synced objects with value set get update self._check_multilinks_equal(original.targets, expected_targets) # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) - def _testcase_init( + async def _testcase_init( self, model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], @@ -3353,15 +3597,15 @@ def _testcase_init( with_targets = model_type(targets=initial_targets) without_targets = model_type() - self.client.sync(with_targets, without_targets) + await self._sync(with_targets, without_targets) self._check_multilinks_equal(with_targets.targets, expected_targets) self._check_multilinks_equal(without_targets.targets, []) # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) - def test_model_sync_multi_link_01(self): + async def test_model_sync_multi_link_01(self): # Insert new object with multi link from models.TestModelSyncMultiLink import default @@ -3369,15 +3613,17 @@ def test_model_sync_multi_link_01(self): target_a = default.Target() target_b = default.Target() target_c = default.Target() - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) # No linkprops - self._testcase_init(default.Source, []) - self._testcase_init(default.Source, [target_a, target_b, target_c]) + await self._testcase_init(default.Source, []) + await self._testcase_init( + default.Source, [target_a, target_b, target_c] + ) # With linkprops - self._testcase_init(default.SourceWithProp, []) - self._testcase_init( + await self._testcase_init(default.SourceWithProp, []) + await self._testcase_init( default.SourceWithProp, [target_a, target_b, target_c], [ @@ -3386,7 +3632,7 @@ def test_model_sync_multi_link_01(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_init( + await self._testcase_init( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3394,7 +3640,7 @@ def test_model_sync_multi_link_01(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_init( + await self._testcase_init( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -3404,17 +3650,17 @@ def test_model_sync_multi_link_01(self): ) @tb.xfail # multilink linkprops not refetched - def test_model_sync_multi_link_01a(self): + async def test_model_sync_multi_link_01a(self): # With linkprop with default from models.TestModelSyncMultiLink import default target_a = default.Target() target_b = default.Target() target_c = default.Target() - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) - self._testcase_init(default.SourceWithPropWithDefault, []) - self._testcase_init( + await self._testcase_init(default.SourceWithPropWithDefault, []) + await self._testcase_init( default.SourceWithPropWithDefault, [target_a, target_b, target_c], [ @@ -3429,7 +3675,7 @@ def test_model_sync_multi_link_01a(self): ), ], ) - self._testcase_init( + await self._testcase_init( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link(target_a), @@ -3448,7 +3694,7 @@ def test_model_sync_multi_link_01a(self): ), ], ) - self._testcase_init( + await self._testcase_init( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -3473,7 +3719,7 @@ def test_model_sync_multi_link_01a(self): ), ], ) - self._testcase_init( + await self._testcase_init( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -3487,7 +3733,7 @@ def test_model_sync_multi_link_01a(self): ), ], ) - self._testcase_init( + await self._testcase_init( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link(target_a), @@ -3519,7 +3765,7 @@ def change(original: GelModel): return change - def _testcase_assign( + async def _testcase_assign( self, model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], @@ -3529,14 +3775,14 @@ def _testcase_assign( if expected_targets is None: expected_targets = changed_targets - self._base_testcase( + await self._base_testcase( model_type, initial_targets, self._get_assign_targets_func(changed_targets), expected_targets, ) - def test_model_sync_multi_link_02(self): + async def test_model_sync_multi_link_02(self): # Updating existing objects with multi link # Set links to new value @@ -3546,52 +3792,52 @@ def test_model_sync_multi_link_02(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) # No linkprops - self._testcase_assign(default.Source, [], []) - self._testcase_assign( + await self._testcase_assign(default.Source, [], []) + await self._testcase_assign( default.Source, [], [target_a, target_b, target_c], ) - self._testcase_assign( + await self._testcase_assign( default.Source, [target_a, target_b, target_c], [], ) - self._testcase_assign( + await self._testcase_assign( default.Source, [target_a, target_b, target_c], [target_a, target_b, target_c], ) - self._testcase_assign( + await self._testcase_assign( default.Source, [target_a, target_b], [target_c, target_d], ) - self._testcase_assign( + await self._testcase_assign( default.Source, [target_a, target_b], [target_a, target_b, target_c, target_d], ) - self._testcase_assign( + await self._testcase_assign( default.Source, [target_a, target_b, target_c, target_d], [target_a, target_b], ) - self._testcase_assign( + await self._testcase_assign( default.Source, [target_a, target_b, target_c], [target_c, target_d], ) # With linkprops - self._testcase_assign(default.SourceWithProp, [], []) - self._testcase_assign( + await self._testcase_assign(default.SourceWithProp, [], []) + await self._testcase_assign( default.SourceWithProp, [], [target_a, target_b, target_c], @@ -3601,7 +3847,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [], [ @@ -3610,7 +3856,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [], [ @@ -3620,7 +3866,7 @@ def test_model_sync_multi_link_02(self): ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3629,7 +3875,7 @@ def test_model_sync_multi_link_02(self): ], [], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3643,7 +3889,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3656,7 +3902,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3670,7 +3916,7 @@ def test_model_sync_multi_link_02(self): ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -3679,7 +3925,7 @@ def test_model_sync_multi_link_02(self): ], [], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -3692,7 +3938,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_c), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -3705,7 +3951,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_c, lprop=3), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -3719,7 +3965,7 @@ def test_model_sync_multi_link_02(self): ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3731,7 +3977,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3742,7 +3988,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3755,7 +4001,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3768,7 +4014,7 @@ def test_model_sync_multi_link_02(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_assign( + await self._testcase_assign( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3782,7 +4028,7 @@ def test_model_sync_multi_link_02(self): ) @tb.xfail # multilink linkprops not refetched - def test_model_sync_multi_link_02b(self): + async def test_model_sync_multi_link_02b(self): # With linkprop with default from models.TestModelSyncMultiLink import default @@ -3791,7 +4037,7 @@ def test_model_sync_multi_link_02b(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) initials: list[list[typing.Any]] = [ [], @@ -3939,14 +4185,14 @@ def test_model_sync_multi_link_02b(self): if len(change) > 1: expected_targets = change[1] - self._testcase_assign( + await self._testcase_assign( default.SourceWithPropWithDefault, initial_targets, changed_targets, expected_targets, ) - def test_model_sync_multi_link_03(self): + async def test_model_sync_multi_link_03(self): # Updating existing objects with multi props # LinkSet clear @@ -3956,11 +4202,11 @@ def change(original: GelModel): return change - def _testcase_clear( + async def _testcase_clear( model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, _get_clear_targets_func(), @@ -3972,18 +4218,18 @@ def _testcase_clear( target_a = default.Target() target_b = default.Target() target_c = default.Target() - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) # No linkprops - _testcase_clear(default.Source, []) - _testcase_clear( + await _testcase_clear(default.Source, []) + await _testcase_clear( default.Source, [target_a, target_b, target_c], ) # With linkprops - _testcase_clear(default.SourceWithProp, []) - _testcase_clear( + await _testcase_clear(default.SourceWithProp, []) + await _testcase_clear( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -3991,7 +4237,7 @@ def _testcase_clear( default.SourceWithProp.targets.link(target_c), ], ) - _testcase_clear( + await _testcase_clear( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4001,8 +4247,8 @@ def _testcase_clear( ) # With linkprop with default - _testcase_clear(default.SourceWithPropWithDefault, []) - _testcase_clear( + await _testcase_clear(default.SourceWithPropWithDefault, []) + await _testcase_clear( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4016,7 +4262,7 @@ def _testcase_clear( ), ], ) - _testcase_clear( + await _testcase_clear( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4040,21 +4286,21 @@ def change(original: GelModel): return change - def _testcase_update( + async def _testcase_update( self, model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], update_targets: typing.Collection[typing.Any], expected_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, self._get_update_targets_func(update_targets), expected_targets, ) - def test_model_sync_multi_link_04(self): + async def test_model_sync_multi_link_04(self): # Updating existing objects with multi props # LinkSet update @@ -4064,50 +4310,50 @@ def test_model_sync_multi_link_04(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) # No linkprops - self._testcase_update(default.Source, [], [], []) - self._testcase_update( + await self._testcase_update(default.Source, [], [], []) + await self._testcase_update( default.Source, [], [target_a, target_b, target_c], [target_a, target_b, target_c], ) - self._testcase_update( + await self._testcase_update( default.Source, [target_a, target_b, target_c], [], [target_a, target_b, target_c], ) - self._testcase_update( + await self._testcase_update( default.Source, [target_a, target_b, target_c], [target_a, target_b, target_c], [target_a, target_b, target_c], ) - self._testcase_update( + await self._testcase_update( default.Source, [target_a, target_b], [target_c, target_d], [target_a, target_b, target_c, target_d], ) - self._testcase_update( + await self._testcase_update( default.Source, [target_a, target_b], [target_a, target_b, target_c, target_d], [target_a, target_b, target_c, target_d], ) - self._testcase_update( + await self._testcase_update( default.Source, [target_a, target_b, target_c, target_d], [target_a, target_b], [target_a, target_b, target_c, target_d], ) - self._testcase_update( + await self._testcase_update( default.Source, [target_a, target_b, target_c], [target_c, target_d], @@ -4115,8 +4361,8 @@ def test_model_sync_multi_link_04(self): ) # With linkprops - self._testcase_update(default.SourceWithProp, [], [], []) - self._testcase_update( + await self._testcase_update(default.SourceWithProp, [], [], []) + await self._testcase_update( default.SourceWithProp, [], [target_a, target_b], @@ -4125,7 +4371,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [], [ @@ -4137,7 +4383,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [], [ @@ -4150,7 +4396,7 @@ def test_model_sync_multi_link_04(self): ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4162,7 +4408,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4174,7 +4420,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4189,7 +4435,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4206,7 +4452,7 @@ def test_model_sync_multi_link_04(self): ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4218,7 +4464,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4233,7 +4479,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4248,7 +4494,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4264,7 +4510,7 @@ def test_model_sync_multi_link_04(self): ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4278,7 +4524,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4295,7 +4541,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4314,7 +4560,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4333,7 +4579,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4352,7 +4598,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4371,7 +4617,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -4390,7 +4636,7 @@ def test_model_sync_multi_link_04(self): default.SourceWithProp.targets.link(target_d, lprop=6), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -4411,7 +4657,7 @@ def test_model_sync_multi_link_04(self): ) @tb.xfail # multilink linkprops not refetched - def test_model_sync_multi_link_04c(self): + async def test_model_sync_multi_link_04c(self): # With linkprop with default from models.TestModelSyncMultiLink import default @@ -4419,10 +4665,12 @@ def test_model_sync_multi_link_04c(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) - self._testcase_update(default.SourceWithPropWithDefault, [], [], []) - self._testcase_update( + await self._testcase_update( + default.SourceWithPropWithDefault, [], [], [] + ) + await self._testcase_update( default.SourceWithPropWithDefault, [], [target_a, target_b, target_c], @@ -4438,7 +4686,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [], [ @@ -4458,7 +4706,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [], [ @@ -4484,7 +4732,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [], [ @@ -4510,7 +4758,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [], [ @@ -4535,7 +4783,7 @@ def test_model_sync_multi_link_04c(self): ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4561,7 +4809,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4591,7 +4839,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4627,7 +4875,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4663,7 +4911,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4698,7 +4946,7 @@ def test_model_sync_multi_link_04c(self): ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4724,7 +4972,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4754,7 +5002,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4790,7 +5038,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4826,7 +5074,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4860,7 +5108,7 @@ def test_model_sync_multi_link_04c(self): ), ], ) - self._testcase_update( + await self._testcase_update( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -4906,21 +5154,21 @@ def change(original: GelModel): return change - def _testcase_add( + async def _testcase_add( self, model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], add_target: typing.Any, expected_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, self._get_add_targets_func(add_target), expected_targets, ) - def test_model_sync_multi_link_05(self): + async def test_model_sync_multi_link_05(self): # Updating existing objects with multi props # LinkSet add @@ -4930,22 +5178,22 @@ def test_model_sync_multi_link_05(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) # No linkprops - self._testcase_add( + await self._testcase_add( default.Source, [], target_a, [target_a], ) - self._testcase_add( + await self._testcase_add( default.Source, [target_a], target_a, [target_a], ) - self._testcase_add( + await self._testcase_add( default.Source, [target_a, target_b, target_c], target_d, @@ -4953,64 +5201,64 @@ def test_model_sync_multi_link_05(self): ) # With linkprops - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [], target_a, [default.SourceWithProp.targets.link(target_a)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [], default.SourceWithProp.targets.link(target_a), [default.SourceWithProp.targets.link(target_a)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [], default.SourceWithProp.targets.link(target_a, lprop=1), [default.SourceWithProp.targets.link(target_a, lprop=1)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], target_a, [default.SourceWithProp.targets.link(target_a)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], default.SourceWithProp.targets.link(target_a), [default.SourceWithProp.targets.link(target_a)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], default.SourceWithProp.targets.link(target_a, lprop=1), [default.SourceWithProp.targets.link(target_a, lprop=1)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a), [default.SourceWithProp.targets.link(target_a)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a, lprop=1), [default.SourceWithProp.targets.link(target_a, lprop=1)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a, lprop=2), [default.SourceWithProp.targets.link(target_a, lprop=2)], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5025,7 +5273,7 @@ def test_model_sync_multi_link_05(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5040,7 +5288,7 @@ def test_model_sync_multi_link_05(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5057,7 +5305,7 @@ def test_model_sync_multi_link_05(self): ) @tb.xfail # multilink linkprops not refetched - def test_model_sync_multi_link_05b(self): + async def test_model_sync_multi_link_05b(self): # With linkprop with default from models.TestModelSyncMultiLink import default @@ -5065,9 +5313,9 @@ def test_model_sync_multi_link_05b(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [], target_a, @@ -5077,7 +5325,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [], default.SourceWithPropWithDefault.targets.link(target_a), @@ -5087,7 +5335,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [], default.SourceWithPropWithDefault.targets.link( @@ -5099,7 +5347,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [], default.SourceWithPropWithDefault.targets.link(target_a, lprop=1), @@ -5109,7 +5357,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5123,7 +5371,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5137,7 +5385,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5153,7 +5401,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5167,7 +5415,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5181,7 +5429,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5195,7 +5443,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5211,7 +5459,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5225,7 +5473,7 @@ def test_model_sync_multi_link_05b(self): ) ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5254,7 +5502,7 @@ def test_model_sync_multi_link_05b(self): ), ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5285,7 +5533,7 @@ def test_model_sync_multi_link_05b(self): ), ], ) - self._testcase_add( + await self._testcase_add( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5315,7 +5563,7 @@ def test_model_sync_multi_link_05b(self): ], ) - def test_model_sync_multi_link_06(self): + async def test_model_sync_multi_link_06(self): # Updating existing objects with multi props # LinkSet discard @@ -5327,13 +5575,13 @@ def change(original: GelModel): return change - def _testcase_discard( + async def _testcase_discard( model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], discard_target: typing.Any, expected_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, _get_discard_targets_func(discard_target), @@ -5346,16 +5594,16 @@ def _testcase_discard( target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) # No linkprops - _testcase_discard( + await _testcase_discard( default.Source, [target_a], target_a, [], ) - _testcase_discard( + await _testcase_discard( default.Source, [target_a, target_b, target_c], target_c, @@ -5363,45 +5611,45 @@ def _testcase_discard( ) # With linkprops - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], target_a, [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], default.SourceWithProp.targets.link(target_a), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], default.SourceWithProp.targets.link(target_a, lprop=1), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a, lprop=1), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a, lprop=2), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5414,7 +5662,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5427,7 +5675,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5440,7 +5688,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5453,7 +5701,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5466,7 +5714,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5481,7 +5729,7 @@ def _testcase_discard( ) # With linkprop with default - _testcase_discard( + await _testcase_discard( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5491,7 +5739,7 @@ def _testcase_discard( target_a, [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5501,7 +5749,7 @@ def _testcase_discard( default.SourceWithPropWithDefault.targets.link(target_a), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5513,7 +5761,7 @@ def _testcase_discard( ), [], ) - _testcase_discard( + await _testcase_discard( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5525,13 +5773,13 @@ def _testcase_discard( ) # Discarding non-member items does nothing - _testcase_discard( + await _testcase_discard( default.Source, [target_a, target_b, target_c], target_d, [target_a, target_b, target_c], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5545,7 +5793,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_c), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5559,7 +5807,7 @@ def _testcase_discard( default.SourceWithProp.targets.link(target_c), ], ) - _testcase_discard( + await _testcase_discard( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5574,7 +5822,7 @@ def _testcase_discard( ], ) - def test_model_sync_multi_link_07(self): + async def test_model_sync_multi_link_07(self): # Updating existing objects with multi props # LinkSet remove @@ -5586,13 +5834,13 @@ def change(original: GelModel): return change - def _testcase_remove( + async def _testcase_remove( model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], remove_target: typing.Any, expected_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, _get_remove_targets_func(remove_target), @@ -5604,16 +5852,16 @@ def _testcase_remove( target_a = default.Target() target_b = default.Target() target_c = default.Target() - self.client.save(target_a, target_b, target_c) + await self._save(target_a, target_b, target_c) # No linkprops - _testcase_remove( + await _testcase_remove( default.Source, [target_a], target_a, [], ) - _testcase_remove( + await _testcase_remove( default.Source, [target_a, target_b, target_c], target_c, @@ -5621,45 +5869,45 @@ def _testcase_remove( ) # With linkprops - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], target_a, [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], default.SourceWithProp.targets.link(target_a), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], default.SourceWithProp.targets.link(target_a, lprop=1), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a, lprop=1), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], default.SourceWithProp.targets.link(target_a, lprop=2), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5672,7 +5920,7 @@ def _testcase_remove( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5685,7 +5933,7 @@ def _testcase_remove( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5698,7 +5946,7 @@ def _testcase_remove( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5711,7 +5959,7 @@ def _testcase_remove( default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5724,7 +5972,7 @@ def _testcase_remove( default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - _testcase_remove( + await _testcase_remove( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5739,7 +5987,7 @@ def _testcase_remove( ) # With linkprop with default - _testcase_remove( + await _testcase_remove( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5749,7 +5997,7 @@ def _testcase_remove( target_a, [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5759,7 +6007,7 @@ def _testcase_remove( default.SourceWithPropWithDefault.targets.link(target_a), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5771,7 +6019,7 @@ def _testcase_remove( ), [], ) - _testcase_remove( + await _testcase_remove( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -5791,21 +6039,21 @@ def change(original: GelModel): return change - def _testcase_op_iadd( + async def _testcase_op_iadd( self, model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], op_iadd_targets: typing.Collection[typing.Any], expected_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, self._get_op_iadd_targets_func(op_iadd_targets), expected_targets, ) - def test_model_sync_multi_link_08(self): + async def test_model_sync_multi_link_08(self): # Updating existing objects with multi props # LinkSet operator iadd @@ -5815,50 +6063,50 @@ def test_model_sync_multi_link_08(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) # No linkprops - self._testcase_op_iadd(default.Source, [], [], []) - self._testcase_op_iadd( + await self._testcase_op_iadd(default.Source, [], [], []) + await self._testcase_op_iadd( default.Source, [], [target_a, target_b, target_c], [target_a, target_b, target_c], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.Source, [target_a, target_b, target_c], [], [target_a, target_b, target_c], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.Source, [target_a, target_b, target_c], [target_a, target_b, target_c], [target_a, target_b, target_c], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.Source, [target_a, target_b], [target_c, target_d], [target_a, target_b, target_c, target_d], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.Source, [target_a, target_b], [target_a, target_b, target_c, target_d], [target_a, target_b, target_c, target_d], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.Source, [target_a, target_b, target_c, target_d], [target_a, target_b], [target_a, target_b, target_c, target_d], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.Source, [target_a, target_b, target_c], [target_c, target_d], @@ -5866,8 +6114,8 @@ def test_model_sync_multi_link_08(self): ) # With linkprops - self._testcase_op_iadd(default.SourceWithProp, [], [], []) - self._testcase_op_iadd( + await self._testcase_op_iadd(default.SourceWithProp, [], [], []) + await self._testcase_op_iadd( default.SourceWithProp, [], [target_a, target_b], @@ -5876,7 +6124,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [], [ @@ -5888,7 +6136,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [], [ @@ -5901,7 +6149,7 @@ def test_model_sync_multi_link_08(self): ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5913,7 +6161,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5925,7 +6173,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5940,7 +6188,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -5957,7 +6205,7 @@ def test_model_sync_multi_link_08(self): ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5969,7 +6217,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5984,7 +6232,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -5999,7 +6247,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -6015,7 +6263,7 @@ def test_model_sync_multi_link_08(self): ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -6029,7 +6277,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -6046,7 +6294,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -6065,7 +6313,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -6084,7 +6332,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -6103,7 +6351,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -6122,7 +6370,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a), @@ -6141,7 +6389,7 @@ def test_model_sync_multi_link_08(self): default.SourceWithProp.targets.link(target_d, lprop=6), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithProp, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -6162,7 +6410,7 @@ def test_model_sync_multi_link_08(self): ) @tb.xfail # multilink linkprops not refetched - def test_model_sync_multi_link_08c(self): + async def test_model_sync_multi_link_08c(self): # With linkprop with default from models.TestModelSyncMultiLink import default @@ -6171,10 +6419,12 @@ def test_model_sync_multi_link_08c(self): target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) - self._testcase_op_iadd(default.SourceWithPropWithDefault, [], [], []) - self._testcase_op_iadd( + await self._testcase_op_iadd( + default.SourceWithPropWithDefault, [], [], [] + ) + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [], [target_a, target_b, target_c], @@ -6190,7 +6440,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [], [ @@ -6210,7 +6460,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [], [ @@ -6236,7 +6486,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [], [ @@ -6262,7 +6512,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [], [ @@ -6287,7 +6537,7 @@ def test_model_sync_multi_link_08c(self): ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6313,7 +6563,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6343,7 +6593,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6379,7 +6629,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6415,7 +6665,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6450,7 +6700,7 @@ def test_model_sync_multi_link_08c(self): ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6476,7 +6726,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6506,7 +6756,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6542,7 +6792,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6578,7 +6828,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6612,7 +6862,7 @@ def test_model_sync_multi_link_08c(self): ), ], ) - self._testcase_op_iadd( + await self._testcase_op_iadd( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6649,7 +6899,7 @@ def test_model_sync_multi_link_08c(self): ], ) - def test_model_sync_multi_link_09(self): + async def test_model_sync_multi_link_09(self): # Updating existing objects with multi props # LinkSet operator isub @@ -6661,13 +6911,13 @@ def change(original: GelModel): return change - def _testcase_op_isub( + async def _testcase_op_isub( model_type: typing.Type[GelModel], initial_targets: typing.Collection[typing.Any], op_isub_targets: typing.Collection[typing.Any], expected_targets: typing.Collection[typing.Any], ) -> None: - self._base_testcase( + await self._base_testcase( model_type, initial_targets, _get_op_isub_targets_func(op_isub_targets), @@ -6680,37 +6930,37 @@ def _testcase_op_isub( target_b = default.Target() target_c = default.Target() target_d = default.Target() - self.client.save(target_a, target_b, target_c, target_d) + await self._save(target_a, target_b, target_c, target_d) # No linkprops - _testcase_op_isub(default.Source, [], [], []) - _testcase_op_isub( + await _testcase_op_isub(default.Source, [], [], []) + await _testcase_op_isub( default.Source, [], [target_a], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [target_a], [], [target_a], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [target_a], [target_a], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [target_a], [target_b], [target_a], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [target_a, target_b, target_c], [target_c, target_d], @@ -6718,95 +6968,95 @@ def _testcase_op_isub( ) # With linkprops - _testcase_op_isub(default.SourceWithProp, [], [], []) - _testcase_op_isub( + await _testcase_op_isub(default.SourceWithProp, [], [], []) + await _testcase_op_isub( default.SourceWithProp, [], [target_a], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [], [default.SourceWithProp.targets.link(target_a)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [], [default.SourceWithProp.targets.link(target_a, lprop=1)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], [], [default.SourceWithProp.targets.link(target_a)], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], [target_a], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], [default.SourceWithProp.targets.link(target_a)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], [default.SourceWithProp.targets.link(target_a, lprop=1)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], [target_b], [default.SourceWithProp.targets.link(target_a)], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a)], [default.SourceWithProp.targets.link(target_b)], [default.SourceWithProp.targets.link(target_a)], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], [], [default.SourceWithProp.targets.link(target_a, lprop=1)], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], [default.SourceWithProp.targets.link(target_a)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], [default.SourceWithProp.targets.link(target_a, lprop=1)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], [default.SourceWithProp.targets.link(target_a, lprop=2)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithProp, [default.SourceWithProp.targets.link(target_a, lprop=1)], [default.SourceWithProp.targets.link(target_b)], [default.SourceWithProp.targets.link(target_a, lprop=1)], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [ default.SourceWithProp.targets.link(target_a), @@ -6819,7 +7069,7 @@ def _testcase_op_isub( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [ default.SourceWithProp.targets.link(target_a), @@ -6835,7 +7085,7 @@ def _testcase_op_isub( default.SourceWithProp.targets.link(target_b), ], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [ default.SourceWithProp.targets.link(target_a), @@ -6852,7 +7102,7 @@ def _testcase_op_isub( ], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -6868,7 +7118,7 @@ def _testcase_op_isub( default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -6884,7 +7134,7 @@ def _testcase_op_isub( default.SourceWithProp.targets.link(target_b, lprop=2), ], ) - _testcase_op_isub( + await _testcase_op_isub( default.Source, [ default.SourceWithProp.targets.link(target_a, lprop=1), @@ -6902,20 +7152,20 @@ def _testcase_op_isub( ) # With linkprop with default - _testcase_op_isub(default.SourceWithPropWithDefault, [], [], []) - _testcase_op_isub( + await _testcase_op_isub(default.SourceWithPropWithDefault, [], [], []) + await _testcase_op_isub( default.SourceWithPropWithDefault, [], [target_a], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [], [default.SourceWithPropWithDefault.targets.link(target_a)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [], [ @@ -6925,7 +7175,7 @@ def _testcase_op_isub( ], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [], [ @@ -6936,7 +7186,7 @@ def _testcase_op_isub( [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6950,7 +7200,7 @@ def _testcase_op_isub( ) ], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6960,7 +7210,7 @@ def _testcase_op_isub( [target_a], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6970,7 +7220,7 @@ def _testcase_op_isub( [default.SourceWithPropWithDefault.targets.link(target_a)], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6984,7 +7234,7 @@ def _testcase_op_isub( ], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -6998,7 +7248,7 @@ def _testcase_op_isub( ], [], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -7012,7 +7262,7 @@ def _testcase_op_isub( ) ], ) - _testcase_op_isub( + await _testcase_op_isub( default.SourceWithPropWithDefault, [ default.SourceWithPropWithDefault.targets.link( @@ -7028,11 +7278,11 @@ def _testcase_op_isub( ) @tb.xfail - def test_model_sync_multi_link_10(self): + async def test_model_sync_multi_link_10(self): # Existing object without link should not have it fetched # No linkprops - def _testcase( + async def _testcase( model_type: typing.Type[GelModel], initial_targets: typing.Any, changed_targets_0: typing.Any, @@ -7040,38 +7290,38 @@ def _testcase( changed_targets_2: typing.Any, ): original = model_type(targets=initial_targets) - self.client.save(original) + await self._save(original) - mirror_1 = self.client.query_required_single( + mirror_1 = await self._query_required_single( model_type.select(targets=False).limit(1) ) original.targets = changed_targets_0 - self.client.save(original) - self.client.sync(mirror_1) + await self._save(original) + await self._sync(mirror_1) self.assertEqual(mirror_1.targets._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.targets._items, []) # Sync alongside another object with the prop set - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(targets=True).limit(1) ) original.targets = changed_targets_1 - self.client.save(original) - self.client.sync(mirror_1, mirror_2) + await self._save(original) + await self._sync(mirror_1, mirror_2) self.assertEqual(mirror_1.targets._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.targets._items, []) # Sync alongside another object with the prop changed - mirror_2 = self.client.query_required_single( + mirror_2 = await self._query_required_single( model_type.select(targets=True).limit(1) ) mirror_2.targets = changed_targets_2 - self.client.sync(mirror_1, mirror_2) + await self._sync(mirror_1, mirror_2) self.assertEqual(mirror_1.targets._mode, _tracked_list.Mode.Write) self.assertEqual(mirror_1.targets._items, []) # Fail # cleanup - self.client.query(model_type.delete()) + await self._query(model_type.delete()) from models.TestModelSyncMultiLink import default @@ -7079,21 +7329,21 @@ def _testcase( changed_target_0 = default.Target() changed_target_1 = default.Target() changed_target_2 = default.Target() - self.client.save( + await self._save( initial_target, changed_target_0, changed_target_1, changed_target_2, ) - _testcase( + await _testcase( default.Source, [initial_target], [changed_target_0], [changed_target_1], [changed_target_2], ) - _testcase( + await _testcase( default.SourceWithProp, [default.SourceWithProp.targets.link(initial_target)], [default.SourceWithProp.targets.link(changed_target_0)], @@ -7101,13 +7351,13 @@ def _testcase( [default.SourceWithProp.targets.link(changed_target_2)], ) - def test_model_sync_multi_link_11(self): + async def test_model_sync_multi_link_11(self): # Updating linkprops without changing the proxy model objects from models.TestModelSyncMultiLink import default target_a = default.Target() - self.client.save(target_a) + await self._save(target_a) initial_targets = [ default.SourceWithManyProps.targets.link( @@ -7116,7 +7366,7 @@ def test_model_sync_multi_link_11(self): ] original = default.SourceWithManyProps(targets=initial_targets) - self.client.save(original) + await self._save(original) self._check_multilinks_equal(original.targets, initial_targets) @@ -7131,11 +7381,11 @@ def test_model_sync_multi_link_11(self): ) ] - self.client.sync(original) + await self._sync(original) self._check_multilinks_equal(original.targets, expected_targets) -class TestModelSyncRewrite(tb.ModelTestCase): +class TestModelSyncRewrite(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -7165,46 +7415,46 @@ class TestModelSyncRewrite(tb.ModelTestCase): }; """ - def test_model_sync_rewrite_insert_01(self): + async def test_model_sync_rewrite_insert_01(self): # Insert, property with rewrite from models.TestModelSyncRewrite import default - def _testcase( + async def _testcase( insert_n: int | None, insert_val: int | None, expected_val: int | None, ) -> None: original = default.SingleProp(n=insert_n, val=insert_val) - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, expected_val) # cleanup - self.client.query(default.SingleProp.delete()) + await self._query(default.SingleProp.delete()) - _testcase(None, None, None) - _testcase(1, None, 2) - _testcase(1, 0, 2) + await _testcase(None, None, None) + await _testcase(1, None, 2) + await _testcase(1, 0, 2) - def test_model_sync_rewrite_insert_02(self): + async def test_model_sync_rewrite_insert_02(self): # Insert, link with rewrite from models.TestModelSyncRewrite import default - def _testcase( + async def _testcase( insert_n: int | None, insert_target: default.Target | None, expected_val: int | None, ) -> None: original = default.SingleLink(n=insert_n, target=insert_target) - self.client.sync(original) + await self._sync(original) self.assertNotEqual(original.target, insert_target) assert original.target is not None self.assertFalse(hasattr(original.target, 'n')) - rewritten_target = self.client.query_required_single( + rewritten_target = await self._query_required_single( default.Target.select(n=True) .filter(id=original.target.id) .limit(1) @@ -7212,79 +7462,79 @@ def _testcase( self.assertEqual(rewritten_target.n, expected_val) # cleanup - self.client.query(default.SingleLink.delete()) + await self._query(default.SingleLink.delete()) target_zero = default.Target(n=0) - self.client.save(target_zero) + await self._save(target_zero) - _testcase(None, None, None) + await _testcase(None, None, None) # Normally we might expect the rewrite to be 1+1 because this is an # insert. However, sync currently splits adding links to a separate # batch query, making it an update. This is surprising, but everything # about rewrites is surprising. - _testcase(1, None, 3) - _testcase(1, target_zero, 3) + await _testcase(1, None, 3) + await _testcase(1, target_zero, 3) - def test_model_sync_rewrite_update_01(self): + async def test_model_sync_rewrite_update_01(self): # Update, property with rewrite # Only update the rewrite field from models.TestModelSyncRewrite import default - def _testcase( + async def _testcase( insert_n: int | None, update_val: int | None, expected_val: int | None, ) -> None: original = default.SingleProp(n=insert_n) - self.client.sync(original) + await self._sync(original) original.val = update_val original.dummy = 1 # Change some other prop in parallel - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, expected_val) # cleanup - self.client.query(default.SingleProp.delete()) + await self._query(default.SingleProp.delete()) - _testcase(None, None, None) - _testcase(None, 1, None) - _testcase(1, None, 3) - _testcase(1, 1, 3) - _testcase(1, 9, 3) + await _testcase(None, None, None) + await _testcase(None, 1, None) + await _testcase(1, None, 3) + await _testcase(1, 1, 3) + await _testcase(1, 9, 3) - def test_model_sync_rewrite_update_02(self): + async def test_model_sync_rewrite_update_02(self): # Update, property with rewrite # Only update other field from models.TestModelSyncRewrite import default - def _testcase( + async def _testcase( insert_n: int | None, update_n: int | None, expected_val: int | None, ) -> None: original = default.SingleProp(n=insert_n) - self.client.sync(original) + await self._sync(original) original.n = update_n original.dummy = 1 # Change some other prop in parallel - self.client.sync(original) + await self._sync(original) self.assertEqual(original.val, expected_val) # cleanup - self.client.query(default.SingleProp.delete()) + await self._query(default.SingleProp.delete()) - _testcase(None, None, None) - _testcase(None, 1, 3) - _testcase(1, None, None) - _testcase(1, 1, 3) - _testcase(1, 9, 11) + await _testcase(None, None, None) + await _testcase(None, 1, 3) + await _testcase(1, None, None) + await _testcase(1, 1, 3) + await _testcase(1, 9, 11) - def test_model_sync_rewrite_update_03(self): + async def test_model_sync_rewrite_update_03(self): # Update, link with rewrite # Only update the rewrite field @@ -7293,28 +7543,28 @@ def test_model_sync_rewrite_update_03(self): # Initialize all links to not None, because sync currently breaks # otherwise. target_zero = default.Target(n=0) - self.client.save(target_zero) + await self._save(target_zero) - def _testcase( + async def _testcase( insert_n: int | None, update_target: default.Target | None, expected_val: int | None, ) -> None: original = default.SingleLink(n=insert_n, target=target_zero) - self.client.sync(original) + await self._sync(original) insert_target = original.target original.target = update_target original.dummy = 1 # Change some other prop in parallel - self.client.sync(original) + await self._sync(original) self.assertNotEqual(original.target, insert_target) self.assertNotEqual(original.target, update_target) assert original.target is not None self.assertFalse(hasattr(original.target, 'n')) - rewritten_target = self.client.query_required_single( + rewritten_target = await self._query_required_single( default.Target.select(n=True) .filter(id=original.target.id) .limit(1) @@ -7322,15 +7572,15 @@ def _testcase( self.assertEqual(rewritten_target.n, expected_val) # cleanup - self.client.query(default.SingleLink.delete()) + await self._query(default.SingleLink.delete()) target_one = default.Target(n=1) - self.client.save(target_one) + await self._save(target_one) - _testcase(1, None, 3) - _testcase(1, target_one, 3) + await _testcase(1, None, 3) + await _testcase(1, target_one, 3) - def test_model_sync_rewrite_update_04(self): + async def test_model_sync_rewrite_update_04(self): # Update, link with rewrite # Only update other field @@ -7339,27 +7589,27 @@ def test_model_sync_rewrite_update_04(self): # Initialize all links to not None, because sync currently breaks # otherwise. target_zero = default.Target(n=0) - self.client.save(target_zero) + await self._save(target_zero) - def _testcase( + async def _testcase( insert_n: int | None, update_n: int | None, expected_val: int | None, ) -> None: original = default.SingleLink(n=insert_n, target=target_zero) - self.client.sync(original) + await self._sync(original) insert_target = original.target original.n = update_n original.dummy = 1 # Change some other prop in parallel - self.client.sync(original) + await self._sync(original) self.assertNotEqual(original.target, insert_target) assert original.target is not None self.assertFalse(hasattr(original.target, 'n')) - rewritten_target = self.client.query_required_single( + rewritten_target = await self._query_required_single( default.Target.select(n=True) .filter(id=original.target.id) .limit(1) @@ -7367,15 +7617,15 @@ def _testcase( self.assertEqual(rewritten_target.n, expected_val) # cleanup - self.client.query(default.SingleLink.delete()) + await self._query(default.SingleLink.delete()) - _testcase(None, None, None) - _testcase(1, None, None) - _testcase(1, 1, 3) - _testcase(1, 9, 11) + await _testcase(None, None, None) + await _testcase(1, None, None) + await _testcase(1, 1, 3) + await _testcase(1, 9, 11) -class TestModelSyncTrigger(tb.ModelTestCase): +class TestModelSyncTrigger(TestBlockingModelSyncBase): ISOLATED_TEST_BRANCHES = True SCHEMA = """ @@ -7443,78 +7693,78 @@ class TestModelSyncTrigger(tb.ModelTestCase): }; """ - def test_model_sync_trigger_insert_01(self): + async def test_model_sync_trigger_insert_01(self): # Insert trigger, basic from models.TestModelSyncTrigger import default test_obj = default.TestInsert(val=0) trigger_a = default.TriggerInsert(n=1) - self.client.sync(test_obj, trigger_a) + await self._sync(test_obj, trigger_a) self.assertEqual(test_obj.val, 1) trigger_b = default.TriggerInsert(n=2) - self.client.sync(test_obj, trigger_b) + await self._sync(test_obj, trigger_b) self.assertEqual(test_obj.val, 3) trigger_c = default.TriggerInsert(n=3) - self.client.sync(test_obj, trigger_c) + await self._sync(test_obj, trigger_c) self.assertEqual(test_obj.val, 6) - def test_model_sync_trigger_insert_02(self): + async def test_model_sync_trigger_insert_02(self): # Insert trigger, computed modified by trigger from models.TestModelSyncTrigger import default test_obj = default.TestInsert(val=0) trigger = default.TriggerInsertComputed(n=1) - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) self.assertEqual(trigger.test_vals, (1,)) - def test_model_sync_trigger_insert_03(self): + async def test_model_sync_trigger_insert_03(self): # Insert trigger # Link will cause test objs to be batched before trigger objs from models.TestModelSyncTrigger import default test_obj = default.TestInsert(val=0) trigger_a = default.TriggerInsertWithLink(n=1, test=test_obj) - self.client.sync(test_obj, trigger_a) + await self._sync(test_obj, trigger_a) self.assertEqual(test_obj.val, 1) trigger_b = default.TriggerInsertWithLink(n=2, test=test_obj) - self.client.sync(test_obj, trigger_b) + await self._sync(test_obj, trigger_b) self.assertEqual(test_obj.val, 3) trigger_c = default.TriggerInsertWithLink(n=3, test=test_obj) - self.client.sync(test_obj, trigger_c) + await self._sync(test_obj, trigger_c) self.assertEqual(test_obj.val, 6) - def test_model_sync_trigger_update_01(self): + async def test_model_sync_trigger_update_01(self): from models.TestModelSyncTrigger import default test_obj = default.TestUpdate(val=0) trigger = default.TriggerUpdate(n=0) - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) trigger.n = 1 - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) self.assertEqual(test_obj.val, 1) trigger.n = 2 - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) self.assertEqual(test_obj.val, 3) trigger.n = 3 - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) self.assertEqual(test_obj.val, 6) - def test_model_sync_trigger_update_02(self): + async def test_model_sync_trigger_update_02(self): # Update trigger, computed modified by trigger from models.TestModelSyncTrigger import default test_obj = default.TestUpdate(val=0) trigger = default.TriggerUpdateComputed(n=0) - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) trigger.n = 1 - self.client.sync(test_obj, trigger) + await self._sync(test_obj, trigger) self.assertEqual(trigger.test_vals, (1,))