def test_phrase_reordering(self):
		"""
		This is not necessarily a desired feature compared to returning the
		same phrase the user entered, but it works for now.
		"""
		phrase = 'finances: r noon every 3mo Oil change next Tuesday *'
		target_phrase = 'finances: Oil change next Tuesday every 3mo r noon *'
		task = TaskParser(phrase)
		new_phrase = task.phrase_with()

		assert target_phrase == new_phrase
	def test_default_time_today_disabled_offset(self):
		date_component = _today
		now = datetime.now()
		reminder_date = TaskParser.reminder_date_combine(date_component)

		assert reminder_date.date() == date_component
		assert reminder_date.time() == _default_reminder_time
	def test_reminder_implicitly_relative_to_today_no_time(self):
		title = 'a sample task'
		reminder_phrase = 'reminder'
		reminder_date = TaskParser.reminder_date_combine(_today) # Adds 1hr and rounds up to nearest 5m mark
		phrase = '%s %s' % (title, reminder_phrase)
		task = TaskParser(phrase)

		assert_task(task, phrase=phrase, title=title, reminder_date=reminder_date, has_reminder_prompt=True)
Пример #4
0
    def test_list_substring_infix(self):
        target_list = _single_word_list
        title = 'a sample task'
        phrase = '%s: %s' % (target_list[2:5], title)  # nan: a sample task
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #5
0
    def test_default_list_preference_is_default(self):
        target_list = _single_word_list
        title = 'a sample task'
        phrase = title
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #6
0
    def test_infix_list_initials_ignored_if_lowercase(self):
        """
		Fewer than 3 characters should be ignored unless uppercase
		"""
        target_list = _multi_word_list
        title = 'a sample task'
        phrase = '%s in %s' % (title, initials(target_list).lower()
                               )  # a sample task in sl
        task = TaskParser(phrase)

        assert_task(task, phrase=phrase, title=phrase)
Пример #7
0
    def test_list_initials(self):
        target_list = _multi_word_list
        title = 'a sample task'
        phrase = '%s: %s' % (initials(target_list), title)  # SL: a sample task
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #8
0
    def test_list_name_diacritic_exact_match(self):
        target_list = _diacritic_list
        title = 'a sample task'
        phrase = '%s: %s' % (target_list, title)  # Jardinería: a sample task
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #9
0
    def test_reminder_implicitly_relative_to_today(self):
        title = 'a sample task'
        reminder_phrase = 'r noon'
        reminder_date = datetime.combine(_today, time(12, 0, 0))
        phrase = '%s %s' % (title, reminder_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    reminder_date=reminder_date)
Пример #10
0
    def test_inbox_is_default_for_invalid_list_preference(self):
        target_list = _inbox
        title = 'a sample task'
        phrase = title
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #11
0
    def test_infix_list_name_exact_match(self):
        target_list = _single_word_list
        title = 'a sample task'
        phrase = '%s in %s' % (title, target_list)  # a sample task in Finances
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #12
0
    def test_inbox_is_default_before_syncing_lists(self):
        target_list = _inbox
        title = 'a sample task'
        phrase = title
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #13
0
    def test_reminder_explicit_date(self):
        title = 'a sample task'
        reminder_phrase = 'remind me at dinner on Dec 13, 2014'
        reminder_date = datetime.combine(_12_13_14, time(19, 0, 0))
        phrase = '%s %s' % (title, reminder_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    reminder_date=reminder_date)
Пример #14
0
    def test_due_date_prompt_with_star_whitespace(self):
        title = 'a sample task'
        due_phrase = 'due'
        phrase = '%s %s *' % (title, due_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    has_due_date_prompt=True,
                    starred=True)
Пример #15
0
    def test_infix_list_initials(self):
        target_list = _multi_word_list
        title = 'a sample task'
        phrase = '%s in list %s' % (title, initials(target_list)
                                    )  # a sample task in list SL
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #16
0
    def test_list_name_diacritic_insensitive_match(self):
        target_list = _diacritic_list
        title = 'a sample task'
        phrase = '%s: %s' % (_diacritic_list_insensitive, title
                             )  # Jardineria: a sample task (no accent)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
Пример #17
0
    def test_hashtag_prompt_following_list(self):
        target_list = _single_word_list
        title = '#'
        phrase = '%s:%s' % (target_list, title)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list),
                    has_hashtag_prompt=True)
Пример #18
0
    def test_list_name_case_insensitive_match(self):
        target_list = _single_word_list
        title = 'a sample task'
        phrase = '%s: %s' % (target_list.upper(), title
                             )  # FINANCES: a sample task
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    list_title=target_list,
                    list_id=_lists.index(target_list))
	def test_default_time_today_custom_offset(self):
		date_component = _today
		now = datetime.now()
		reminder_date = TaskParser.reminder_date_combine(date_component)

		assert reminder_date.date() == date_component
		assert reminder_date.microsecond == 0
		assert reminder_date.second == 0
		assert reminder_date.minute % 5 == 0
		assert reminder_date.hour == (now + timedelta(hours=2)).hour

		# Rounded up to the nearest 5 minute mark
		assert reminder_date.minute == (now + timedelta(minutes=(5 - now.minute % 5) % 5)).minute
Пример #20
0
    def test_due_date_with_time_overrides_automatic_reminder(self):
        title = 'a sample task'
        due_date = _tomorrow
        due_phrase = 'due 8:00 tomorrow'
        reminder_date = datetime.combine(due_date, time(8, 0, 0))
        phrase = '%s %s' % (title, due_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #21
0
    def test_automatic_reminder_with_due_date(self):
        title = 'a sample task'
        due_date = _tomorrow
        due_phrase = 'due tomorrow'
        reminder_date = datetime.combine(due_date, _default_reminder_time)
        phrase = '%s %s' % (title, due_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #22
0
    def test_reminder_with_time_implicitly_due_today(self):
        title = 'a sample task'
        reminder_phrase = 'at noon'
        reminder_date = datetime.combine(_today, _noon)
        due_date = _today
        phrase = '%s %s' % (title, reminder_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #23
0
    def test_due_date_with_time_sets_reminder(self):
        title = 'a sample task'
        due_phrase = 'due 12/13/14 at noon'
        due_date = _12_13_14
        reminder_date = datetime.combine(due_date, _noon)
        phrase = '%s %s' % (title, due_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #24
0
    def test_time_only_due_today_with_reminder_no_keyword(self):
        title = 'a sample task'
        due_phrase = 'at noon'
        due_date = _today
        reminder_date = datetime.combine(_today, _noon)
        phrase = '%s %s' % (title, due_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #25
0
    def test_explicit_reminder_overrides_due_date_with_time(self):
        title = 'a sample task'
        due_date = _tomorrow
        due_phrase = 'due tomorrow at noon'
        reminder_phrase = 'alarm at 8:00a'
        reminder_date = datetime.combine(due_date, time(8, 0, 0))
        phrase = '%s %s %s' % (title, due_phrase, reminder_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #26
0
    def test_reminder_implicitly_relative_to_due_date(self):
        title = 'a sample task'
        due_date = _tomorrow
        due_phrase = 'due tomorrow'
        reminder_phrase = 'alarm at 8:00a'
        reminder_date = datetime.combine(due_date, time(8, 0, 0))
        phrase = '%s %s %s' % (title, due_phrase, reminder_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date)
Пример #27
0
    def test_default_time_today_custom_offset(self):
        date_component = _today
        now = datetime.now()
        reminder_date = TaskParser.reminder_date_combine(date_component)

        assert reminder_date.date() == date_component
        assert reminder_date.microsecond == 0
        assert reminder_date.second == 0
        assert reminder_date.minute % 5 == 0
        assert reminder_date.hour == (
            now + timedelta(hours=2, minutes=(5 - now.minute % 5) % 5)).hour

        # Rounded up to the nearest 5 minute mark
        assert reminder_date.minute == (
            now + timedelta(minutes=(5 - now.minute % 5) % 5)).minute
Пример #28
0
    def test_reminder_implicitly_relative_to_due_date_no_time(self):
        title = 'a sample task'
        due_date = _tomorrow
        due_phrase = 'due tomorrow'
        reminder_phrase = 'r'
        reminder_date = datetime.combine(due_date, _default_reminder_time)
        phrase = '%s %s %s' % (title, due_phrase, reminder_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    due_date=due_date,
                    reminder_date=reminder_date,
                    has_reminder_prompt=True)
Пример #29
0
    def test_recurrence_with_explicit_weekday(self):
        title = 'a sample task'
        recurrence_count = 1
        due_date = _monday
        recurrence_type = 'week'
        recurrence_phrase = 'every Monday'
        phrase = '%s %s' % (title, recurrence_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    recurrence_type=recurrence_type,
                    recurrence_count=recurrence_count,
                    due_date=due_date)
Пример #30
0
    def test_recurrence_with_explicit_date(self):
        title = 'a sample task'
        recurrence_count = 1
        due_date = date(_today.year, 12, 31)
        recurrence_type = 'year'
        recurrence_phrase = 'every December 31'
        phrase = '%s %s' % (title, recurrence_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    recurrence_type=recurrence_type,
                    recurrence_count=recurrence_count,
                    due_date=due_date)
Пример #31
0
    def test_due_next_year(self):
        """
		The "next" word was not understood by parsedatetime.nlp() in an
		earlier version and the implementation in the workflow was incorrect;
		rather than the same date one year from now, "next year" means Jan 1
		of the following year.
		"""
        today = date.today()
        title = 'a sample task'
        due_phrase = 'due next year'
        due_date = date(year=today.year + 1, month=1, day=1)
        phrase = '%s %s' % (title, due_phrase)
        task = TaskParser(phrase)

        assert_task(task, phrase=phrase, title=title, due_date=due_date)
Пример #32
0
    def test_recurrence_implicitly_due_today(self):
        title = 'a sample task'
        recurrence_type = 'month'
        recurrence_count = 1
        recurrence_phrase = 'every ' + recurrence_type
        due_date = date.today()
        phrase = '%s %s' % (title, recurrence_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    recurrence_type=recurrence_type,
                    recurrence_count=recurrence_count,
                    due_date=due_date)
Пример #33
0
    def test_case_insensitive_recurrence_types(self):
        (due_phrase, due_date) = due_date_formats.items()[0]
        title = 'a sample task'
        recurrence_count = 2
        recurrence_type = 'year'
        recurrence_phrase = 'REpeat EVerY %d %sS' % (recurrence_count,
                                                     recurrence_type.upper())
        phrase = '%s %s %s' % (title, due_phrase, recurrence_phrase)
        task = TaskParser(phrase)

        assert_task(task,
                    phrase=phrase,
                    title=title,
                    recurrence_type=recurrence_type,
                    recurrence_count=recurrence_count,
                    due_date=due_date)
Пример #34
0
    def test_recurrence_types(self):
        recurrence_count = 1
        (due_phrase, due_date) = due_date_formats.items()[0]
        for (recurrence_phrase,
             recurrence_type) in recurrence_types.iteritems():
            title = 'a sample task'
            recurrence_phrase = 'every ' + recurrence_phrase
            phrase = '%s %s due %s' % (title, recurrence_phrase, due_phrase)
            task = TaskParser(phrase)

            assert_task(task,
                        phrase=phrase,
                        title=title,
                        recurrence_type=recurrence_type,
                        recurrence_count=recurrence_count,
                        due_date=due_date)
	def test_date_and_time(self):
		date_component = _12_13_14
		time_component = _noon
		reminder_date = TaskParser.reminder_date_combine(date_component, time_component)

		assert reminder_date == datetime.combine(date_component, time_component)
	def test_default_time_not_today(self):
		date_component = _tomorrow
		reminder_date = TaskParser.reminder_date_combine(date_component)

		assert reminder_date == datetime.combine(date_component, _default_reminder_time)
class TestPhrases():

	task = None
	title = 'a sample task'

	@pytest.fixture(autouse=True)
	def setup_task(self):
		phrase = self.title
		self.task = TaskParser(phrase)

	def test_simple_unchanged_phrase(self):
		phrase = self.task.phrase
		new_phrase = self.task.phrase_with()

		assert phrase == new_phrase

	def test_complex_unchanged_phrase(self):
		phrase = 'fin: Oil change next Tuesday at noon repeat every 3mo *'
		task = TaskParser(phrase)
		new_phrase = task.phrase_with()

		assert phrase == new_phrase

	def test_phrase_reordering(self):
		"""
		This is not necessarily a desired feature compared to returning the
		same phrase the user entered, but it works for now.
		"""
		phrase = 'finances: r noon every 3mo Oil change next Tuesday *'
		target_phrase = 'finances: Oil change next Tuesday every 3mo r noon *'
		task = TaskParser(phrase)
		new_phrase = task.phrase_with()

		assert target_phrase == new_phrase

	def test_change_title(self):
		new_title = 'new title'
		new_phrase = self.task.phrase_with(title=new_title)

		assert new_phrase == '%s' % (new_title)

	def test_change_list_title(self):
		new_list_title = 'new title'
		new_phrase = self.task.phrase_with(list_title=new_list_title)

		assert new_phrase == '%s: %s' % (new_list_title, self.title)

	def test_change_due_date(self):
		new_due_date = 'due tomorrow'
		new_phrase = self.task.phrase_with(due_date=new_due_date)

		assert new_phrase == '%s %s' % (self.title, new_due_date)

	def test_change_recurrence(self):
		new_recurrence = 'every month'
		new_phrase = self.task.phrase_with(recurrence=new_recurrence)

		assert new_phrase == '%s %s' % (self.title, new_recurrence)

	def test_change_reminder(self):
		new_reminder = 'r tomorrow at noon'
		new_phrase = self.task.phrase_with(reminder_date=new_reminder)

		assert new_phrase == '%s %s' % (self.title, new_reminder)

	def test_add_reminder_prompt(self):
		new_reminder = 'remind me '
		new_phrase = self.task.phrase_with(reminder_date=True)

		assert new_phrase == '%s %s' % (self.title, new_reminder)

	def test_change_star(self):
		new_phrase = self.task.phrase_with(starred=True)

		assert new_phrase == '%s *' % (self.title)

	def test_prompt_list_title(self):
		new_phrase = self.task.phrase_with(list_title=True)

		assert new_phrase == ': %s' % (self.title)

	def test_prompt_due_date(self):
		new_phrase = self.task.phrase_with(due_date=True)

		assert new_phrase == '%s due ' % (self.title)

	def test_prompt_recurrence(self):
		new_phrase = self.task.phrase_with(recurrence=True)

		assert new_phrase == '%s every ' % (self.title)
	def setup_task(self):
		phrase = self.title
		self.task = TaskParser(phrase)
	def test_complex_unchanged_phrase(self):
		phrase = 'fin: Oil change next Tuesday at noon repeat every 3mo *'
		task = TaskParser(phrase)
		new_phrase = task.phrase_with()

		assert phrase == new_phrase
	def test_date_and_time_as_datetimes(self):
		date_component = datetime.combine(_12_13_14, _default_reminder_time)
		time_component = datetime.combine(_today, _noon)
		reminder_date = TaskParser.reminder_date_combine(date_component, time_component)

		assert reminder_date == datetime.combine(date_component.date(), time_component.time())