microsoft-todo-cli 1.0.0__py3-none-any.whl

tests/test_odata_escape.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""Unit tests for OData string escaping in graph API wrapper"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+from todocli.graphapi.wrapper import (
+    _escape_odata_string,
+    get_task_id_by_name,
+    TaskNotFoundByName,
+)
+
+
+class TestEscapeOdataString(unittest.TestCase):
+    """Test _escape_odata_string helper"""
+
+    def test_plain_text_unchanged(self):
+        """Test that plain text passes through unchanged"""
+        self.assertEqual(_escape_odata_string("Buy milk"), "Buy milk")
+
+    def test_cyrillic_text_unchanged(self):
+        """Test that Cyrillic text passes through unchanged"""
+        self.assertEqual(
+            _escape_odata_string("Купить молоко"),
+            "Купить молоко",
+        )
+
+    def test_single_quote_doubled(self):
+        """Test that single quotes are doubled per OData spec"""
+        self.assertEqual(_escape_odata_string("it's done"), "it''s done")
+
+    def test_multiple_single_quotes(self):
+        """Test multiple single quotes in one string"""
+        self.assertEqual(
+            _escape_odata_string("it's Alice's task"),
+            "it''s Alice''s task",
+        )
+
+    def test_hash_double_encoded(self):
+        """Test that '#' is double-percent-encoded for URL safety"""
+        self.assertEqual(
+            _escape_odata_string("task #tag"),
+            "task %2523tag",
+        )
+
+    def test_ampersand_double_encoded(self):
+        """Test that '&' is double-percent-encoded for URL safety"""
+        self.assertEqual(
+            _escape_odata_string("bread & butter"),
+            "bread %2526 butter",
+        )
+
+    def test_plus_double_encoded(self):
+        """Test that '+' is double-percent-encoded for URL safety"""
+        self.assertEqual(
+            _escape_odata_string("1+1=2"),
+            "1%252B1=2",
+        )
+
+    def test_all_special_chars_combined(self):
+        """Test string with all special characters at once"""
+        self.assertEqual(
+            _escape_odata_string("it's a #tag & 1+1"),
+            "it''s a %2523tag %2526 1%252B1",
+        )
+
+    def test_empty_string(self):
+        """Test that empty string returns empty string"""
+        self.assertEqual(_escape_odata_string(""), "")
+
+    def test_only_special_chars(self):
+        """Test string consisting entirely of special characters"""
+        self.assertEqual(_escape_odata_string("#&#"), "%2523%2526%2523")
+
+    def test_safe_url_chars_unchanged(self):
+        """Test that other URL-safe special chars are not affected"""
+        for char in ["?", "=", "/", ":", "(", ")"]:
+            value = f"task {char} test"
+            self.assertEqual(
+                _escape_odata_string(value),
+                value,
+                f"Character '{char}' should not be escaped",
+            )
+
+
+class TestGetTaskIdByNameEndpoint(unittest.TestCase):
+    """Test that get_task_id_by_name builds the correct OData filter URL"""
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_plain_name_filter(self, mock_get_list_id, mock_get_session):
+        """Test OData filter URL for a plain task name"""
+        mock_get_list_id.return_value = "list123"
+        mock_response = MagicMock()
+        mock_response.content = b'{"value": [{"id": "task1", "title": "Buy milk", "importance": "normal", "status": "notStarted", "createdDateTime": "2024-01-01T00:00:00.0000000Z", "lastModifiedDateTime": "2024-01-01T00:00:00.0000000Z", "isReminderOn": false}]}'
+        mock_get_session.return_value.get.return_value = mock_response
+
+        get_task_id_by_name("Tasks", "Buy milk")
+
+        called_url = mock_get_session.return_value.get.call_args[0][0]
+        self.assertIn("$filter=title eq 'Buy milk'", called_url)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_hash_tag_filter(self, mock_get_list_id, mock_get_session):
+        """Test OData filter URL for task name containing '#' (tag)"""
+        mock_get_list_id.return_value = "list123"
+        mock_response = MagicMock()
+        mock_response.content = b'{"value": [{"id": "task1", "title": "Do stuff #work", "importance": "normal", "status": "notStarted", "createdDateTime": "2024-01-01T00:00:00.0000000Z", "lastModifiedDateTime": "2024-01-01T00:00:00.0000000Z", "isReminderOn": false}]}'
+        mock_get_session.return_value.get.return_value = mock_response
+
+        get_task_id_by_name("Tasks", "Do stuff #work")
+
+        called_url = mock_get_session.return_value.get.call_args[0][0]
+        self.assertIn("%2523", called_url)
+        self.assertNotIn("#work", called_url)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_ampersand_filter(self, mock_get_list_id, mock_get_session):
+        """Test OData filter URL for task name containing '&'"""
+        mock_get_list_id.return_value = "list123"
+        mock_response = MagicMock()
+        mock_response.content = b'{"value": [{"id": "task1", "title": "bread & butter", "importance": "normal", "status": "notStarted", "createdDateTime": "2024-01-01T00:00:00.0000000Z", "lastModifiedDateTime": "2024-01-01T00:00:00.0000000Z", "isReminderOn": false}]}'
+        mock_get_session.return_value.get.return_value = mock_response
+
+        get_task_id_by_name("Tasks", "bread & butter")
+
+        called_url = mock_get_session.return_value.get.call_args[0][0]
+        self.assertIn("%2526", called_url)
+        self.assertNotIn("& butter", called_url)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_plus_filter(self, mock_get_list_id, mock_get_session):
+        """Test OData filter URL for task name containing '+'"""
+        mock_get_list_id.return_value = "list123"
+        mock_response = MagicMock()
+        mock_response.content = b'{"value": [{"id": "task1", "title": "1+1=2", "importance": "normal", "status": "notStarted", "createdDateTime": "2024-01-01T00:00:00.0000000Z", "lastModifiedDateTime": "2024-01-01T00:00:00.0000000Z", "isReminderOn": false}]}'
+        mock_get_session.return_value.get.return_value = mock_response
+
+        get_task_id_by_name("Tasks", "1+1=2")
+
+        called_url = mock_get_session.return_value.get.call_args[0][0]
+        self.assertIn("%252B", called_url)
+        self.assertNotIn("+1", called_url)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_single_quote_filter(self, mock_get_list_id, mock_get_session):
+        """Test OData filter URL for task name containing single quote"""
+        mock_get_list_id.return_value = "list123"
+        mock_response = MagicMock()
+        mock_response.content = b'{"value": [{"id": "task1", "title": "it\'s done", "importance": "normal", "status": "notStarted", "createdDateTime": "2024-01-01T00:00:00.0000000Z", "lastModifiedDateTime": "2024-01-01T00:00:00.0000000Z", "isReminderOn": false}]}'
+        mock_get_session.return_value.get.return_value = mock_response
+
+        get_task_id_by_name("Tasks", "it's done")
+
+        called_url = mock_get_session.return_value.get.call_args[0][0]
+        self.assertIn("it''s done", called_url)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_not_found_raises_exception(self, mock_get_list_id, mock_get_session):
+        """Test that TaskNotFoundByName is raised for non-existent task"""
+        mock_get_list_id.return_value = "list123"
+        mock_response = MagicMock()
+        mock_response.content = b'{"value": []}'
+        mock_get_session.return_value.get.return_value = mock_response
+
+        with self.assertRaises(TaskNotFoundByName):
+            get_task_id_by_name("Tasks", "NonExistent")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_recurrence.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Unit tests for recurrence expression parsing"""
+
+import unittest
+from datetime import date
+from unittest.mock import patch
+
+from todocli.utils.recurrence_util import parse_recurrence, InvalidRecurrenceExpression
+
+
+class TestParseRecurrence(unittest.TestCase):
+    """Test parse_recurrence function"""
+
+    def setUp(self):
+        self.today = date(2026, 2, 4)
+        self.patcher = patch(
+            "todocli.utils.recurrence_util.date",
+            wraps=date,
+        )
+        self.mock_date = self.patcher.start()
+        self.mock_date.today.return_value = self.today
+
+    def tearDown(self):
+        self.patcher.stop()
+
+    def test_none_input(self):
+        """Test None input returns None"""
+        self.assertIsNone(parse_recurrence(None))
+
+    def test_empty_string(self):
+        """Test empty string returns None"""
+        self.assertIsNone(parse_recurrence(""))
+        self.assertIsNone(parse_recurrence("   "))
+
+    def test_daily(self):
+        """Test 'daily' preset"""
+        result = parse_recurrence("daily")
+        self.assertEqual(result["pattern"]["type"], "daily")
+        self.assertEqual(result["pattern"]["interval"], 1)
+        self.assertEqual(result["range"]["type"], "noEnd")
+        self.assertEqual(result["range"]["startDate"], "2026-02-04")
+
+    def test_weekly(self):
+        """Test 'weekly' preset"""
+        result = parse_recurrence("weekly")
+        self.assertEqual(result["pattern"]["type"], "weekly")
+        self.assertEqual(result["pattern"]["interval"], 1)
+
+    def test_weekdays(self):
+        """Test 'weekdays' preset sets mon-fri"""
+        result = parse_recurrence("weekdays")
+        self.assertEqual(result["pattern"]["type"], "weekly")
+        self.assertEqual(result["pattern"]["interval"], 1)
+        self.assertEqual(
+            result["pattern"]["daysOfWeek"],
+            ["monday", "tuesday", "wednesday", "thursday", "friday"],
+        )
+
+    def test_monthly(self):
+        """Test 'monthly' preset sets dayOfMonth from today"""
+        result = parse_recurrence("monthly")
+        self.assertEqual(result["pattern"]["type"], "absoluteMonthly")
+        self.assertEqual(result["pattern"]["interval"], 1)
+        self.assertEqual(result["pattern"]["dayOfMonth"], 4)
+
+    def test_yearly(self):
+        """Test 'yearly' preset sets dayOfMonth and month from today"""
+        result = parse_recurrence("yearly")
+        self.assertEqual(result["pattern"]["type"], "absoluteYearly")
+        self.assertEqual(result["pattern"]["interval"], 1)
+        self.assertEqual(result["pattern"]["dayOfMonth"], 4)
+        self.assertEqual(result["pattern"]["month"], 2)
+
+    def test_every_n_days(self):
+        """Test 'every 2 days' custom interval"""
+        result = parse_recurrence("every 2 days")
+        self.assertEqual(result["pattern"]["type"], "daily")
+        self.assertEqual(result["pattern"]["interval"], 2)
+
+    def test_every_n_weeks(self):
+        """Test 'every 3 weeks' custom interval"""
+        result = parse_recurrence("every 3 weeks")
+        self.assertEqual(result["pattern"]["type"], "weekly")
+        self.assertEqual(result["pattern"]["interval"], 3)
+
+    def test_every_n_months(self):
+        """Test 'every 2 months' custom interval"""
+        result = parse_recurrence("every 2 months")
+        self.assertEqual(result["pattern"]["type"], "absoluteMonthly")
+        self.assertEqual(result["pattern"]["interval"], 2)
+        self.assertEqual(result["pattern"]["dayOfMonth"], 4)
+
+    def test_every_n_years(self):
+        """Test 'every 1 year' custom interval"""
+        result = parse_recurrence("every 1 year")
+        self.assertEqual(result["pattern"]["type"], "absoluteYearly")
+        self.assertEqual(result["pattern"]["interval"], 1)
+
+    def test_weekly_with_days(self):
+        """Test 'weekly:mon,fri' with day specifiers"""
+        result = parse_recurrence("weekly:mon,fri")
+        self.assertEqual(result["pattern"]["type"], "weekly")
+        self.assertEqual(result["pattern"]["interval"], 1)
+        self.assertEqual(result["pattern"]["daysOfWeek"], ["monday", "friday"])
+
+    def test_every_n_weeks_with_days(self):
+        """Test 'every 2 weeks:mon,wed,fri' with day specifiers"""
+        result = parse_recurrence("every 2 weeks:mon,wed,fri")
+        self.assertEqual(result["pattern"]["type"], "weekly")
+        self.assertEqual(result["pattern"]["interval"], 2)
+        self.assertEqual(
+            result["pattern"]["daysOfWeek"], ["monday", "wednesday", "friday"]
+        )
+
+    def test_case_insensitive(self):
+        """Test that input is case insensitive"""
+        result = parse_recurrence("Daily")
+        self.assertEqual(result["pattern"]["type"], "daily")
+
+        result = parse_recurrence("WEEKLY:MON,FRI")
+        self.assertEqual(result["pattern"]["daysOfWeek"], ["monday", "friday"])
+
+    def test_whitespace_handling(self):
+        """Test that extra whitespace is handled"""
+        result = parse_recurrence("  daily  ")
+        self.assertEqual(result["pattern"]["type"], "daily")
+
+    def test_invalid_expression(self):
+        """Test that invalid expressions raise InvalidRecurrenceExpression"""
+        with self.assertRaises(InvalidRecurrenceExpression):
+            parse_recurrence("biweekly")
+
+    def test_invalid_day_abbreviation(self):
+        """Test that invalid day abbreviations raise InvalidRecurrenceExpression"""
+        with self.assertRaises(InvalidRecurrenceExpression):
+            parse_recurrence("weekly:monday,fri")
+
+    def test_range_always_no_end(self):
+        """Test that range is always noEnd with today's date"""
+        for expr in ["daily", "weekly", "monthly", "yearly"]:
+            result = parse_recurrence(expr)
+            self.assertEqual(result["range"]["type"], "noEnd")
+            self.assertEqual(result["range"]["startDate"], "2026-02-04")
+
+    def test_singular_unit(self):
+        """Test singular unit forms work"""
+        result = parse_recurrence("every 1 day")
+        self.assertEqual(result["pattern"]["type"], "daily")
+        self.assertEqual(result["pattern"]["interval"], 1)
+
+        result = parse_recurrence("every 1 week")
+        self.assertEqual(result["pattern"]["type"], "weekly")
+
+        result = parse_recurrence("every 1 month")
+        self.assertEqual(result["pattern"]["type"], "absoluteMonthly")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_update_command.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Unit tests for the update command (CLI parsing + wrapper)"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+from todocli.cli import setup_parser
+from todocli.graphapi.wrapper import update_task
+
+
+class TestUpdateCLIParsing(unittest.TestCase):
+    """Test argparse setup for the update command"""
+
+    def setUp(self):
+        self.parser = setup_parser()
+
+    def test_update_basic(self):
+        args = self.parser.parse_args(["update", "Tasks/my task"])
+        self.assertEqual(args.task_name, "Tasks/my task")
+        self.assertIsNone(args.title)
+        self.assertIsNone(args.due)
+        self.assertIsNone(args.reminder)
+        self.assertFalse(args.important)
+        self.assertIsNone(args.recurrence)
+        self.assertIsNone(getattr(args, "list", None))
+
+    def test_update_with_title(self):
+        args = self.parser.parse_args(["update", "Tasks/old", "--title", "new name"])
+        self.assertEqual(args.title, "new name")
+
+    def test_update_with_due(self):
+        args = self.parser.parse_args(["update", "Tasks/t", "-d", "15.02.2026"])
+        self.assertEqual(args.due, "15.02.2026")
+
+    def test_update_with_all_flags(self):
+        args = self.parser.parse_args(
+            [
+                "update",
+                "Tasks/t",
+                "--title",
+                "renamed",
+                "-d",
+                "20.02.2026",
+                "-r",
+                "9:00",
+                "-I",
+                "-R",
+                "daily",
+            ]
+        )
+        self.assertEqual(args.title, "renamed")
+        self.assertEqual(args.due, "20.02.2026")
+        self.assertEqual(args.reminder, "9:00")
+        self.assertTrue(args.important)
+        self.assertEqual(args.recurrence, "daily")
+
+    def test_update_with_list_flag(self):
+        args = self.parser.parse_args(
+            ["update", "my task", "-l", "Work", "--title", "x"]
+        )
+        self.assertEqual(args.task_name, "my task")
+        self.assertEqual(args.list, "Work")
+        self.assertEqual(args.title, "x")
+
+    def test_update_mutually_exclusive_due(self):
+        """Test --due and --clear-due are mutually exclusive"""
+        with self.assertRaises(SystemExit):
+            self.parser.parse_args(["update", "t", "-d", "tomorrow", "--clear-due"])
+
+    def test_update_mutually_exclusive_reminder(self):
+        """Test --reminder and --clear-reminder are mutually exclusive"""
+        with self.assertRaises(SystemExit):
+            self.parser.parse_args(["update", "t", "-r", "9am", "--clear-reminder"])
+
+    def test_update_mutually_exclusive_important(self):
+        """Test --important and --no-important are mutually exclusive"""
+        with self.assertRaises(SystemExit):
+            self.parser.parse_args(["update", "t", "-I", "--no-important"])
+
+    def test_update_mutually_exclusive_recurrence(self):
+        """Test --recurrence and --clear-recurrence are mutually exclusive"""
+        with self.assertRaises(SystemExit):
+            self.parser.parse_args(["update", "t", "-R", "daily", "--clear-recurrence"])
+
+    def test_update_clear_due_alone(self):
+        """Test --clear-due works alone"""
+        args = self.parser.parse_args(["update", "t", "--clear-due"])
+        self.assertTrue(args.clear_due)
+        self.assertIsNone(args.due)
+
+    def test_update_no_important_alone(self):
+        """Test --no-important works alone"""
+        args = self.parser.parse_args(["update", "t", "--no-important"])
+        self.assertTrue(args.no_important)
+        self.assertFalse(args.important)
+
+
+class TestUpdateWrapper(unittest.TestCase):
+    """Test update_task wrapper function with mocked API"""
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_task_id_by_name")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_update_task_title_only(self, mock_list_id, mock_task_id, mock_session):
+        mock_list_id.return_value = "lid"
+        mock_task_id.return_value = "tid"
+        mock_resp = MagicMock()
+        mock_resp.ok = True
+        mock_resp.content = b'{"id": "tid", "title": "new title"}'
+        mock_session.return_value.patch.return_value = mock_resp
+
+        task_id, task_title = update_task("Tasks", "my task", title="new title")
+        self.assertEqual(task_id, "tid")
+        self.assertEqual(task_title, "new title")
+        call_kwargs = mock_session.return_value.patch.call_args
+        body = call_kwargs.kwargs["json"]
+        self.assertEqual(body["title"], "new title")
+        self.assertNotIn("dueDateTime", body)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_task_id_by_name")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_update_task_due_only(self, mock_list_id, mock_task_id, mock_session):
+        from datetime import datetime
+
+        mock_list_id.return_value = "lid"
+        mock_task_id.return_value = "tid"
+        mock_resp = MagicMock()
+        mock_resp.ok = True
+        mock_resp.content = b'{"id": "tid", "title": "my task"}'
+        mock_session.return_value.patch.return_value = mock_resp
+
+        dt = datetime(2026, 2, 15, 7, 0, 0)
+        task_id, task_title = update_task("Tasks", "my task", due_datetime=dt)
+        self.assertEqual(task_id, "tid")
+        body = mock_session.return_value.patch.call_args.kwargs["json"]
+        self.assertIn("dueDateTime", body)
+        self.assertNotIn("title", body)
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_task_id_by_name")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_update_task_importance(self, mock_list_id, mock_task_id, mock_session):
+        mock_list_id.return_value = "lid"
+        mock_task_id.return_value = "tid"
+        mock_resp = MagicMock()
+        mock_resp.ok = True
+        mock_resp.content = b'{"id": "tid", "title": "my task"}'
+        mock_session.return_value.patch.return_value = mock_resp
+
+        task_id, task_title = update_task("Tasks", "my task", important=True)
+        self.assertEqual(task_id, "tid")
+        body = mock_session.return_value.patch.call_args.kwargs["json"]
+        self.assertEqual(body["importance"], "high")
+
+    @patch("todocli.graphapi.wrapper.get_oauth_session")
+    @patch("todocli.graphapi.wrapper.get_task_id_by_name")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_update_task_multiple_fields(
+        self, mock_list_id, mock_task_id, mock_session
+    ):
+        from datetime import datetime
+
+        mock_list_id.return_value = "lid"
+        mock_task_id.return_value = "tid"
+        mock_resp = MagicMock()
+        mock_resp.ok = True
+        mock_resp.content = b'{"id": "tid", "title": "new"}'
+        mock_session.return_value.patch.return_value = mock_resp
+
+        dt = datetime(2026, 3, 1, 7, 0, 0)
+        task_id, task_title = update_task(
+            "Tasks", "t", title="new", due_datetime=dt, important=True
+        )
+        self.assertEqual(task_id, "tid")
+        self.assertEqual(task_title, "new")
+        body = mock_session.return_value.patch.call_args.kwargs["json"]
+        self.assertEqual(body["title"], "new")
+        self.assertIn("dueDateTime", body)
+        self.assertEqual(body["importance"], "high")
+
+    @patch("todocli.graphapi.wrapper.get_task_id_by_name")
+    @patch("todocli.graphapi.wrapper.get_list_id_by_name")
+    def test_update_task_empty_body_raises(self, mock_list_id, mock_task_id):
+        mock_list_id.return_value = "lid"
+        mock_task_id.return_value = "tid"
+
+        with self.assertRaises(ValueError):
+            update_task("Tasks", "t")
+
+
+if __name__ == "__main__":
+    unittest.main()