def test_handle_my_plans_only_in_rsvps(
mock_send_reply,
mock_user,
make_handler_params,
make_time,
):
"""
Checks that the user only appears in plans they have RSVP'd to.
"""
params = make_handler_params("my-plans")
plan1 = Plan("tjs", make_time(11, 00), [])
plan2 = Plan("tjs", make_time(12, 30), [mock_user])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_my_plans(params)
mock_send_reply.assert_called_with(
params.client,
params.message,
"Here are the lunches you've RSVP'd to:\ntjs @ 12:30pm, 1 RSVP",
)
def test_handle_rsvp_success(
mock_send_reply,
mock_user,
make_handler_params,
make_time,
):
"""
Ensures that handle_rsvp functions correctly when the preconditions are
met.
"""
params = make_handler_params("rsvp tjs")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_rsvp(params)
params.storage.put.assert_called_with(
params.storage.PLANS_ENTRY,
{plan.uuid: Plan("tjs", make_time(12, 30), [mock_user])},
)
mock_send_reply.assert_called_with(
params.client,
params.message,
"Thanks for RSVPing to lunch at tjs! Enjoy your food, Test Sender!",
)
def test_handle_un_rsvp_ambiguous(
mock_send_reply, make_handler_params, make_time,
):
"""
Ensures that, when the user has provided an ambiguous query, handle_un_rsvp
prompts them to disambiguate.
"""
params = make_handler_params("un-rsvp tjs")
plan1 = Plan("tjs", make_time(11, 00), [])
plan2 = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_un_rsvp(params)
params.storage.put.assert_not_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"""There are multiple lunches with that lunch_id. Please reissue the command with the time of the lunch you're interested in:
tjs @ 11:00am
tjs @ 12:30pm""",
)
def test_handle_delete_plan_ambiguous(
mock_send_reply, make_handler_params, make_time,
):
"""
Tests that when there are multiple plans with the same name, delete_plan
prompts the user to disambiguate a lunch.
"""
params = make_handler_params("delete-plan tjs")
plan1 = Plan("tjs", make_time(11, 00), [])
plan2 = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_delete_plan(params)
mock_send_reply.assert_called_with(
params.client,
params.message,
"There are multiple lunches with that lunch_id. Please reissue the command with the time of the lunch you're"
" interested in:\n"
"tjs @ 11:00am\n"
"tjs @ 12:30pm",
)
def test_handle_rsvp_disambiguate(
mock_send_reply,
mock_user,
make_handler_params,
make_time,
):
"""
Ensures that, when there are multiple lunches, the user can construct a
query to disambiguate between them.
"""
params = make_handler_params("rsvp tjs 12:30")
plan1 = Plan("tjs", make_time(11, 00), [])
plan2 = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_rsvp(params)
params.storage.put.assert_called_with(
params.storage.PLANS_ENTRY,
{
plan1.uuid: plan1,
plan2.uuid: Plan("tjs", make_time(12, 30), [mock_user])
},
)
mock_send_reply.assert_called_with(
params.client,
params.message,
"Thanks for RSVPing to lunch at tjs! Enjoy your food, Test Sender!",
)
def test_alert_leaving_ambiguous(mock_send_reply, make_handler_params,
make_time):
"""
Ensures that, when there are multiple plans, and the user has addressed them
ambiguously, handle_alert_leaving fails as expected.
"""
params = make_handler_params("alert-leaving tjs")
plan1 = Plan("tjs", make_time(11, 0), [])
plan2 = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_alert_leaving(params)
mock_send_reply.assert_called_with(
params.client,
params.message,
"There are multiple lunches with that lunch_id. Please reissue the"
" command with the time of the lunch you're interested in:\n"
"tjs @ 11:00am\n"
"tjs @ 12:30pm",
)
def test_handle_un_rsvp_disambiguate(
mock_send_reply, mock_user, make_handler_params, make_time,
):
"""
Ensures that, when the user has provided an ambiguous query, handle_un_rsvp
prompts them to disambiguate.
"""
params = make_handler_params("un-rsvp tjs 12:30")
plan1 = Plan("tjs", make_time(11, 00), [])
plan2 = Plan("tjs", make_time(12, 30), [mock_user])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_un_rsvp(params)
params.storage.put.assert_called_with(
params.storage.PLANS_ENTRY,
{plan1.uuid: plan1, plan2.uuid: Plan("tjs", make_time(12, 30), []),},
)
mock_send_reply.assert_called_with(
params.client, params.message, "You've successful un-RSVP'd to lunch at tjs."
)
def test_handle_delete_plan_disambiguate(
mock_send_reply, make_handler_params, make_time,
):
"""
Tests that when there are multiple plans with the same name, delete_plan
lets the user disambiguate with a time.
"""
params = make_handler_params("delete-plan tjs 12:30")
plan1 = Plan("tjs", make_time(11, 00), [])
plan2 = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_delete_plan(params)
params.storage.put.assert_called_with(
params.storage.PLANS_ENTRY, {plan1.uuid: plan1}
)
params.cron.remove_event.assert_called_with(plan2.uuid)
mock_send_reply.assert_called_with(
params.client,
params.message,
"You've successfully deleted lunch tjs @ 12:30pm.",
)
def test_handle_make_plan_success(
mocker, mock_send_reply, mock_user, make_handler_params, make_time,
):
"""
Ensures that make_plan correctly inserts a plan when the arguments are
correct.
"""
params = make_handler_params("make-plans tjs 12:30")
mocker.patch("uuid.uuid4", return_value="test_uuid")
params.storage.get.return_value = {}
handle_make_plan(params)
params.storage.put.assert_called_with(
params.storage.PLANS_ENTRY,
{"test_uuid": Plan("tjs", make_time(12, 30), [mock_user])},
)
params.cron.add_event.assert_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"I have added your plan! Enjoy lunch, Test Sender!",
)
def test_handle_un_rsvp_success(
mock_send_reply, mock_user, make_handler_params, make_time,
):
"""
Ensures that handle_un_rsvp succeeds when the required preconditions are
met.
"""
params = make_handler_params("un-rsvp tjs")
plan = Plan("tjs", make_time(12, 30), [mock_user])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_un_rsvp(params)
params.storage.put_assert_called_with(
params.storage.PLANS_ENTRY, Plan("tjs", make_time(12, 30), [])
)
mock_send_reply.assert_called_with(
params.client, params.message, "You've successful un-RSVP'd to lunch at tjs."
)
def test_alert_leaving_disambiguate(mock_user, make_handler_params, make_time):
"""
Ensures that, when there are multiple plans, but the user has addressed a
specific plan, handle_alert_leaving succeeds.
"""
params = make_handler_params("alert-leaving tjs 12:30pm")
plan1 = Plan("tjs", make_time(11, 0), [])
plan2 = Plan("tjs", make_time(12, 30), [mock_user, mock_user])
params.storage.get.return_value = {
plan1.uuid: plan1,
plan2.uuid: plan2,
}
handle_alert_leaving(params)
params.client.send_message.assert_called_with({
"type":
"private",
"to": ["*****@*****.**", "*****@*****.**"],
"content":
"Heads up! You're going to tjs in 2:30:00",
})
def test_handle_delete_plan_success(
mock_send_reply, make_handler_params, make_time,
):
params = make_handler_params("delete-plan tjs")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {plan.uuid: plan}
handle_delete_plan(params)
params.storage.put.assert_called_with(params.storage.PLANS_ENTRY, {})
params.cron.remove_event.assert_called_with(plan.uuid)
mock_send_reply.assert_called_with(
params.client,
params.message,
"You've successfully deleted lunch tjs @ 12:30pm.",
)
def test_handle_show_plans_success(
mock_send_reply, make_handler_params, make_time,
):
"""
Ensures that, if there are plans, handle_show_plans shows the user all of
the plans.
"""
params = make_handler_params("show-plans")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_show_plans(params)
mock_send_reply.assert_called_with(
params.client, params.message, "tjs @ 12:30pm, 0 RSVPs"
)
def test_handle_delete_plan_bad_id(
mock_send_reply, make_handler_params, make_time,
):
"""
Ensures that handle_delete_plan functions correctly when the user provides
an integer ID that does not correspond to a plan.
"""
params = make_handler_params("delete-plan not-tjs")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {plan.uuid: plan}
handle_delete_plan(params)
mock_send_reply.assert_called_with(
params.client,
params.message,
"That lunch_id doesn't exist! Type show-plans to see each lunch_id and its associated lunch plan.",
)
def test_handle_make_plan_existing_plan(
mock_send_reply, make_handler_params, make_time,
):
"""
Ensures that, when there is already an existing plan with the intended name,
we prevent the user from making another one.
"""
params = make_handler_params("make-plan tjs 12:30")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {plan.uuid: plan}
handle_make_plan(params)
params.storage.put.assert_not_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"Sorry, there is already a plan with that name and time. How about you RSVP instead?",
)
def test_alert_leaving_bad_id(mock_send_reply, make_handler_params, make_time):
"""
Ensures that, when there is a plan but not with the ID the user has
provided, handle_alert_leaving fails as expected.
"""
params = make_handler_params("alert-leaving not-tjs")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_alert_leaving(params)
mock_send_reply.assert_called_with(
params.client,
params.message,
"That lunch_id doesn't exist! Type show-plans to see each lunch_id and"
" its associated lunch plan.",
)
def test_alert_leaving_success(mock_user, make_handler_params, make_time):
"""
Ensures that, when all the preconditions have been met, handle_alert_leaving
succeeds.
"""
params = make_handler_params("alert-leaving tjs")
plan = Plan("tjs", make_time(12, 30), [mock_user, mock_user, mock_user])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_alert_leaving(params)
params.client.send_message.assert_called_with({
"type":
"private",
"to": ["*****@*****.**", "*****@*****.**", "*****@*****.**"],
"content":
"Heads up! You're going to tjs in 2:30:00",
})
def test_handle_un_rsvp_not_rsvpd(
mock_send_reply, make_handler_params, make_time,
):
"""
Ensures that handle_un_rsvp fails as expected when the user is not already
RSVP'd to the event.
"""
params = make_handler_params("un-rsvp tjs")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_un_rsvp(params)
params.storage.put.assert_not_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"Oops! It looks like you haven't RSVP'd to this lunch_id!",
)
def test_handle_rsvp_bad_id(
mock_send_reply,
make_handler_params,
make_time,
):
"""
Ensures that handle_rsvp failes correctly when the plan ID is not malformed
but does not correspond to a plan.
"""
params = make_handler_params("rsvp not-tjs")
plan = Plan("tjs", make_time(12, 30), [])
params.storage.get.return_value = {plan.uuid: plan}
handle_rsvp(params)
params.storage.put.assert_not_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"That lunch_id doesn't exist! Type show-plans to see each lunch_id and its associated lunch plan.",
)
def test_handle_un_rsvp_bad_id(
mock_send_reply, mock_user, make_handler_params, make_time,
):
"""
Ensures that handle_un_rsvp fails as expected when the user provides an id
that is out of range of our available lunches.
"""
params = make_handler_params("un-rsvp not-tjs")
plan = Plan("tjs", make_time(12, 30), [mock_user])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_un_rsvp(params)
params.storage.put.assert_not_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"That lunch_id doesn't exist! Type show-plans to see each lunch_id and its associated lunch plan.",
)
def test_handle_rsvp_already_rsvpd(
mock_send_reply,
mock_user,
make_handler_params,
make_time,
):
"""
Ensures handle_rsvp fails correctly when the user is already RSVP'd to the
event to which they're trying to rsvp.
"""
params = make_handler_params("rsvp tjs")
plan = Plan("tjs", make_time(12, 30), [mock_user])
params.storage.get.return_value = {plan.uuid: plan}
handle_rsvp(params)
params.storage.put.assert_not_called()
mock_send_reply.assert_called_with(
params.client,
params.message,
"You've already RSVP'd to this lunch_id! Type my-plans to show all of your current lunch plans.",
)
def test_handle_my_plans_success(
mock_send_reply,
mock_user,
make_handler_params,
make_time,
):
"""
Checks that, when the user has a plan, the correct list is shown.
"""
params = make_handler_params("my-plans")
plan = Plan("tjs", make_time(12, 30), [mock_user])
params.storage.get.return_value = {
plan.uuid: plan,
}
handle_my_plans(params)
mock_send_reply.assert_called_with(
params.client,
params.message,
"Here are the lunches you've RSVP'd to:\ntjs @ 12:30pm, 1 RSVP",
)
def handle_make_plan(params: HandlerParams):
if len(params.args) != 3:
common.send_reply(
params.client,
params.message,
"Oops! The make-plan command requires more information. Type help for formatting instructions.",
)
return
try:
plan_time = common.parse_time(params.args[2])
except ValueError:
common.send_reply(
params.client,
params.message,
"Sorry, the time you entered could not be used because it is not a valid date format.",
)
return
now = common.get_now()
if plan_time < now:
common.send_reply(
params.client,
params.message,
"Sorry, you can't plan for a lunch before the current time.",
)
return
if not params.storage.contains(params.storage.PLANS_ENTRY):
params.storage.put(params.storage.PLANS_ENTRY, {})
plans = params.storage.get(params.storage.PLANS_ENTRY)
for _, plan in plans.items():
if plan.restaurant == params.args[1] and plan.time == plan_time:
common.send_reply(
params.client,
params.message,
"Sorry, there is already a plan with that name and time. How about you RSVP instead?",
)
return
user = User.get_sender(params.message)
plan = Plan(params.args[1], plan_time, [user])
plans = params.storage.get(params.storage.PLANS_ENTRY)
plans[plan.uuid] = plan
params.storage.put(params.storage.PLANS_ENTRY, plans)
common.send_reply(
params.client,
params.message,
"I have added your plan! Enjoy lunch, {}!".format(user.full_name),
)
params.cron.add_event(
(plan.time - timedelta(minutes=15)).timestamp(),
events.AlertLeavingGenerator(plan),
plan.uuid,
)
params.cron.add_event(
plan.time.timestamp(),
events.DeletePlanGenerator(plan),
)