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 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(pk__in=[event_first.pk, event_second.pk])
| 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].pk, event_first.pk)
self.assertEqual(found_events[1].pk, event_third.pk)
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")
teams = await Team.filter(name__iexact="SeCoNd")
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=f"Team {(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(set(teamids),
{participants[0].id, participants[1].id})
teamids = [team.id async for team in event.participants]
self.assertEqual(set(teamids),
{participants[0].id, participants[1].id})
self.assertEqual({team.id
for team in event.participants},
{participants[0].id, participants[1].id})
self.assertIn(event.participants[0].id,
{participants[0].id, participants[1].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_prefetch_direct_relation_to_attr(self):
tournament = await Tournament.create(name="tournament")
await Event.create(name="First", tournament=tournament)
event = await Event.first().prefetch_related(
Prefetch("tournament", queryset=Tournament.all(), to_attr="to_attr_tournament")
)
self.assertEqual(event.to_attr_tournament.id, tournament.id)
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_delete_await_across_transaction_success(self):
obj = await Tournament.create(name="Test1")
query = Tournament.filter(id=obj.id).delete()
async with in_transaction():
await query
self.assertEqual(await Tournament.all(), [])
async def test_select_await_across_transaction_success(self):
query = Tournament.all().values("id", "name")
async with in_transaction():
obj = await Tournament.create(name="Test1")
result = await query
self.assertEqual(result, [{"id": obj.id, "name": "Test1"}])
self.assertEqual(
await Tournament.all().values("id", "name"), [{"id": obj.id, "name": "Test1"}]
)
async def test_update_await_across_transaction_success(self):
obj = await Tournament.create(name="Test1")
query = Tournament.filter(id=obj.id).update(name="Test2")
async with in_transaction():
await query
self.assertEqual(
await Tournament.all().values("id", "name"), [{"id": obj.id, "name": "Test2"}]
)
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()
await Team.bulk_create(
Team(name="Team {}".format(i + 1)) for i in range(2))
participants = list(await Team.all())
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).annotate(
lowest_team_id=Min("participants__id")).first())
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)
##############
default_name_tournaments = (await Tournament.all().annotate(
Count("events")).order_by("events__count"))
self.assertEqual(len(default_name_tournaments), 2)
self.assertEqual(default_name_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)
##############
with self.assertRaisesRegex(NotARelationFieldError,
str(NotARelationFieldError("name",
Event))):
await Event.all().annotate(tournament_test_id=Sum("name__id")
).first()
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("name")
try:
async with in_transaction():
await Tournament.create(name="Test1")
result = await query
raise KeyError("moo")
except KeyError:
pass
self.assertEqual(result, [{"name": "Test1"}])
self.assertEqual(await Tournament.all(), [])
async def test_delete_await_across_transaction_fail(self):
obj = await Tournament.create(name="Test1")
query = Tournament.filter(id=obj.id).delete()
try:
async with in_transaction():
await query
raise KeyError("moo")
except KeyError:
pass
self.assertEqual(
await Tournament.all().values("id", "name"), [{"id": obj.id, "name": "Test1"}]
)
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")
# TODO: reactive once savepoints are implemented
# 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 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
)
with self.assertRaisesRegex(ConfigurationError, "name__id not resolvable"):
await Event.all().annotate(tournament_test_id=Sum("name__id")).first()
async def create_trans_concurrent(self):
async with in_transaction():
await asyncio.gather(
*[Tournament.create(name="Test") for _ in range(100)])
async def atomic_decorated_func():
tournament = Tournament(name="Test")
await tournament.save()
return tournament
async def asyncSetUp(self):
await super().asyncSetUp()
self.mdl = await Tournament.create(name="Test")
self.mdl2 = Tournament(name="Test")
self.cls = Tournament
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))
def test_fk_unsaved(self):
with self.assertRaisesRegex(OperationalError,
"You should first call .save()"):
Event(name="a", tournament=Tournament(name="a"))
async def asyncSetUp(self) -> None:
self.mdl = await Tournament.create(name="Test")
self.mdl2 = Tournament(name="Test")
self.cls = Tournament
async def test_subquery_select(self):
t1 = await Tournament.create(name="1")
ret = (await Tournament.filter(pk=t1.pk).annotate(
ids=Subquery(Tournament.filter(pk=t1.pk).values("id"))
).values("ids", "id"))
self.assertEqual(ret, [{"id": t1.pk, "ids": t1.pk}])
def test_rev_fk(self):
with self.assertRaisesRegex(
ConfigurationError,
"You can't set backward relations through init, change related model instead",
):
Tournament(name="a", events=[])
async def test_subquery_filter(self):
t1 = await Tournament.create(name="1")
ret = await Tournament.filter(
pk=Subquery(Tournament.filter(pk=t1.pk).values("id"))).first()
self.assertEqual(ret, t1)
async def setUp(self):
self.mdl = await Tournament.create(name="Test")
self.mdl2 = Tournament(name="Test")
self.cls = Tournament
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)])
