async def test_insert_await_across_transaction_success(self):
tournament = Tournament(name='Test')
query = tournament.save() # pylint: disable=E1111
async with in_transaction():
await query
self.assertEqual(await Tournament.all(), [tournament])
async def test_insert_await_across_transaction_fail(self):
tournament = Tournament(name='Test')
query = tournament.save() # pylint: disable=E1111
try:
async with in_transaction():
await query
raise KeyError('moo')
except KeyError:
pass
self.assertEqual(await Tournament.all(), [])
async def bound_to_succeed():
tournament = Tournament(name='Test')
await tournament.save()
await Tournament.filter(id=tournament.id).update(name='Updated name')
saved_event = await Tournament.filter(name='Updated name').first()
self.assertEqual(saved_event.id, tournament.id)
return tournament
async def test_aggregation(self):
tournament = Tournament(name="New Tournament")
await tournament.save()
await Tournament.create(name="Second tournament")
await Event(name="Without participants",
tournament_id=tournament.id).save()
event = Event(name="Test", tournament_id=tournament.id)
await event.save()
participants = []
for i in range(2):
team = Team(name="Team {}".format(i + 1))
await team.save()
participants.append(team)
await event.participants.add(participants[0], participants[1])
await event.participants.add(participants[0], participants[1])
tournaments_with_count = (await Tournament.all().annotate(
events_count=Count("events")).filter(events_count__gte=1))
self.assertEqual(len(tournaments_with_count), 1)
self.assertEqual(tournaments_with_count[0].events_count, 2)
event_with_lowest_team_id = (await Event.filter(
id=event.id
).first().annotate(lowest_team_id=Min("participants__id")))
self.assertEqual(event_with_lowest_team_id.lowest_team_id,
participants[0].id)
ordered_tournaments = (await Tournament.all().annotate(
events_count=Count("events")).order_by("events_count"))
self.assertEqual(len(ordered_tournaments), 2)
self.assertEqual(ordered_tournaments[1].id, tournament.id)
event_with_annotation = (await Event.all().annotate(
tournament_test_id=Sum("tournament__id")).first())
self.assertEqual(event_with_annotation.tournament_test_id,
event_with_annotation.tournament_id)
async def test_delete_await_across_transaction_success(self):
await Tournament.create(name='Test1')
query = Tournament.filter(id=1).delete()
async with in_transaction():
await query
self.assertEqual(await Tournament.all(), [])
async def test_update_await_across_transaction_success(self):
await Tournament.create(name='Test1')
query = Tournament.filter(id=1).update(name='Test2')
async with in_transaction():
await query
self.assertEqual(await Tournament.all().values('id', 'name'), [{'id': 1, 'name': 'Test2'}])
async def test_select_await_across_transaction_success(self):
query = Tournament.all().values('id', 'name')
async with in_transaction():
await Tournament.create(name='Test1')
result = await query
self.assertEqual(result, [{'id': 1, 'name': 'Test1'}])
self.assertEqual(await Tournament.all().values('id', 'name'), [{'id': 1, 'name': 'Test1'}])
async def test_filtering(self):
tournament = Tournament(name='Tournament')
await tournament.save()
second_tournament = Tournament(name='Tournament 2')
await second_tournament.save()
event_first = Event(name='1', tournament=tournament)
await event_first.save()
event_second = Event(name='2', tournament=second_tournament)
await event_second.save()
event_third = Event(name='3', tournament=tournament)
await event_third.save()
event_forth = Event(name='4', tournament=second_tournament)
await event_forth.save()
team_first = Team(name='First')
await team_first.save()
team_second = Team(name='Second')
await team_second.save()
await team_first.events.add(event_first)
await event_second.participants.add(team_second)
found_events = await Event.filter(
Q(id__in=[event_first.id, event_second.id])
| Q(name='3')).filter(participants__not=team_second.id
).order_by('name',
'tournament_id').distinct()
self.assertEqual(len(found_events), 2)
self.assertEqual(found_events[0].id, event_first.id)
self.assertEqual(found_events[1].id, event_third.id)
await Team.filter(events__tournament_id=tournament.id
).order_by('-events__name')
await Tournament.filter(events__name__in=['1', '3'], ).distinct()
teams = await Team.filter(name__icontains='CON')
self.assertEqual(len(teams), 1)
self.assertEqual(teams[0].name, 'Second')
tournaments = await Tournament.filter(
events__participants__name__startswith='Fir')
self.assertEqual(len(tournaments), 1)
self.assertEqual(tournaments[0], tournament)
async def test_filtering(self):
tournament = Tournament(name="Tournament")
await tournament.save()
second_tournament = Tournament(name="Tournament 2")
await second_tournament.save()
event_first = Event(name="1", tournament=tournament)
await event_first.save()
event_second = Event(name="2", tournament=second_tournament)
await event_second.save()
event_third = Event(name="3", tournament=tournament)
await event_third.save()
event_forth = Event(name="4", tournament=second_tournament)
await event_forth.save()
team_first = Team(name="First")
await team_first.save()
team_second = Team(name="Second")
await team_second.save()
await team_first.events.add(event_first)
await event_second.participants.add(team_second)
found_events = (await Event.filter(
Q(id__in=[event_first.id, event_second.id])
| Q(name="3")).filter(participants__not=team_second.id
).order_by("name",
"tournament_id").distinct())
self.assertEqual(len(found_events), 2)
self.assertEqual(found_events[0].id, event_first.id)
self.assertEqual(found_events[1].id, event_third.id)
await Team.filter(events__tournament_id=tournament.id
).order_by("-events__name")
await Tournament.filter(events__name__in=["1", "3"]).distinct()
teams = await Team.filter(name__icontains="CON")
self.assertEqual(len(teams), 1)
self.assertEqual(teams[0].name, "Second")
tournaments = await Tournament.filter(
events__participants__name__startswith="Fir")
self.assertEqual(len(tournaments), 1)
self.assertEqual(tournaments[0], tournament)
async def test_relations(self):
tournament = Tournament(name="New Tournament")
await tournament.save()
await Event(name="Without participants",
tournament_id=tournament.id).save()
event = Event(name="Test", tournament_id=tournament.id)
await event.save()
participants = []
for i in range(2):
team = Team(name="Team {}".format(i + 1))
await team.save()
participants.append(team)
await event.participants.add(participants[0], participants[1])
await event.participants.add(participants[0], participants[1])
with self.assertRaises(NoValuesFetched):
[team.id for team in event.participants] # pylint: disable=W0104
teamids = []
async for team in event.participants:
teamids.append(team.id)
self.assertEqual(teamids, [participants[0].id, participants[1].id])
self.assertEqual([team.id for team in event.participants],
[participants[0].id, participants[1].id])
self.assertEqual(event.participants[0].id, participants[0].id)
selected_events = await Event.filter(participants=participants[0].id
).prefetch_related(
"participants", "tournament")
self.assertEqual(len(selected_events), 1)
self.assertEqual(selected_events[0].tournament.id, tournament.id)
self.assertEqual(len(selected_events[0].participants), 2)
await participants[0].fetch_related("events")
self.assertEqual(participants[0].events[0], event)
await Team.fetch_for_list(participants, "events")
await Team.filter(events__tournament__id=tournament.id)
await Event.filter(tournament=tournament)
await Tournament.filter(events__name__in=["Test", "Prod"]).distinct()
result = await Event.filter(id=event.id
).values("id",
"name",
tournament="tournament__name")
self.assertEqual(result[0]["tournament"], tournament.name)
result = await Event.filter(id=event.id
).values_list("id", "participants__name")
self.assertEqual(len(result), 2)
async def test_relations(self):
tournament = Tournament(name='New Tournament')
await tournament.save()
await Event(name='Without participants',
tournament_id=tournament.id).save()
event = Event(name='Test', tournament_id=tournament.id)
await event.save()
participants = []
for i in range(2):
team = Team(name='Team {}'.format(i + 1))
await team.save()
participants.append(team)
await event.participants.add(participants[0], participants[1])
await event.participants.add(participants[0], participants[1])
with self.assertRaises(NoValuesFetched):
[team.id for team in event.participants] # pylint: disable=W0104
teamids = []
async for team in event.participants:
teamids.append(team.id)
self.assertEqual(teamids, [participants[0].id, participants[1].id])
self.assertEqual([team.id for team in event.participants],
[participants[0].id, participants[1].id])
self.assertEqual(event.participants[0].id, participants[0].id)
selected_events = await Event.filter(participants=participants[0].id
).prefetch_related(
'participants', 'tournament')
self.assertEqual(len(selected_events), 1)
self.assertEqual(selected_events[0].tournament.id, tournament.id)
self.assertEqual(len(selected_events[0].participants), 2)
await participants[0].fetch_related('events')
self.assertEqual(participants[0].events[0], event)
await Team.fetch_for_list(participants, 'events')
await Team.filter(events__tournament__id=tournament.id)
await Event.filter(tournament=tournament)
await Tournament.filter(events__name__in=['Test', 'Prod']).distinct()
result = await Event.filter(id=event.id
).values('id',
'name',
tournament='tournament__name')
self.assertEqual(result[0]['tournament'], tournament.name)
result = await Event.filter(id=event.id
).values_list('id', 'participants__name')
self.assertEqual(len(result), 2)
async def test_delete_await_across_transaction_fail(self):
await Tournament.create(name='Test1')
query = Tournament.filter(id=1).delete()
try:
async with in_transaction():
await query
raise KeyError('moo')
except KeyError:
pass
self.assertEqual(await Tournament.all().values('id', 'name'), [{'id': 1, 'name': 'Test1'}])
async def test_transactions(self):
with self.assertRaises(SomeException):
async with in_transaction():
tournament = Tournament(name='Test')
await tournament.save()
await Tournament.filter(id=tournament.id).update(name='Updated name')
saved_event = await Tournament.filter(name='Updated name').first()
self.assertEqual(saved_event.id, tournament.id)
raise SomeException('Some error')
saved_event = await Tournament.filter(name='Updated name').first()
self.assertIsNone(saved_event)
async def test_select_await_across_transaction_fail(self):
query = Tournament.all().values('id', 'name')
try:
async with in_transaction():
await Tournament.create(name='Test1')
result = await query
raise KeyError('moo')
except KeyError:
pass
self.assertEqual(result, [{'id': 1, 'name': 'Test1'}])
self.assertEqual(await Tournament.all(), [])
async def test_select_await_across_transaction_success(self):
query = Tournament.all().values("id", "name")
async with in_transaction():
await Tournament.create(name="Test1")
result = await query
self.assertEqual(result, [{"id": 1, "name": "Test1"}])
self.assertEqual(await Tournament.all().values("id", "name"),
[{
"id": 1,
"name": "Test1"
}])
async def test_select_await_across_transaction_fail(self):
query = Tournament.all().values("id", "name")
try:
async with in_transaction():
await Tournament.create(name="Test1")
result = await query
raise KeyError("moo")
except KeyError:
pass
self.assertEqual(result, [{"id": 1, "name": "Test1"}])
self.assertEqual(await Tournament.all(), [])
async def test_update_await_across_transaction_success(self):
await Tournament.create(name="Test1")
query = Tournament.filter(id=1).update(name="Test2")
async with in_transaction():
await query
self.assertEqual(await Tournament.all().values("id", "name"),
[{
"id": 1,
"name": "Test2"
}])
async def test_delete_await_across_transaction_fail(self):
await Tournament.create(name="Test1")
query = Tournament.filter(id=1).delete()
try:
async with in_transaction():
await query
raise KeyError("moo")
except KeyError:
pass
self.assertEqual(await Tournament.all().values("id", "name"),
[{
"id": 1,
"name": "Test1"
}])
async def test_transactions(self):
with self.assertRaises(OperationalError):
async with self.db.in_transaction() as connection:
event = Tournament(name='Test')
await event.save(using_db=connection)
await Tournament.filter(id=event.id
).using_db(connection).update(
name='Updated name')
saved_event = await Tournament.filter(
name='Updated name').using_db(connection).first()
self.assertEqual(saved_event.id, event.id)
await connection.execute_query(
'SELECT * FROM non_existent_table')
saved_event = await Tournament.filter(name='Updated name').first()
self.assertIsNone(saved_event)
async def test_nested_transactions(self):
async with in_transaction():
tournament = Tournament(name="Test")
await tournament.save()
await Tournament.filter(id=tournament.id
).update(name="Updated name")
saved_event = await Tournament.filter(name="Updated name").first()
self.assertEqual(saved_event.id, tournament.id)
with self.assertRaises(SomeException):
async with in_transaction():
tournament = await Tournament.create(name="Nested")
saved_tournament = await Tournament.filter(name="Nested"
).first()
self.assertEqual(tournament.id, saved_tournament.id)
raise SomeException("Some error")
saved_event = await Tournament.filter(name="Updated name").first()
self.assertIsNotNone(saved_event)
not_saved_event = await Tournament.filter(name="Nested").first()
self.assertIsNone(not_saved_event)
async def setUp(self):
self.mdl = await Tournament.create(name='Test')
self.mdl2 = Tournament(name='Test')
self.cls = Tournament
async def atomic_decorated_func():
tournament = Tournament(name='Test')
await tournament.save()
return tournament
async def create_trans_concurrent(self):
async with in_transaction():
await asyncio.gather(*[Tournament.create(name="Test") for _ in range(100)])
async def test_concurrency_create(self):
all_write = await asyncio.gather(
*[Tournament.create(name='Test') for _ in range(100)])
all_read = await Tournament.all()
self.assertEqual(set(all_write), set(all_read))
async def test_concurrency_read(self):
await Tournament.create(name='Test')
tour1 = await Tournament.first()
all_read = await asyncio.gather(
*[Tournament.first() for _ in range(100)])
self.assertEqual(all_read, [tour1 for _ in range(100)])
