Esempio n. 1
0
 def test_vacuum(self, mockNow, mockRandom, mockKeybaseSend):
     self.reminder_test("remind me to foo tomorrow", "foo",
                        "on Monday at 9:02 PM",
                        "on Monday April 9 2018 at 9:02 PM",
                        datetime.timedelta(days=1), mockNow,
                        mockKeybaseSend)
     rows = bot.vacuum_old_reminders(self.config)
     assert rows == 0
     self.reminder_test("remind me to foo tomorrow", "foo",
                        "on Tuesday at 9:02 PM",
                        "on Tuesday April 10 2018 at 9:02 PM",
                        datetime.timedelta(days=1), mockNow,
                        mockKeybaseSend)
     rows = bot.vacuum_old_reminders(self.config)
     assert rows == 1
     self.message_test("snooze for 12 minutes",
                       "Ok. I'll remind you again in 12 minutes.",
                       mockKeybaseSend)
     rows = bot.vacuum_old_reminders(self.config)
     assert rows == 0
     mockNow.return_value = mockNow.return_value + datetime.timedelta(
         minutes=15)
     bot.send_reminders(self.config)
     rows = bot.vacuum_old_reminders(self.config)
     assert rows == 0
     self.message_test(
         "remind me to foo tomorrow",
         "Ok! I'll remind you to foo on Wednesday at 9:17 PM",
         mockKeybaseSend)
     rows = bot.vacuum_old_reminders(self.config)
     assert rows == 1
Esempio n. 2
0
 def test_undo(self, mockNow, mockRandom, mockKeybaseSend):
     self.message_test("remind me to foo tomorrow",
                       "Ok! I'll remind you to foo on Monday at 9:02 PM",
                       mockKeybaseSend)
     self.message_test("nevermind", bot.OK, mockKeybaseSend)
     mockNow.return_value = NOW_UTC + datetime.timedelta(days=1)
     bot.send_reminders(self.config)
     mockKeybaseSend.assert_called_with(TEST_CONV_ID,
                                        bot.OK)  # no reminder sent
Esempio n. 3
0
    def test_repeating_weekday(self, mockNow, mockRandom, mockKeybaseSend):
        self.reminder_test("remind me every weekday at 6pm to eat a quiche",
                           "eat a quiche", "every weekday at 6:00 PM",
                           "every weekday at 6:00 PM",
                           datetime.timedelta(days=1), mockNow,
                           mockKeybaseSend)
        list_output = "Here are your upcoming reminders:\n\n1. eat a quiche - every weekday at 6:00 PM\n"
        self.message_test("list", list_output, mockKeybaseSend)
        # 4 weekdays
        for i in range(4):
            mockNow.return_value = mockNow.return_value + datetime.timedelta(
                days=1)
            bot.send_reminders(self.config)
            mockKeybaseSend.assert_called_with(
                TEST_CONV_ID, ":bell: *Reminder:* eat a quiche")

        # saturday
        mockKeybaseSend.reset_mock()
        mockNow.return_value = mockNow.return_value + datetime.timedelta(
            days=1)
        bot.send_reminders(self.config)
        assert not mockKeybaseSend.called

        # sunday
        mockNow.return_value = mockNow.return_value + datetime.timedelta(
            days=1)
        bot.send_reminders(self.config)
        assert not mockKeybaseSend.called

        # monday
        mockNow.return_value = mockNow.return_value + datetime.timedelta(
            days=1)
        bot.send_reminders(self.config)
        mockKeybaseSend.assert_called_with(TEST_CONV_ID,
                                           ":bell: *Reminder:* eat a quiche")
Esempio n. 4
0
    def reminder_test(self, text, reminder, whentext, fullwhen, timedelta,
                      mockNow, mockKeybaseSend):
        self.message_test(
            text, "Ok! I'll remind you to " + reminder + " " + whentext,
            mockKeybaseSend)
        mockKeybaseSend.assert_any_call(TEST_CONV_ID, bot.ASSUME_TZ)

        self.message_test(
            "list", "Here are your upcoming reminders:\n\n"
            "1. " + reminder + " - " + fullwhen + "\n", mockKeybaseSend)

        mockNow.return_value = mockNow.return_value + timedelta
        bot.send_reminders(self.config)
        mockKeybaseSend.assert_called_with(TEST_CONV_ID,
                                           ":bell: *Reminder:* " + reminder)
Esempio n. 5
0
    def test_repeating_sunday(self, mockNow, mockRandom, mockKeybaseSend):
        self.reminder_test("Remind me every Sunday at 11am to water the plant",
                           "water the plant",
                           "every week on Sunday at 11:00 AM",
                           "every week on Sunday at 11:00 AM",
                           datetime.timedelta(days=7), mockNow,
                           mockKeybaseSend)
        list_output = "Here are your upcoming reminders:\n\n1. water the plant - every week on Sunday at 11:00 AM\n"
        self.message_test("list", list_output, mockKeybaseSend)

        # 1 more day
        mockKeybaseSend.reset_mock()
        mockNow.return_value = mockNow.return_value + datetime.timedelta(
            days=1)
        bot.send_reminders(self.config)
        assert not mockKeybaseSend.called
Esempio n. 6
0
    def test_set_reminder_separate_when(self, mockNow, mockRandom,
                                        mockKeybaseSend):

        self.message_test("Remind me to say hello", bot.WHEN, mockKeybaseSend)
        mockKeybaseSend.assert_any_call(TEST_CONV_ID, bot.ASSUME_TZ)
        self.message_test("10pm",
                          "Ok! I'll remind you to say hello at 10:00 PM",
                          mockKeybaseSend)
        self.message_test(
            "List", "Here are your upcoming reminders:\n\n"
            "1. say hello - on Sunday April 8 2018 at 10:00 PM\n",
            mockKeybaseSend)

        mockNow.return_value = NOW_UTC + datetime.timedelta(hours=1)
        bot.send_reminders(self.config)
        mockKeybaseSend.assert_called_with(TEST_CONV_ID,
                                           ":bell: *Reminder:* say hello")
Esempio n. 7
0
 def snooze_test(self, mockNow, mockKeybaseSend, phrase, echo, duration):
     reminder = "get groceries"
     self.reminder_test("remind me to get groceries tomorrow at 8am",
                        reminder, "at 8:00 AM",
                        "on Monday April 9 2018 at 8:00 AM",
                        datetime.timedelta(days=1), mockNow,
                        mockKeybaseSend)
     mockKeybaseSend.reset_mock()
     self.message_test(phrase, echo, mockKeybaseSend)
     mockKeybaseSend.reset_mock()
     mockNow.return_value = mockNow.return_value + duration - datetime.timedelta(
         minutes=1)
     bot.send_reminders(self.config)
     assert not mockKeybaseSend.called
     mockNow.return_value = mockNow.return_value + duration + datetime.timedelta(
         minutes=1)
     bot.send_reminders(self.config)
     mockKeybaseSend.assert_called_with(TEST_CONV_ID,
                                        ":bell: *Reminder:* " + reminder)
Esempio n. 8
0
    def test_repeating_snooze(self, mockNow, mockRandom, mockKeybaseSend):
        self.reminder_test("remind me every tuesday 8am to eat a quiche",
                           "eat a quiche", "every week on Tuesday at 8:00 AM",
                           "every week on Tuesday at 8:00 AM",
                           datetime.timedelta(days=2), mockNow,
                           mockKeybaseSend)
        self.send_message("snooze for 20 minutes", mockKeybaseSend)

        # snoozed message shows up
        list_output = "Here are your upcoming reminders:\n\n" \
            "1. eat a quiche - on Tuesday April 10 2018 at 9:22 PM\n" \
            "2. eat a quiche - every week on Tuesday at 8:00 AM\n"
        self.message_test("list", list_output, mockKeybaseSend)

        # and the message was snoozed
        mockNow.return_value = mockNow.return_value + datetime.timedelta(
            minutes=21)
        bot.send_reminders(self.config)
        mockKeybaseSend.assert_called_with(TEST_CONV_ID,
                                           ":bell: *Reminder:* eat a quiche")

        # and the repetition still happens
        list_output = "Here are your upcoming reminders:\n\n1. eat a quiche - every week on Tuesday at 8:00 AM\n"
        self.message_test("list", list_output, mockKeybaseSend)