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 testSetupComplete(self):
"""
Check that we can access the complete page of the setup wizard.
"""
# Test a normal GET request (answer was incorrect).
response = self.client.get(reverse("setup_complete"), {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertTemplateUsed(response, "home/first-login/complete.html")
try:
response_dict = json.loads(response.content)
except ValueError:
self.fail("Response JSON could not be decoded.")
user = User.objects.get(username="******")
self.assertTrue(user.get_profile().setup_complete, "Check that the user has completed the profile setup.")
# Create the activity to link to.
activity = Activity(
title="Test activity",
name=settings.SETUP_WIZARD_ACTIVITY_NAME,
description="Testing!",
duration=10,
point_value=15,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
# Test a normal POST request (answer was correct).
profile = user.get_profile()
points = profile.points
profile.setup_complete = False
profile.save()
response = self.client.post(reverse("setup_complete"), {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertTemplateUsed(response, "home/first-login/complete.html")
try:
response_dict = json.loads(response.content)
except ValueError:
self.fail("Response JSON could not be decoded.")
user = User.objects.get(username="******")
self.assertTrue(user.get_profile().setup_complete, "Check that the user has completed the profile setup.")
self.assertEqual(points + 15, user.get_profile().points, "Check that the user has been awarded points as well.")
member = ActivityMember.objects.get(user=user, activity=activity)
self.assertEqual(member.approval_status, "approved", "Test that the user completed the linked activity.")
def setUp(self):
"""Generate test user and activity. Set the competition settings to the current date for testing."""
self.user = User(username="******", password="******")
self.user.save()
self.activity = Activity(
title="Test activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
self.activity.save()
self.saved_rounds = settings.COMPETITION_ROUNDS
self.current_round = "Round 1"
start = datetime.date.today()
end = start + datetime.timedelta(days=7)
settings.COMPETITION_ROUNDS = {
"Round 1" : {
"start": start.strftime("%Y-%m-%d"),
"end": end.strftime("%Y-%m-%d"),
},
}
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 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 testVariablePointAchievement(self):
"""Test that a variable point activity appears correctly in the my achievements list."""
activity = Activity(
title="Test activity",
slug="test-activity",
description="Variable points!",
duration=10,
point_range_start=5,
point_range_end=314160,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
points = self.user.get_profile().points
member = ActivityMember.objects.create(
user=self.user,
activity=activity,
approval_status="approved",
points_awarded=314159,
)
member.save()
self.assertEqual(self.user.get_profile().points, points + 314159,
"Variable number of points should have been awarded.")
# Kludge to change point value for the info bar.
profile = self.user.get_profile()
profile.add_points(3, datetime.datetime.today(), "test")
profile.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.type, activity.slug,)))
# Note, this test may break if something in the page has the value 314159. Try finding another suitable number.
# print response.content
self.assertContains(response, "314159", count=1, msg_prefix="314159 points should appear for the activity.")
def testRejectedActivity(self):
"""
Test that a rejected activity submission posts a message.
"""
activity = Activity(
title="Test activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
member = ActivityMember(activity=activity, user=self.user, approval_status="rejected")
member.save()
response = self.client.get(reverse("activity_index"))
self.assertContains(response, "Your response to <a href='%s'>%s</a> was not approved" % (
reverse("activity_task", args=(activity.id,)),
activity.title,
))
response = self.client.get(reverse("activity_index"))
self.assertNotContains(response, "notification-box")
def testActivityAchievement(self):
"""Check that the user's activity achievements are loaded."""
activity = Activity(
title="Test activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
is_canopy=True
)
activity.save()
# Test that profile page has a pending activity.
member = ActivityMember(user=self.user, activity=activity, approval_status="approved")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.type, activity.slug,)))
self.assertContains(response, "Canopy Activity:")
self.assertContains(response, "%d (Karma)" % activity.point_value)
# Test adding an event to catch a bug.
event = Activity(
title="Test event",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="event",
)
event.save()
member = ActivityMember(user=self.user, activity=event, approval_status="pending")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.type, activity.slug,)))
self.assertContains(response, "Pending")
self.assertContains(response, "Activity:")
self.assertContains(response, "Event:")
self.assertNotContains(response, "You have nothing in progress or pending.")
def testAwardRollback(self):
"""Tests that the last_awarded_submission field rolls back to a previous task."""
user = User(username="******", password="******")
user.save()
activity1 = Activity(
title="Test activity",
slug="test-activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity1.save()
activity2 = Activity(
title="Test activity 2",
slug="test-activity-2",
description="Testing!",
duration=10,
point_value=15,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity2.save()
activities = [activity1, activity2]
# Submit the first activity. This is what we're going to rollback to.
activity_member = ActivityMember(user=user, activity=activities[0], submission_date=datetime.datetime.today())
activity_member.approval_status = "approved"
activity_member.submission_date = datetime.datetime.today() - datetime.timedelta(days=1)
activity_member.save()
points = user.get_profile().points
submit_date = user.get_profile().last_awarded_submission
# Submit second activity.
activity_member = ActivityMember(user=user, activity=activities[1], submission_date=datetime.datetime.today())
activity_member.approval_status = "approved"
activity_member.submission_date = datetime.datetime.today()
activity_member.save()
logs = user.pointstransaction_set.count()
activity_member.approval_status = "rejected"
activity_member.submission_date = datetime.datetime.today()
activity_member.save()
# Verify that we rolled back to the previous activity.
self.assertEqual(points, user.get_profile().points)
class ScoreboardEntryUnitTests(TestCase):
def setUp(self):
"""Generate test user and activity. Set the competition settings to the current date for testing."""
self.user = User(username="******", password="******")
self.user.save()
self.activity = Activity(
title="Test activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
self.activity.save()
self.saved_rounds = settings.COMPETITION_ROUNDS
self.current_round = "Round 1"
start = datetime.date.today()
end = start + datetime.timedelta(days=7)
settings.COMPETITION_ROUNDS = {
"Round 1" : {
"start": start.strftime("%Y-%m-%d"),
"end": end.strftime("%Y-%m-%d"),
},
}
def testRoundsUpdate(self):
"""Test that the score for the round updates when an activity is approved."""
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
round_points = entry.points
round_submission_date = entry.last_awarded_submission
activity_points = self.activity.point_value
activity_member = ActivityMember(user=self.user, activity=self.activity)
activity_member.approval_status = "approved"
activity_member.save()
# Verify that the points for the round has been updated.
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
self.assertEqual(round_points + activity_points, entry.points)
self.assertNotEqual(round_submission_date, entry.last_awarded_submission)
def testRoundDoesNotUpdate(self):
"""Test that the score for the round does not update for an activity submitted outside of the round."""
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
round_points = entry.points
round_submission_date = entry.last_awarded_submission
activity_member = ActivityMember(user=self.user, activity=self.activity)
activity_member.approval_status = "approved"
activity_member.submission_date = datetime.datetime.today() - datetime.timedelta(days=1)
activity_member.save()
# Verify that the points for the round has not been updated.
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
self.assertEqual(round_points, entry.points)
self.assertEqual(round_submission_date, entry.last_awarded_submission)
def testUserOverallRoundRankWithPoints(self):
"""Tests that the overall rank calculation for a user in a round is correct based on points."""
profile = self.user.get_profile()
top_entry = ScoreboardEntry.objects.filter(round_name=self.current_round).order_by("-points")[0]
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
entry.points = top_entry.points + 1
entry.last_awarded_submission = datetime.datetime.today()
entry.save()
self.assertEqual(ScoreboardEntry.user_round_overall_rank(self.user, self.current_round), 1,
"Check user is ranked #1 for the current round.")
user2 = User(username="******", password="******")
user2.save()
profile2 = user2.get_profile()
entry2, created = ScoreboardEntry.objects.get_or_create(
profile=profile2,
round_name=self.current_round,
)
entry2.points = entry.points + 1
entry2.last_awarded_submission = entry.last_awarded_submission
entry2.save()
self.assertEqual(ScoreboardEntry.user_round_overall_rank(self.user, self.current_round), 2,
"Check user is now second.")
def testUserOverallRoundRankWithSubmissionDate(self):
"""Tests that the overall rank calculation for a user in a round is correct based on submission date."""
profile = self.user.get_profile()
top_entry = ScoreboardEntry.objects.filter(round_name=self.current_round).order_by("-points")[0]
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
entry.points = top_entry.points + 1
entry.last_awarded_submission = datetime.datetime.today() - datetime.timedelta(days=3)
entry.save()
self.assertEqual(ScoreboardEntry.user_round_overall_rank(self.user, self.current_round), 1,
"Check user is ranked #1 for the current round.")
user2 = User(username="******", password="******")
user2.save()
profile2 = user2.get_profile()
entry2, created = ScoreboardEntry.objects.get_or_create(
profile=profile2,
round_name=self.current_round,
)
entry2.points = entry.points
entry2.last_awarded_submission = datetime.datetime.today()
entry2.save()
self.assertEqual(ScoreboardEntry.user_round_overall_rank(self.user, self.current_round), 2,
"Check user is now second.")
def testUserFloorRoundRankWithPoints(self):
"""Tests that the floor rank calculation for a round is correct based on points."""
# Setup dorm
dorm = Dorm(name="Test dorm")
dorm.save()
floor = Floor(number="A", dorm=dorm)
floor.save()
profile = self.user.get_profile()
profile.floor = floor
profile.save()
# Set up entry
top_entry = ScoreboardEntry.objects.filter(round_name=self.current_round).order_by("-points")[0]
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
entry.points = top_entry.points + 1
entry.last_awarded_submission = datetime.datetime.today()
entry.save()
self.assertEqual(ScoreboardEntry.user_round_floor_rank(self.user, self.current_round), 1,
"Check user is ranked #1 for the current round.")
user2 = User(username="******", password="******")
user2.save()
profile2 = user2.get_profile()
profile2.floor = floor
profile2.save()
entry2, created = ScoreboardEntry.objects.get_or_create(
profile=profile2,
round_name=self.current_round,
)
entry2.points = entry.points + 1
entry2.last_awarded_submission = entry.last_awarded_submission
entry2.save()
self.assertEqual(ScoreboardEntry.user_round_floor_rank(self.user, self.current_round), 2,
"Check user is now second.")
def testUserFloorRoundRankWithSubmissionDate(self):
"""Tests that the floor rank calculation for a round is correct based on points."""
# Set up dorm
dorm = Dorm(name="Test dorm")
dorm.save()
floor = Floor(number="A", dorm=dorm)
floor.save()
# Create the entry for the test user
profile = self.user.get_profile()
profile.floor = floor
profile.save()
top_entry = ScoreboardEntry.objects.filter(round_name=self.current_round).order_by("-points")[0]
entry, created = ScoreboardEntry.objects.get_or_create(
profile=self.user.get_profile(),
round_name=self.current_round,
)
entry.points = top_entry.points + 1
entry.last_awarded_submission = datetime.datetime.today() - datetime.timedelta(days=3)
entry.save()
# Create another test user
user2 = User(username="******", password="******")
user2.save()
profile2 = user2.get_profile()
profile2.floor = floor
profile2.save()
entry2, created = ScoreboardEntry.objects.get_or_create(
profile=profile2,
round_name=self.current_round,
)
entry2.points = entry.points
entry2.last_awarded_submission = datetime.datetime.today()
entry2.save()
self.assertEqual(ScoreboardEntry.user_round_floor_rank(self.user, self.current_round), 2,
"Check user is now second.")
def testRoundRankWithoutEntry(self):
"""Tests that the overall rank calculation is correct even if a user has not done anything yet."""
dorm = Dorm(name="Test dorm")
dorm.save()
floor = Floor(number="A", dorm=dorm)
floor.save()
profile = self.user.get_profile()
# Rank will be the number of users who have points plus one.
overall_rank = Profile.objects.filter(points__gt=0).count() + 1
floor_rank = Profile.objects.filter(points__gt=0, floor=floor).count() + 1
self.assertEqual(ScoreboardEntry.user_round_overall_rank(self.user, self.current_round), overall_rank,
"Check user is last overallfor the current round.")
self.assertEqual(ScoreboardEntry.user_round_floor_rank(self.user, self.current_round), floor_rank,
"Check user is last in their floor for the current round.")
user2 = User(username="******", password="******")
user2.save()
profile2 = user2.get_profile()
entry2, created = ScoreboardEntry.objects.get_or_create(
profile=profile2,
round_name=self.current_round,
)
entry2.points = 10
entry2.last_awarded_submission = datetime.datetime.today()
entry2.floor = floor
entry2.save()
self.assertEqual(ScoreboardEntry.user_round_overall_rank(self.user, self.current_round), overall_rank + 1,
"Check that the user's overall rank has moved down.")
self.assertEqual(ScoreboardEntry.user_round_floor_rank(self.user, self.current_round), floor_rank + 1,
"Check that the user's floor rank has moved down.")
def tearDown(self):
"""Restore the saved settings."""
settings.COMPETITION_ROUNDS = self.saved_rounds
def testAwardRollback(self):
"""Tests that the last_awarded_submission field rolls back to a previous task."""
user = User(username="******", password="******")
user.save()
activity1 = Activity(
title="Test activity",
slug="test-activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity1.save()
activity2 = Activity(
title="Test activity 2",
slug="test-activity-2",
description="Testing!",
duration=10,
point_value=15,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity2.save()
activities = [activity1, activity2]
# Submit the first activity. This is what we're going to rollback to.
activity_member = ActivityMember(
user=user,
activity=activities[0],
submission_date=datetime.datetime.today())
activity_member.approval_status = "approved"
activity_member.submission_date = datetime.datetime.today(
) - datetime.timedelta(days=1)
activity_member.save()
points = user.get_profile().points
submit_date = user.get_profile().last_awarded_submission
# Submit second activity.
activity_member = ActivityMember(
user=user,
activity=activities[1],
submission_date=datetime.datetime.today())
activity_member.approval_status = "approved"
activity_member.submission_date = datetime.datetime.today()
activity_member.save()
logs = user.pointstransaction_set.count()
activity_member.approval_status = "rejected"
activity_member.submission_date = datetime.datetime.today()
activity_member.save()
# Verify that we rolled back to the previous activity.
self.assertEqual(points, user.get_profile().points)
def testActivityAchievement(self):
"""Check that the user's activity achievements are loaded."""
activity = Activity(
title="Test activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
# Test that profile page has a pending activity.
member = ActivityMember(user=self.user, activity=activity, approval_status="pending")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.id,)))
self.assertContains(response, "Pending")
self.assertContains(response, "Activity:")
self.assertContains(response, "You have not been awarded anything yet!")
self.assertNotContains(response, "You have nothing in progress or pending.")
# Test that the profile page has a rejected activity
member.approval_status = "rejected"
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.id,)))
self.assertContains(response, "Rejected")
self.assertContains(response, "You have not been awarded anything yet!")
self.assertNotContains(response, "You have nothing in progress or pending.")
# Use the argument and check that the context has a rejected member.
response = self.client.get(reverse("profile_rejected", args=(member.id,)), follow=True)
self.assertEqual(response.context["rejected_member"], member)
# Test that the profile page has a completed activity
member.approval_status = "approved"
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.id,)))
self.assertNotContains(response, "You have not been awarded anything yet!")
self.assertContains(response, "You have nothing in progress or pending.")
self.assertContains(response, "Activity:")
# Test adding an event to catch a bug.
event = Activity(
title="Test event",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="event",
)
event.save()
member = ActivityMember(user=self.user, activity=event, approval_status="pending")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(activity.id,)))
self.assertContains(response, "Pending")
self.assertContains(response, "Activity:")
self.assertContains(response, "Event:")
self.assertNotContains(response, "You have nothing in progress or pending.")
