def testAllocatedTicket(self):
"""
Test that allocated_ticket works.
"""
# Create a raffle prize.
deadline = RaffleDeadline(
round_name="Overall",
pub_date=datetime.datetime.today() - datetime.timedelta(hours=1),
end_date=datetime.datetime.today() + datetime.timedelta(days=5),
)
deadline.save()
prize = RafflePrize(title="Super prize!", description="A test prize", deadline=deadline)
prize.save()
# Test within context of a quest
self.quest.unlock_conditions = "allocated_ticket()"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(
self.quest not in quests["available_quests"], "User should not be able to participate in this quest."
)
self.quest.unlock_conditions = "not allocated_ticket()"
self.quest.completion_conditions = "allocated_ticket()"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"], "User should be able to participate in this quest.")
self.quest.accept(self.user)
# Add a raffle ticket and test that the user completed the quest.
ticket = RaffleTicket(raffle_prize=prize, user=self.user)
ticket.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests, "User should have completed the quest.")
def testHasPointsOverall(self):
"""Tests that has_points works for a user."""
profile = self.user.get_profile()
test_points = 10
self.assertFalse(has_points(self.user, test_points), "User should not have any points")
profile.points = test_points
profile.save()
self.assertTrue(has_points(self.user, test_points), "User should have enough points.")
# Test within context of a quest.
profile.points = 0
profile.save()
self.quest.unlock_conditions = "has_points(10)"
self.quest.save()
self.assertTrue(
self.quest not in get_quests(self.user), "User should not be able to participate in this quest."
)
self.quest.unlock_conditions = "not has_points(10)"
self.quest.save()
print self.user.get_profile().points
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"], "User should be able to participate in this quest."
)
self.quest.accept(self.user)
self.quest.completion_conditions = "has_points(10)"
self.quest.save()
self.assertTrue(
self.quest not in possibly_completed_quests(self.user), "User should not be able to complete this quest."
)
profile.points = 10
profile.save()
self.assertTrue(self.quest in possibly_completed_quests(self.user), "User should have completed this quest.")
def testBasicCompletion(self):
"""Tests that the user can complete quests."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="True",
completion_conditions="False",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 1, "User should have one quest.")
quests["available_quests"][0].accept(self.user)
possibly_completed_quests(self.user)
complete_quests = self.user.quest_set.filter(questmember__completed=True)
self.assertTrue(quest not in complete_quests, "Quest should not be completed.")
quest.completion_conditions = True
quest.save()
possibly_completed_quests(self.user)
complete_quests = self.user.quest_set.filter(questmember__completed=True)
self.assertTrue(quest in complete_quests, "Quest should be in the user's complete quests list.")
quests = get_quests(self.user)
self.assertTrue(quest not in quests["available_quests"], "Quest should not be available after completion.")
self.assertTrue(quest not in quests["user_quests"], "Quest should not be in the user's active quests.")
def testHasCommitment(self):
"""Tests that has_task works for a commitment in progress."""
commitment = Commitment(
title="Test commitment",
type="commitment",
name="Test",
slug="test-commitment",
description="A commitment!",
point_value=10,
)
commitment.save()
# Test as an unlock condition.
self.quest.unlock_conditions = "has_task(slug='test-commitment')"
self.quest.save()
self.assertTrue(
self.quest not in get_quests(self.user), "User should not be able to participate in this quest."
)
member = CommitmentMember(user=self.user, commitment=commitment)
member.save()
self.assertTrue(has_task(self.user, slug="test-commitment"), "User should have a commitment in progress.")
self.assertTrue(has_task(self.user, task_type="commitment"), "User should have a commitment in progress.")
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"], "User should be able to participate in this quest."
)
self.quest.unlock_conditions = "has_task(task_type='commitment')"
self.quest.save()
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"], "User should be able to participate in this quest."
)
member.award_date = datetime.datetime.today()
member.save()
self.assertTrue(has_task(self.user, slug="test-commitment"), "User should have a completed commitment.")
self.assertTrue(has_task(self.user, task_type="commitment"), "User should have a completed commitment.")
# Test as a completion condition
self.quest.accept(self.user)
self.quest.completion_conditions = "not has_task(slug='test-commitment')"
self.quest.save()
self.assertTrue(
self.quest not in possibly_completed_quests(self.user), "User should not be able to complete this quest."
)
self.quest.completion_conditions = "not has_task(task_type='commitment')"
self.quest.save()
self.assertTrue(
self.quest not in possibly_completed_quests(self.user), "User should not be able to complete this quest."
)
self.quest.completion_conditions = "has_task(slug='test-commitment')"
self.quest.save()
self.assertTrue(
self.quest in possibly_completed_quests(self.user), "User should be able to complete this quest."
)
def testHasActivity(self):
"""Test that completing an activity works with has_task."""
activity = Activity(
type="activity",
name="Test",
slug="test-activity",
title="Test activity",
description="Variable points!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
# Test within context of a quest
self.quest.unlock_conditions = "has_task(slug='test-activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest not in quests, "User should not be able to participate in this quest.")
member = ActivityMember(user=self.user, activity=activity, approval_status="pending")
member.save()
self.assertTrue(has_task(self.user, slug="test-activity"), "User should have a pending task.")
self.assertTrue(has_task(self.user, task_type="activity"), "User should have a pending task.")
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"], "User should be able to participate in this quest.")
self.quest.unlock_conditions = "has_task(task_type='activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"], "User should be able to participate in this quest.")
member.approval_status = "approved"
member.save()
self.assertTrue(has_task(self.user, slug="test-activity"), "User should have a completed task.")
self.assertTrue(has_task(self.user, task_type="activity"), "User should have a completed task.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "not has_task(slug='test-activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests, "User should not be able to complete the quest.")
self.quest.completion_conditions = "not has_task(task_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests, "User should not be able to complete the quest.")
self.quest.completion_conditions = "has_task(slug='test-activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests, "User should have completed the quest.")
def testGetQuests(self):
"""Tests that we can get the quests for a user."""
# Create some sample quests.
self.assertEqual(len(get_quests(self.user)["available_quests"]), 0,
"There are no quests for the user.")
for i in range(0, 3):
quest_name = "Test Quest %d" % i
quest = Quest(
name=quest_name,
quest_slug="test_quest_%d" % i,
description=quest_name,
level=1,
unlock_conditions="True",
completion_conditions="False" # User cannot complete these.
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 3,
"User should have 3 quests available.")
# Test that if we add another quest, the user still has the 3 original quests.
quest = Quest(
name="Another quest",
quest_slug="another_quest",
description="another quest",
level=1,
unlock_conditions="True",
completion_conditions="False",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 3,
"User should still have 3 quests available.")
self.assertTrue(quest not in quests,
"New quest should not be in quests.")
# Mark a quest as completed so that the new quest is picked up.
quests["available_quests"][0].accept(self.user)
member = QuestMember.objects.filter(user=self.user)[0]
member.completed = True
member.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 3,
"User should have 3 quests available.")
self.assertTrue(quest in quests["available_quests"],
"New quest should be in quests.")
def testOptOut(self):
"""Test that once a user opts out of a quest, it doesn't show up."""
quest = Quest(
name="Another quest",
quest_slug="another_quest",
description="another quest",
level=1,
unlock_conditions="False", # User cannot unlock this quest
completion_conditions="False",
)
quest.save()
self.assertFalse(quest.opt_out(self.user),
"User should not be able to see this quest.")
quest.unlock_conditions = "True"
quest.save()
self.assertTrue(quest.opt_out(self.user),
"User should be able to opt out of this quest.")
quests = get_quests(self.user)
self.assertTrue(quest not in quests["available_quests"],
"User should not see the quest as available.")
self.assertTrue(
quest not in quests["user_quests"],
"User should not have this listed as their current quest.")
def testNumTasksCompletedWithType(self):
activity = Activity(
type="activity",
name="Test",
title="Test activity",
description="Variable points!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
# Test activities
member = ActivityMember(user=self.user, activity=activity, approval_status="pending")
member.save()
self.assertFalse(
num_tasks_completed(self.user, 1, task_type="activity"),
"User with pending activity should not have completed a task.",
)
# Test within context of a quest
self.quest.unlock_conditions = "num_tasks_completed(1, task_type='activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest not in quests, "User should not be able to participate in this quest.")
# Check that the user can now add the quest.
member.approval_status = "approved"
member.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"], "User should be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "num_tasks_completed(2, task_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests, "User should not be able to complete the quest.")
self.quest.completion_conditions = "num_tasks_completed(1, task_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests, "User should have completed the quest.")
def testGetQuests(self):
"""Tests that we can get the quests for a user."""
# Create some sample quests.
self.assertEqual(len(get_quests(self.user)["available_quests"]), 0, "There are no quests for the user.")
for i in range(0, 3):
quest_name = "Test Quest %d" % i
quest = Quest(
name=quest_name,
quest_slug="test_quest_%d" % i,
description=quest_name,
level=1,
unlock_conditions="True",
completion_conditions="False" # User cannot complete these.
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 3, "User should have 3 quests available.")
# Test that if we add another quest, the user still has the 3 original quests.
quest = Quest(
name="Another quest",
quest_slug="another_quest",
description="another quest",
level=1,
unlock_conditions="True",
completion_conditions="False",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 3, "User should still have 3 quests available.")
self.assertTrue(quest not in quests, "New quest should not be in quests.")
# Mark a quest as completed so that the new quest is picked up.
quests["available_quests"][0].accept(self.user)
member = QuestMember.objects.filter(user=self.user)[0]
member.completed = True
member.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 3, "User should have 3 quests available.")
self.assertTrue(quest in quests["available_quests"], "New quest should be in quests.")
def testBasicPrerequisites(self):
"""Tests that the user can only get quests for which they meet the prerequisites."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="False",
completion_conditions="False",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 0, "User should not have this quest available.")
quest.unlock_conditions = "True"
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 1, "User should now have one quest.")
def testCommitmentsNumCompleted(self):
"""Tests that num_tasks_completed works for a completed commitment."""
commitment = Commitment(
title="Test commitment", type="commitment", name="Test", description="A commitment!", point_value=10
)
commitment.save()
member = CommitmentMember(user=self.user, commitment=commitment)
member.save()
self.assertFalse(
num_tasks_completed(self.user, 1), "User with commitment in progress should not have completed a task."
)
# Test as an unlock condition
self.quest.unlock_conditions = "num_tasks_completed(1)"
self.quest.save()
self.assertTrue(
self.quest not in get_quests(self.user), "User should not be able to participate in this quest."
)
member.award_date = datetime.datetime.today()
member.save()
self.assertTrue(
num_tasks_completed(self.user, 1), "User that has a completed commitment did not complete a task."
)
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"], "User should be able to participate in this quest."
)
# Test as a completion condition
self.quest.accept(self.user)
self.quest.completion_conditions = "num_tasks_completed(2)"
self.quest.save()
self.assertTrue(
self.quest not in possibly_completed_quests(self.user), "User should not be able to complete this quest."
)
self.quest.completion_conditions = "num_tasks_completed(1)"
self.quest.save()
self.assertTrue(
self.quest in possibly_completed_quests(self.user), "User should be able to complete this quest."
)
def testBasicPrerequisites(self):
"""Tests that the user can only get quests for which they meet the prerequisites."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="False",
completion_conditions="False",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 0,
"User should not have this quest available.")
quest.unlock_conditions = "True"
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 1,
"User should now have one quest.")
def competition(request):
"""Provides access to standard competition constants within a template."""
user = request.user
# We may want to retrieve theme settings for insertion into CSS.
theme_name, theme_dict = get_theme()
# Get user-specific information.
floor_count = Floor.objects.count()
overall_member_count = Profile.objects.count()
floor_member_count = None
quests = None
quest_help = None
notifications = None
# Try to load quest_help from the database.
try:
quest_help = HelpTopic.objects.get(slug="quests", category="widget")
except HelpTopic.DoesNotExist:
pass
if user.is_authenticated():
quests = get_quests(user)
notifications = get_unread_notifications(user, limit=3)
if user.get_profile().floor:
floor_member_count = user.get_profile().floor.profile_set.count()
# Get current round info.
current_round = get_current_round()
# Get Facebook info.
try:
facebook_app_id = settings.FACEBOOK_APP_ID
except AttributeError:
facebook_app_id = None
return {
"COMPETITION_NAME": settings.COMPETITION_NAME,
"COMPETITION_POINT_NAME": settings.COMPETITION_POINT_NAME or "point",
"THEME_NAME": theme_name,
"THEME": theme_dict,
"FLOOR_COUNT": floor_count,
"FLOOR_MEMBER_COUNT": floor_member_count,
"OVERALL_MEMBER_COUNT": overall_member_count,
"ROUNDS": get_rounds_for_header(),
"FLOOR_LABEL": get_floor_label(),
"CURRENT_ROUND": current_round,
"FACEBOOK_APP_ID": facebook_app_id,
"QUESTS": quests,
"QUEST_HELP": quest_help,
"NOTIFICATIONS": notifications,
}
def competition(request):
"""Provides access to standard competition constants within a template."""
user = request.user
# We may want to retrieve theme settings for insertion into CSS.
theme_name, theme_dict = get_theme()
# Get user-specific information.
floor_count = Floor.objects.count()
overall_member_count = Profile.objects.count()
floor_member_count = None
quests = None
notifications = None
if user.is_authenticated():
quests = get_quests(user)
notifications = get_unread_notifications(user, limit=3)
if user.get_profile().floor:
floor_member_count = user.get_profile().floor.profile_set.count()
# Get current round info.
current_round = get_current_round() or "Overall"
# Get Facebook info.
try:
facebook_app_id = settings.FACEBOOK_APP_ID
except AttributeError:
facebook_app_id = None
return {
"STATIC_URL": settings.STATIC_URL,
"COMPETITION_NAME": settings.COMPETITION_NAME,
"COMPETITION_POINT_NAME": settings.COMPETITION_POINT_NAME or "point",
"THEME_NAME": theme_name,
"THEME": theme_dict,
"FLOOR_COUNT": floor_count,
"FLOOR_MEMBER_COUNT": floor_member_count,
"OVERALL_MEMBER_COUNT": overall_member_count,
"ROUNDS": get_rounds_for_header(),
"FLOOR_LABEL": get_floor_label(),
"CURRENT_ROUND": current_round,
"CURRENT_ROUND_INFO": get_current_round_info(),
"FACEBOOK_APP_ID": facebook_app_id,
"QUESTS": quests,
"NOTIFICATIONS": notifications,
"IN_COMPETITION": in_competition(),
"SPREADSHEETS": {
"THIRTY_DAYS": settings.ENERGY_THIRTY_DAYS_URL,
"ENERGY_GOAL": settings.ENERGY_GOAL_URL,
"POWER": settings.POWER_GAUGE_URL,
}
}
def competition(request):
"""Provides access to standard competition constants within a template."""
user = request.user
# We may want to retrieve theme settings for insertion into CSS.
theme_name, theme_dict = get_theme()
# Get user-specific information.
floor_count = Floor.objects.count()
overall_member_count = Profile.objects.count()
floor_member_count = None
quests = None
notifications = None
if user.is_authenticated():
quests = get_quests(user)
notifications = get_unread_notifications(user, limit=3)
if user.get_profile().floor:
floor_member_count = user.get_profile().floor.profile_set.count()
# Get current round info.
current_round = get_current_round() or "Overall"
# Get Facebook info.
try:
facebook_app_id = settings.FACEBOOK_APP_ID
except AttributeError:
facebook_app_id = None
return {
"STATIC_URL": settings.STATIC_URL,
"COMPETITION_NAME": settings.COMPETITION_NAME,
"COMPETITION_POINT_NAME": settings.COMPETITION_POINT_NAME or "point",
"THEME_NAME": theme_name,
"THEME": theme_dict,
"FLOOR_COUNT": floor_count,
"FLOOR_MEMBER_COUNT": floor_member_count,
"OVERALL_MEMBER_COUNT": overall_member_count,
"ROUNDS": get_rounds_for_header(),
"FLOOR_LABEL": get_floor_label(),
"CURRENT_ROUND": current_round,
"CURRENT_ROUND_INFO": get_current_round_info(),
"FACEBOOK_APP_ID": facebook_app_id,
"QUESTS": quests,
"NOTIFICATIONS": notifications,
"IN_COMPETITION": in_competition(),
"SPREADSHEETS": {
"THIRTY_DAYS": settings.ENERGY_THIRTY_DAYS_URL,
"ENERGY_GOAL": settings.ENERGY_GOAL_URL,
"POWER": settings.POWER_GAUGE_URL,
}
}
def testBadgeAwarded(self):
"""Tests that badge awarded works for a user."""
from components.makahiki_badges.user_badges import DailyVisitorBadge
badges.register(DailyVisitorBadge)
profile = self.user.get_profile()
self.assertFalse(
badge_awarded(self.user, "dailyvisitor"), "New user should not be awarded the daily visitor badge."
)
# Test as a quest unlock condition.
self.quest.unlock_conditions = "badge_awarded('dailyvisitor')"
self.quest.save()
self.assertTrue(
self.quest not in get_quests(self.user), "User should not be able to participate in this quest."
)
self.quest.unlock_conditions = "not badge_awarded('dailyvisitor')"
self.quest.save()
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"], "User should be able to participate in this quest."
)
self.quest.accept(self.user)
self.quest.completion_conditions = "badge_awarded('dailyvisitor')"
self.quest.save()
self.assertTrue(
self.quest not in possibly_completed_quests(self.user), "User should not be able to complete this quest."
)
profile.daily_visit_count = 3
profile.save()
badges.possibly_award_badge("dailyvisitor", user=self.user)
self.assertTrue(
badge_awarded(self.user, "dailyvisitor"), "User should have been awarded the daily visitor badge."
)
self.assertTrue(self.quest in possibly_completed_quests(self.user), "User should have completed this quest.")
def testBasicCompletion(self):
"""Tests that the user can complete quests."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="True",
completion_conditions="False",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 1,
"User should have one quest.")
quests["available_quests"][0].accept(self.user)
possibly_completed_quests(self.user)
complete_quests = self.user.quest_set.filter(
questmember__completed=True)
self.assertTrue(quest not in complete_quests,
"Quest should not be completed.")
quest.completion_conditions = True
quest.save()
possibly_completed_quests(self.user)
complete_quests = self.user.quest_set.filter(
questmember__completed=True)
self.assertTrue(quest in complete_quests,
"Quest should be in the user's complete quests list.")
quests = get_quests(self.user)
self.assertTrue(quest not in quests["available_quests"],
"Quest should not be available after completion.")
self.assertTrue(quest not in quests["user_quests"],
"Quest should not be in the user's active quests.")
def testCommentsAreIgnored(self):
"""Tests that any comments in the text are ignored."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="#Hello World\nTrue",
completion_conditions="#Hello World\nTrue",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 1, "User should now have one quest.")
quests["available_quests"][0].accept(self.user)
possibly_completed_quests(self.user)
complete_quests = self.user.quest_set.filter(questmember__completed=True)
self.assertTrue(quest in complete_quests, "Quest should be in the user's complete quests list.")
def testOptOut(self):
"""Test that once a user opts out of a quest, it doesn't show up."""
quest = Quest(
name="Another quest",
quest_slug="another_quest",
description="another quest",
level=1,
unlock_conditions="False", # User cannot unlock this quest
completion_conditions="False",
)
quest.save()
self.assertFalse(quest.opt_out(self.user), "User should not be able to see this quest.")
quest.unlock_conditions = "True"
quest.save()
self.assertTrue(quest.opt_out(self.user), "User should be able to opt out of this quest.")
quests = get_quests(self.user)
self.assertTrue(quest not in quests["available_quests"], "User should not see the quest as available.")
self.assertTrue(quest not in quests["user_quests"], "User should not have this listed as their current quest.")
def testAcceptQuest(self):
"""Test that a user can accept a quest using a url."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="True",
completion_conditions="False",
)
quest.save()
response = self.client.get(reverse("home_index"))
self.assertContains(response, "Test quest", msg_prefix="Test quest should be available to the user.")
response = self.client.post(
reverse("quests_accept", args=(quest.quest_slug,)),
follow=True,
HTTP_REFERER=reverse("home_index"),
)
self.assertRedirects(response, reverse("home_index"))
quests = get_quests(self.user)
self.assertEqual(len(quests["user_quests"]), 1, "User should have one quest.")
def testCommentsAreIgnored(self):
"""Tests that any comments in the text are ignored."""
quest = Quest(
name="Test quest",
quest_slug="test_quest",
description="test quest",
level=1,
unlock_conditions="#Hello World\nTrue",
completion_conditions="#Hello World\nTrue",
)
quest.save()
quests = get_quests(self.user)
self.assertEqual(len(quests["available_quests"]), 1,
"User should now have one quest.")
quests["available_quests"][0].accept(self.user)
possibly_completed_quests(self.user)
complete_quests = self.user.quest_set.filter(
questmember__completed=True)
self.assertTrue(quest in complete_quests,
"Quest should be in the user's complete quests list.")