class SQLAComponentTestCase(TestCase): test_models = { 'db1': create_models1(), 'db2': create_models2(), } @skipIf(mysql_skip, 'MySQLdb not installed') def test_mysql(self): self._db_test(cfg.MYSQL_URL) @skipIf(pg_skip, 'Psycopg2 not instaled') def test_postgress(self): self._db_test(cfg.POSTGRESS_URL) def _db_test(self, db_url): app = MagicMock() del app.db app.cfg.DATABASES = { 'db1': db_url, 'db2': db_url, } def get_models(db_id): self.assertIn(db_id, app.cfg.DATABASES) return self.test_models[db_id] Component = component(get_models=get_models) db = Component.create(app) self.assertEqual(db.models, self.test_models) engine1 = db.engines['db1'] engine2 = db.engines['db2'] self.assertEqual(db.binds[self.test_models['db1'].test_table1], engine1) self.assertEqual(db.binds[self.test_models['db2'].test_table2], engine2) test_table1 = self.test_models['db1'].test_table1 session = db() db.reset_all() Test = db.models['db1'].Test test = Test(id=5, title='test_title') session.add(test) session.commit() test = session.query(Test).filter_by(id=5).one() self.assertEqual(test.id, 5) self.assertEqual(test.title, 'test_title') test.title = 'test_title2' session.commit() cnt = session.query(Test).filter_by(id=5, title='test_title2').count() self.assertEqual(cnt, 1) session.delete(test) session.commit() cnt = session.query(Test).filter_by(id=5, title='test_title2').count() self.assertEqual(cnt, 0) session.close()
async def asetup(self): self.models1 = create_models1() registry = orm.mappers.Registry(create_metadata([self.models1])) self.LocalMapperClass.create(registry, db_id='db1') self.RemoteMapperClass.create(registry, db_id='db1') local_mapper = registry['db1']['Local'] remote_mapper = registry['db1']['Remote'] registry.create_schema() state1 = DbState() state1['local'] = TableState(local_mapper.table) state1['remote'] = TableState(remote_mapper.table) state1['m2m'] = TableState( local_mapper.relations['m2m'].table, primary_keys=['local_id', 'remote_id'], ) state1['m2m_ordered'] = TableState( local_mapper.relations['m2m_ordered'].table, primary_keys=['local_id', 'remote_id'], ) state1['remote'].append({'id': 1, 'title': 'title1'}) state1['remote'].append({'id': 2, 'title': 'title2'}) state1['remote'].append({'id': 3, 'title': 'title3'}) state2 = state1.copy() state2['local'].append({'id': 1, 'title': 'title1'}) state2['m2m'].append({'local_id': 1, 'remote_id': 1}) state2['m2m'].append({'local_id': 1, 'remote_id': 2}) state2['m2m'].append({'local_id': 1, 'remote_id': 3}) state2['m2m_ordered'].append({'local_id': 1, 'remote_id': 1, 'order': 2}) state2['m2m_ordered'].append({'local_id': 1, 'remote_id': 2, 'order': 1}) state2['m2m_ordered'].append({'local_id': 1, 'remote_id': 3, 'order': 3}) app = MagicMock() del app.db app.cfg.DATABASES = { 'db1': DB_URL, } Component = component(mappers=registry) db = await Component.create(app) async with await db() as session: conn1 = await session.get_connection(db.engines['db1']) await self.models1.reset(conn1) return { 'db': db, 'local_mapper': local_mapper, 'remote_mapper': remote_mapper, 'state1': state1, 'state2': state2, }
class SQLAComponentTestCase(TestCase): test_models = { 'db1': create_models1(), 'db2': create_models2(), } @skipIf(mysql_skip, 'Aiomysql not installed') @asynctest async def test_mysql(self): await self._db_test(cfg.MYSQL_URL) @skipIf(pg_skip, 'Aiopg not instaled') @asynctest async def test_postgress(self): await self._db_test(cfg.POSTGRESS_URL) async def _db_test(self, db_url): app = MagicMock() del app.db app.cfg.DATABASES = { 'db1': db_url, 'db2': db_url, } session_cls_mock = MagicMock() Component = component( mappers=mappers.Registry(create_metadata( self.test_models.values())), session_cls=session_cls_mock, ) db = await Component.create(app) self.assertEqual(set(db.engines.keys()), set(app.cfg.DATABASES.keys())) self.assertEqual( db.binds, { self.test_models['db1'].test_table1: db.engines['db1'], self.test_models['db2'].test_table2: db.engines['db2'], }) session = await db() self.assertEqual(session, session_cls_mock(db.engines, db.binds))
class ActionsTestCase(TestCase): item1 = { 'id': 1, 'title': '111t', 'title2': '111t2', 'date': date(2005, 4, 20), } item2 = { 'id': 2, 'title': '222t', 'title2': '222t2', 'date': date(1998, 7, 6), } item3 = { 'id': 3, 'title': '333t', 'title2': '333t2', 'date': date(2016, 12, 12), } item4 = { 'id': 4, 'title': '444t', 'title2': '444t2', 'date': date(2020, 1, 17), } items = [item1, item2, item3, item4] edit_items = _items_from_keys(items, ['id', 'title', 'date']) raw_item1 = { 'id': 1, 'title': '111t', 'title2': '111t2', 'date': '2005-04-20', } raw_item2 = { 'id': 2, 'title': '222t', 'title2': '222t2', 'date': '1998-07-06', } raw_item3 = { 'id': 3, 'title': '333t', 'title2': '333t2', 'date': '2016-12-12', } raw_item4 = { 'id': 4, 'title': '444t', 'title2': '444t2', 'date': '2020-01-17', } raw_items = [raw_item1, raw_item2, raw_item3, raw_item4] raw_edit_items = _items_from_keys(raw_items, ['id', 'title', 'date']) items_table_keys = {'id', 'title', 'title2', 'date'} items_relation_keys = set() items_allowed_keys = items_table_keys.union(items_relation_keys) models1 = create_models1() models2 = create_models2() mapper_cls = orm.mappers.Base async def asetup(self): registry = orm.mappers.Registry( create_metadata([self.models1, self.models2])) self.mapper_cls.from_model(registry, [self.models1.Test]) app = MagicMock() app.cfg.DATABASES = { 'db1': cfg.DB_URL, 'db2': cfg.DB_URL, } del app.db db = await ikcms.ws_components.db.component(mappers=registry ).create(app) async with await db() as session: conn1 = await session.get_connection(db.engines['db1']) await self.models1.reset(conn1) conn2 = await session.get_connection(db.engines['db2']) await self.models2.reset(conn2) class l_id(list_fields.id): widget = MagicMock() class l_title(list_fields.title): widget = MagicMock() class l_date(list_fields.Date): name = 'date' title = 'date' widget = MagicMock() class f_id(filter_fields.id): widget = MagicMock() class f_title(filter_fields.title): widget = MagicMock() class f_date(filter_fields.Date): name = 'date' title = 'date' widget = MagicMock() class f_title2(filter_fields.title): name = 'title2' title = 'title2' widget = MagicMock() class i_id(item_fields.id): widget = MagicMock() def get_initials(_self, **kwargs): return 50000 class i_title(item_fields.title): widget = MagicMock() def get_initials(_self, **kwargs): test_kwarg = kwargs.get('test_kwarg', 'test_default') return '{}-{}-initials'.format(_self.name, test_kwarg) class i_date(item_fields.Date): name = 'date' title = 'date' widget = MagicMock() def get_initials(_self, **kwargs): return date(2005, 5, 5) class TestStream(Stream): max_limit = 50 name = 'test_stream' title = 'test_stream_title' mapper_name = 'Test' db_id = 'db1' permissions = {'test_role': 'rwxcd'} list_fields = [ l_id, l_title, l_date, ] filter_fields = [ f_id, f_title, f_title2, f_date, ] item_fields = [ i_id, i_title, i_date, ] def get_item_form(self, env, item=None, kwargs=None): kwargs = kwargs or {} raise_kwarg = kwargs.get('raise') if raise_kwarg: raise raise_kwarg return super().get_item_form(env, item, kwargs) def check_perms(self, user, perms): pass stream = TestStream(MagicMock(app=app)) env = MagicMock() env.app = app return { 'db': db, 'stream': stream, 'env': env, } async def aclose(self, db, stream, env): await db.close() def _base_assert_list_action_response(self, resp, action, stream): self.assertEqual(resp['stream'], 'test_stream') self.assertEqual(resp['title'], 'test_stream_title') self.assertEqual(resp['action'], action.name) self.assertEqual( resp['list_fields'], [f.widget.to_dict(f) for f in stream.list_fields], ) self.assertEqual( resp['filters_fields'], [f.widget.to_dict(f) for f in stream.filter_fields], ) async def _set_table_state(self, db, table, state): async with await db() as session: query = sql.insert(table).values(state) result = await session.execute(query) async def _assert_table_state(self, db, table, state, keys=None): if keys: columns = [table.c[key] for key in keys] else: columns = table.c async with await db() as session: query = sql.select(columns).order_by(table.c.id) result = await session.execute(query) db_state = [dict(row) for row in result] self.assertEqual(state, db_state) @asynctest async def test_list(self, db, stream, env): action = actions.List(stream) mapper = db.mappers['db1']['Test'] await self._set_table_state(db, self.models1.test_table1, self.items) # test order order_values = [ (None, self.raw_edit_items), ('+id', self.raw_edit_items), ('+title', self.raw_edit_items), ('-title', self.raw_edit_items[::-1]), ] filters_values = [ (None, lambda i: True), ({}, lambda i: True), ] for id in [-5, 0, 1, 3, 10]: def func(x): return lambda i: i['id'] == x filters_values.append(({'id': id}, func(id))) for title in ['1', 't', '2-333t', '24']: def func(x): return lambda i: i['title'].find(x) != -1 filters_values.append(({'title': title}, func(title))) for order, raw_items in order_values: _order = order or '+id' for filters, filter_func in filters_values: _filters = filters or {} _raw_items = [i for i in raw_items if filter_func(i)] for page_size in [None, 1, 3, 4, 50]: _page_size = page_size or 1 for page in [None, 1, 2, 3, 4, 10]: _page = page or 1 kwargs = {} if order is not None: kwargs['order'] = order if filters is not None: kwargs['filters'] = filters if page_size is not None: kwargs['page_size'] = page_size if page is not None: kwargs['page'] = page resp = await action.handle(env, kwargs) self._base_assert_list_action_response( resp, action, stream) self.assertEqual( resp['items'], _raw_items[(_page - 1) * _page_size:_page * _page_size], { 'order': order, 'filters': filters, 'page_size': page_size, 'page': page, }) self.assertEqual(resp['filters_errors'], {}) self.assertEqual(resp['filters'], _filters) self.assertEqual(resp['page_size'], _page_size) self.assertEqual(resp['page'], _page) self.assertEqual(resp['order'], _order) self.assertEqual(resp['total'], len(_raw_items)) error_page_values = [-10, 0, 5.6, 'aaaa', '20', None] for value in error_page_values: with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'page': value, }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['page']) error_page_size_values = [-10, 0, 5.6, 'aaa', '20', None] for value in error_page_size_values: with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'page': value, }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['page']) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'filters': 56, }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['filters']) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'order': {}, }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['order']) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'page': 'xxx', }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['page']) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'page_size': 'xxx', }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['page_size']) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'page_size': -5, }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['page_size']) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'order': '+error_field', }) exc = ctx.exception self.assertEqual( exc.kwargs, { 'stream_name': 'test_stream', 'field_name': 'error_field' }, ) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, { 'page_size': 100, }) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['page_size']) #XXX to do: test ValidationError @asynctest async def test_get_item(self, db, stream, env): action = actions.GetItem(stream) mapper = db.mappers['db1']['Test'] await self._set_table_state(db, self.models1.test_table1, self.items) for raw_item in self.raw_edit_items: resp = await action.handle(env, {'item_id': raw_item['id']}) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual(resp['item'], raw_item) for value in [-10, 0, 5, 500]: with self.assertRaises(exceptions.ClientError): await action.handle(env, {'item_id': value}) with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, {}) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors']), ['item_id']) for value in [{}, None, [1, 2]]: with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, {'item_id': value}) ctx.exception @asynctest async def test_new_item(self, db, stream, env): action = actions.NewItem(stream) resp = await action.handle(env, {}) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual( resp['item'], { 'id': 50000, 'title': 'title-test_default-initials', 'date': '2005-05-05', }, ) #test initials resp = await action.handle(env, {'kwargs': { 'test_kwarg': 'test_init' }}) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual( resp['item'], { 'id': 50000, 'title': 'title-test_init-initials', 'date': '2005-05-05', }, ) #test kwargs test_exc = Exception('test') with self.assertRaises(Exception) as ctx: resp = await action.handle(env, {'kwargs': {'raise': test_exc}}) self.assertEqual(ctx.exception, test_exc) for value in [None, 'xxx', [], 10]: with self.assertRaises(exceptions.ClientError) as ctx: await action.handle(env, {'kwargs': value}) self.assertEqual( list(ctx.exception.kwargs['errors']), ['kwargs'], ) @asynctest async def test_create_item(self, db, stream, env): mapper = db.mappers['db1']['Test'] action = actions.CreateItem(stream) for item in self.raw_edit_items[:2]: _item = item.copy() _item.pop('id') resp = await action.handle(env, {'values': _item}) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual(resp['item'], item) self.assertEqual(resp['errors'], {}) for item in self.raw_edit_items[:-3:-1]: resp = await action.handle(env, {'values': item}) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual(resp['item'], item) self.assertEqual(resp['errors'], {}) await self._assert_table_state( db, self.models1.test_table1, self.edit_items, keys=['id', 'title', 'date'], ) # validation error _item = item.copy() _item['date'] = 'validation error' resp = await action.handle(env, {'values': _item}) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual(resp['item'], _item) self.assertEqual( resp['errors'], {'date': stream.item_fields[2].conv.error_not_valid},\ ) # errors with self.assertRaises(exceptions.ClientError): await action.handle(env, {}) with self.assertRaises(exceptions.ClientError): await action.handle(env, {'values': []}) with self.assertRaises(exceptions.ClientError): await action.handle(env, {'kwargs': None}) with self.assertRaises(exceptions.ClientError): resp = await action.handle(env, {'values': {'id': ''}}) #test kwargs test_exc = Exception('test') with self.assertRaises(Exception) as ctx: resp = await action.handle(env, { 'values': _item, 'kwargs': { 'raise': test_exc } }) self.assertEqual(ctx.exception, test_exc) @asynctest async def test_update_item(self, db, stream, env): action = actions.UpdateItem(stream) mapper = db.mappers['db1']['Test'] await self._set_table_state(db, self.models1.test_table1, self.items) items = self.edit_items.copy() resp = await action.handle(env, { 'item_id': 3, 'values': { 'title': 'updated_title' } }) self.assertEqual(resp['item_id'], 3) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual( resp['values'], { 'title': 'updated_title', }, ) self.assertEqual(resp['errors'], {}) items[3 - 1] = dict(items[3 - 1], title='updated_title') resp = await action.handle(env, { 'item_id': 4, 'values': { 'id': 50, 'title': 'updated_title2' } }) self.assertEqual(resp['item_id'], 50) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual( resp['values'], { 'id': 50, 'title': 'updated_title2', }, ) self.assertEqual(resp['errors'], {}) items[4 - 1] = dict(items[4 - 1], id=50, title='updated_title2') await self._assert_table_state( db, self.models1.test_table1, items, keys=['id', 'title', 'date'], ) # test errors with self.assertRaises(exceptions.ClientError) as ctx: resp = await action.handle(env, {}) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['item_id']) with self.assertRaises(exceptions.ClientError) as ctx: resp = await action.handle(env, {'item_id': 16}) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['values']) with self.assertRaises(exceptions.ClientError) as ctx: resp = await action.handle(env, {'item_id': 'error type'}) exc = ctx.exception self.assertEqual(list(exc.kwargs['errors'].keys()), ['item_id']) with self.assertRaises(exceptions.ClientError): resp = await action.handle(env, { 'item_id': 11, 'values': { 'id': 51, 'title': 'new_title' }, }) # validation error resp = await action.handle(env, { 'item_id': 11, 'values': { 'id': 51, 'date': 'validation error' }, }) self.assertEqual( resp['item_fields'], [f.widget.to_dict(f) for f in stream.item_fields], ) self.assertEqual( resp['errors'], {'date': stream.item_fields[2].conv.error_not_valid},\ ) @asynctest async def test_delete_item(self, db, stream, env): action = actions.DeleteItem(stream) mapper = db.mappers['db1']['Test'] await self._set_table_state(db, self.models1.test_table1, self.items) resp = await action.handle(env, {'item_id': 3}) self.assertEqual(resp['item_id'], 3) await self._assert_table_state( db, self.models1.test_table1, [self.item1, self.item2, self.item4], ) with self.assertRaises(exceptions.ClientError): await action.handle(env, {}) invalid_values = [None, 'aaa', [], {}, set()] for value in invalid_values: with self.assertRaises(exceptions.ClientError): await action.handle(env, {'item_id': value}) with self.assertRaises(exceptions.ClientError): await action.handle(env, {'item_id': 500})
async def asetup(self): self.models1 = create_models1() registry = orm.mappers.Registry(create_metadata([self.models1])) self.LocalMapperClass.create(registry, db_id='db1') self.RemoteMapperClass.create(registry, db_id='db1') local_mapper = registry['db1']['Local'] remote_mapper = registry['db1']['Remote'] registry.create_schema() state1 = DbState() state1['local'] = TableState(local_mapper.table) state1['remote'] = TableState(remote_mapper.table) state1['m2m'] = TableState( local_mapper.relations['m2m'].table, primary_keys=['local_id', 'remote_id'], ) state1['m2m_ordered'] = TableState( local_mapper.relations['m2m_ordered'].table, primary_keys=['local_id', 'remote_id'], ) state1['remote'].append({'id': 1, 'title': 'title1'}) state1['remote'].append({'id': 2, 'title': 'title2'}) state1['remote'].append({'id': 3, 'title': 'title3'}) state2 = state1.copy() state2['local'].append({'id': 1, 'title': 'title1'}) state2['m2m'].append({'local_id': 1, 'remote_id': 1}) state2['m2m'].append({'local_id': 1, 'remote_id': 2}) state2['m2m'].append({'local_id': 1, 'remote_id': 3}) state2['m2m_ordered'].append({ 'local_id': 1, 'remote_id': 1, 'order': 2 }) state2['m2m_ordered'].append({ 'local_id': 1, 'remote_id': 2, 'order': 1 }) state2['m2m_ordered'].append({ 'local_id': 1, 'remote_id': 3, 'order': 3 }) app = MagicMock() del app.db app.cfg.DATABASES = { 'db1': DB_URL, } Component = component(mappers=registry) db = await Component.create(app) async with await db() as session: conn1 = await session.get_connection(db.engines['db1']) await self.models1.reset(conn1) return { 'db': db, 'local_mapper': local_mapper, 'remote_mapper': remote_mapper, 'state1': state1, 'state2': state2, }
def test_models(self): return { 'db1': create_models1(), 'db2': create_models2(), }
class _SessionTestCaseBase(TestCase): test_models = { 'db1': create_models1(), 'db2': create_models2(), } async def asetup(self): engines = { 'db1': await Component.create_engine('db1', self.db_url), 'db2': await Component.create_engine('db2', self.db_url), } test_table1 = self.test_models['db1'].test_table1 test_table2 = self.test_models['db2'].test_table2 binds = { test_table1: engines['db1'], test_table2: engines['db2'], } async with engines['db1'].acquire() as conn: await self.test_models['db1'].reset(conn) async with engines['db2'].acquire() as conn: await self.test_models['db2'].reset(conn) return { 'engines': engines, 'binds': binds, } async def aclose(self, engines, binds): for engine in engines.values(): engine.terminate() await engine.wait_closed() @asynctest async def test_get_engine(self, engines, binds): test_table1 = self.test_models['db1'].test_table1 test_table2 = self.test_models['db2'].test_table2 async with Session(engines, binds) as session: i1 = sql.insert(test_table1) i2 = sql.insert(test_table2) u1 = sql.update(test_table1) u2 = sql.update(test_table2) d1 = sql.delete(test_table1) d2 = sql.delete(test_table2) s1 = sql.insert(test_table1) s2 = sql.insert(test_table2) for q1, q2 in [(i1, i2), (u1, u2), (d1, d2), (s1, s2)]: engine1 = session.get_engine(q1) engine2 = session.get_engine(q2) self.assertEqual(engine1, engines['db1']) self.assertEqual(engine2, engines['db2']) with self.assertRaises(exc.OrmError): session.get_engine('error query') async def _test_execute(self, engines, binds): test_table1 = self.test_models['db1'].test_table1 test_table2 = self.test_models['db2'].test_table2 async with Session(engines, binds) as session: q = sql.insert(test_table1).values(id=5, title='test_title') result = await session.execute(q) self.assertEqual(result.lastrowid, 5) q = sql.select(test_table1.c).where(test_table1.c.id == 5) result = await session.execute(q) self.assertEqual(result.rowcount, 1) result = list(result) self.assertEqual(result[0]['id'], 5) self.assertEqual(result[0]['title'], 'test_title') q = sql.update(test_table1).where(test_table1.c.id == 5).\ values(title='test_title2') result = await session.execute(q) self.assertEqual(result.rowcount, 1) q = sql.select(test_table1.c).\ where(test_table1.c.id == 5) result = await session.execute(q) self.assertEqual(result.rowcount, 1) result = list(result) self.assertEqual(result[0]['id'], 5) self.assertEqual(result[0]['title'], 'test_title2') q = sql.delete(test_table1).where(test_table1.c.id == 5) result = await session.execute(q) self.assertEqual(result.rowcount, 1) q = sql.select(test_table1.c).\ where(test_table1.c.id == 5) result = await session.execute(q) self.assertEqual(result.rowcount, 0) @asynctest async def test_rollback(self, engines, binds): test_table1 = self.test_models['db1'].test_table1 test_table2 = self.test_models['db2'].test_table2 async with Session(engines, binds) as session: q = sql.insert(test_table1).values(id=5, title='test_title') await session.execute(q) q = sql.insert(test_table2).values(id=10, title='test_title2') await session.execute(q) await session.rollback() async with Session(engines, binds) as session: q = sql.select(test_table1.c).where(test_table1.c.id == 5) rows = await session.execute(q) self.assertEqual(rows.rowcount, 0) q = sql.select(test_table2.c).where(test_table2.c.id == 10) rows = await session.execute(q) self.assertEqual(rows.rowcount, 0) try: async with Session(engines, binds) as session: q = sql.insert(test_table1).values(id=5, title='test_title') await session.execute(q) q = sql.insert(test_table2).values(id=10, title='test_title2') await session.execute(q) raise Exception except: pass async with Session(engines, binds) as session: q = sql.select(test_table1.c).where(test_table1.c.id == 5) rows = await session.execute(q) self.assertEqual(rows.rowcount, 0) q = sql.select(test_table2.c).where(test_table1.c.id == 10) rows = await session.execute(q) self.assertEqual(rows.rowcount, 0) @asynctest async def test_commit(self, engines, binds): test_table1 = self.test_models['db1'].test_table1 test_table2 = self.test_models['db2'].test_table2 async with Session(engines, binds) as session: q = sql.insert(test_table1).values(id=5, title='test_title') await session.execute(q) q = sql.insert(test_table2).values(id=10, title='test_title2') await session.execute(q) async with Session(engines, binds) as session: q = sql.select(test_table1.c).where(test_table1.c.id == 5) rows = await session.execute(q) self.assertEqual(rows.rowcount, 1) q = sql.select(test_table2.c).where(test_table2.c.id == 10) rows = await session.execute(q) self.assertEqual(rows.rowcount, 1) try: async with Session(engines, binds) as session: q = sql.insert(test_table1).values(id=5, title='test_title') await session.execute(q) session.commit() q = sql.insert(test_table2).values(id=10, title='test_title2') await session.execute(q) session.commit() raise Exception except: pass async with Session(engines, binds) as session: q = sql.select(test_table1.c).where(test_table1.c.id == 5) rows = await session.execute(q) self.assertEqual(rows.rowcount, 1) q = sql.select(test_table2.c).where(test_table2.c.id == 10) rows = await session.execute(q) self.assertEqual(rows.rowcount, 1)