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

tests/test_checklist_wrapper.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Unit tests for checklist item wrapper functions"""
+
+import unittest
+from todocli.graphapi.wrapper import (
+    StepNotFoundByName,
+    StepNotFoundByIndex,
+    BASE_URL,
+)
+
+
+class TestStepExceptions(unittest.TestCase):
+    """Test step-related exception classes"""
+
+    def test_step_not_found_by_name_exception(self):
+        """Test StepNotFoundByName exception message"""
+        step_name = "NonExistentStep"
+        task_name = "Buy groceries"
+        exc = StepNotFoundByName(step_name, task_name)
+
+        self.assertIn(step_name, exc.message)
+        self.assertIn(task_name, exc.message)
+        self.assertIn("could not be found", exc.message)
+
+    def test_step_not_found_by_index_exception(self):
+        """Test StepNotFoundByIndex exception message"""
+        step_index = 999
+        task_name = "Buy groceries"
+        exc = StepNotFoundByIndex(step_index, task_name)
+
+        self.assertIn(str(step_index), exc.message)
+        self.assertIn(task_name, exc.message)
+        self.assertIn("could not be found", exc.message)
+
+
+class TestChecklistEndpointPattern(unittest.TestCase):
+    """Test that the checklist endpoint URL is correctly constructed"""
+
+    def test_checklist_endpoint_format(self):
+        """Test the checklistItems endpoint follows the expected pattern"""
+        list_id = "list123"
+        task_id = "task456"
+        endpoint = f"{BASE_URL}/{list_id}/tasks/{task_id}/checklistItems"
+
+        self.assertIn("checklistItems", endpoint)
+        self.assertIn(list_id, endpoint)
+        self.assertIn(task_id, endpoint)
+        self.assertTrue(endpoint.startswith("https://graph.microsoft.com"))
+
+    def test_checklist_item_endpoint_format(self):
+        """Test individual checklistItem endpoint format"""
+        list_id = "list123"
+        task_id = "task456"
+        step_id = "step789"
+        endpoint = f"{BASE_URL}/{list_id}/tasks/{task_id}/checklistItems/{step_id}"
+
+        self.assertIn(step_id, endpoint)
+        self.assertTrue(endpoint.endswith(step_id))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_cli_commands.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""Unit tests for CLI command parsing and argument handling"""
+
+import unittest
+from todocli.cli import (
+    setup_parser,
+    parse_task_path,
+    try_parse_as_int,
+)
+
+
+class TestCLIArgumentParsing(unittest.TestCase):
+    """Test argparse setup for all commands"""
+
+    def setUp(self):
+        self.parser = setup_parser()
+
+    def test_ls_command(self):
+        """Test 'ls' command parsing"""
+        args = self.parser.parse_args(["ls"])
+        self.assertTrue(hasattr(args, "func"))
+        self.assertIsNotNone(args.func)
+
+    def test_lst_command_with_list(self):
+        """Test 'lst' command with list name"""
+        args = self.parser.parse_args(["lst", "personal"])
+        self.assertEqual(args.list_name, "personal")
+
+    def test_lst_command_default_list(self):
+        """Test 'lst' command defaults to 'Tasks'"""
+        args = self.parser.parse_args(["lst"])
+        self.assertEqual(args.list_name, "Tasks")
+
+    def test_new_command_basic(self):
+        """Test 'new' command with task name"""
+        args = self.parser.parse_args(["new", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertIsNone(args.reminder)
+        self.assertIsNone(getattr(args, "list", None))
+
+    def test_new_command_with_reminder(self):
+        """Test 'new' command with -r flag"""
+        args = self.parser.parse_args(["new", "-r", "9:00", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.reminder, "9:00")
+
+    def test_new_command_with_list_flag(self):
+        """Test 'new' command with --list flag"""
+        args = self.parser.parse_args(["new", "--list", "personal", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.list, "personal")
+
+    def test_new_command_with_short_list_flag(self):
+        """Test 'new' command with -l flag"""
+        args = self.parser.parse_args(["new", "-l", "work", "task"])
+        self.assertEqual(args.task_name, "task")
+        self.assertEqual(args.list, "work")
+
+    def test_new_command_with_all_flags(self):
+        """Test 'new' command with both -l and -r flags"""
+        args = self.parser.parse_args(
+            ["new", "-l", "personal", "-r", "9:00", "buy milk"]
+        )
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.list, "personal")
+        self.assertEqual(args.reminder, "9:00")
+
+    def test_new_command_with_important(self):
+        """Test 'new' command with -I flag"""
+        args = self.parser.parse_args(["new", "-I", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertTrue(args.important)
+
+    def test_new_command_with_important_long(self):
+        """Test 'new' command with --important flag"""
+        args = self.parser.parse_args(["new", "--important", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertTrue(args.important)
+
+    def test_new_command_without_important(self):
+        """Test 'new' command defaults important to False"""
+        args = self.parser.parse_args(["new", "buy milk"])
+        self.assertFalse(args.important)
+
+    def test_new_command_with_due(self):
+        """Test 'new' command with -d flag"""
+        args = self.parser.parse_args(["new", "-d", "tomorrow", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.due, "tomorrow")
+
+    def test_new_command_with_due_long(self):
+        """Test 'new' command with --due flag"""
+        args = self.parser.parse_args(["new", "--due", "2026-01-15", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.due, "2026-01-15")
+
+    def test_new_command_with_recurrence(self):
+        """Test 'new' command with -R flag"""
+        args = self.parser.parse_args(["new", "-R", "daily", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.recurrence, "daily")
+
+    def test_new_command_with_recurrence_long(self):
+        """Test 'new' command with --recurrence flag"""
+        args = self.parser.parse_args(["new", "--recurrence", "weekly", "buy milk"])
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.recurrence, "weekly")
+
+    def test_new_command_without_recurrence(self):
+        """Test 'new' command defaults recurrence to None"""
+        args = self.parser.parse_args(["new", "buy milk"])
+        self.assertIsNone(args.recurrence)
+
+    def test_new_command_with_step_flag(self):
+        """Test 'new' command with -S flag (repeatable)"""
+        args = self.parser.parse_args(
+            ["new", "-S", "milk", "-S", "eggs", "buy groceries"]
+        )
+        self.assertEqual(args.task_name, "buy groceries")
+        self.assertEqual(args.step, ["milk", "eggs"])
+
+    def test_new_command_with_step_long_flag(self):
+        """Test 'new' command with --step flag"""
+        args = self.parser.parse_args(["new", "--step", "milk", "buy groceries"])
+        self.assertEqual(args.step, ["milk"])
+
+    def test_new_command_without_steps(self):
+        """Test 'new' command defaults step to empty list"""
+        args = self.parser.parse_args(["new", "buy milk"])
+        self.assertEqual(args.step, [])
+
+    def test_new_command_with_all_flags(self):
+        """Test 'new' command with all flags"""
+        args = self.parser.parse_args(
+            [
+                "new",
+                "-l",
+                "personal",
+                "-r",
+                "9:00",
+                "-d",
+                "tomorrow",
+                "-I",
+                "-R",
+                "daily",
+                "buy milk",
+            ]
+        )
+        self.assertEqual(args.task_name, "buy milk")
+        self.assertEqual(args.list, "personal")
+        self.assertEqual(args.reminder, "9:00")
+        self.assertEqual(args.due, "tomorrow")
+        self.assertTrue(args.important)
+        self.assertEqual(args.recurrence, "daily")
+
+    def test_newl_command(self):
+        """Test 'newl' command for creating lists"""
+        args = self.parser.parse_args(["newl", "shopping"])
+        self.assertEqual(args.list_name, "shopping")
+
+    def test_new_list_command(self):
+        """Test 'new-list' command (primary name for creating lists)"""
+        args = self.parser.parse_args(["new-list", "work"])
+        self.assertEqual(args.list_name, "work")
+
+    def test_new_with_json_flag(self):
+        """Test 'new' command with --json flag"""
+        args = self.parser.parse_args(["new", "--json", "buy milk"])
+        self.assertTrue(args.json)
+
+    def test_complete_with_json_flag(self):
+        """Test 'complete' command with --json flag"""
+        args = self.parser.parse_args(["complete", "-j", "task"])
+        self.assertTrue(args.json)
+
+    def test_rm_with_json_flag(self):
+        """Test 'rm' command with --json flag"""
+        args = self.parser.parse_args(["rm", "--json", "-y", "task"])
+        self.assertTrue(args.json)
+
+    def test_update_with_json_flag(self):
+        """Test 'update' command with --json flag"""
+        args = self.parser.parse_args(["update", "-j", "task", "--title", "new"])
+        self.assertTrue(args.json)
+
+    def test_complete_command_basic(self):
+        """Test 'complete' command"""
+        args = self.parser.parse_args(["complete", "task"])
+        self.assertEqual(args.task_names, ["task"])
+        self.assertIsNone(getattr(args, "list", None))
+
+    def test_complete_command_with_list(self):
+        """Test 'complete' command with --list flag"""
+        args = self.parser.parse_args(["complete", "--list", "personal", "task"])
+        self.assertEqual(args.task_names, ["task"])
+        self.assertEqual(args.list, "personal")
+
+    def test_complete_command_multiple_tasks(self):
+        """Test 'complete' command with multiple tasks"""
+        args = self.parser.parse_args(["complete", "task1", "task2", "task3"])
+        self.assertEqual(args.task_names, ["task1", "task2", "task3"])
+
+    def test_rm_command_basic(self):
+        """Test 'rm' command"""
+        args = self.parser.parse_args(["rm", "task"])
+        self.assertEqual(args.task_names, ["task"])
+
+    def test_rm_command_with_list(self):
+        """Test 'rm' command with -l flag"""
+        args = self.parser.parse_args(["rm", "-l", "work", "task"])
+        self.assertEqual(args.task_names, ["task"])
+        self.assertEqual(args.list, "work")
+
+    def test_rm_command_multiple_tasks(self):
+        """Test 'rm' command with multiple tasks"""
+        args = self.parser.parse_args(["rm", "task1", "task2"])
+        self.assertEqual(args.task_names, ["task1", "task2"])
+
+    def test_rm_command_yes_flag(self):
+        """Test 'rm' command with -y/--yes flag"""
+        args = self.parser.parse_args(["rm", "-y", "task"])
+        self.assertTrue(args.yes)
+
+        args = self.parser.parse_args(["rm", "--yes", "task"])
+        self.assertTrue(args.yes)
+
+    def test_interactive_flag(self):
+        """Test -i/--interactive flag"""
+        args = self.parser.parse_args(["-i", "ls"])
+        self.assertTrue(args.interactive)
+
+        args = self.parser.parse_args(["--interactive", "ls"])
+        self.assertTrue(args.interactive)
+
+    def test_lst_date_format_flag(self):
+        """Test lst command with --date-format flag"""
+        args = self.parser.parse_args(["lst", "--date-format", "iso"])
+        self.assertEqual(args.date_format, "iso")
+
+        args = self.parser.parse_args(["lst", "--date-format", "us"])
+        self.assertEqual(args.date_format, "us")
+
+        args = self.parser.parse_args(["lst", "--date-format", "eu"])
+        self.assertEqual(args.date_format, "eu")
+
+    def test_lst_date_format_default(self):
+        """Test lst command defaults date-format to eu"""
+        args = self.parser.parse_args(["lst"])
+        self.assertEqual(args.date_format, "eu")
+
+    def test_complete_with_id_flag(self):
+        """Test 'complete' command with --id flag"""
+        args = self.parser.parse_args(["complete", "--id", "AAMkABC123"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.task_names, [])
+
+    def test_complete_with_id_and_list_flag(self):
+        """Test 'complete' command with --id and -l flags"""
+        args = self.parser.parse_args(["complete", "--id", "AAMkABC123", "-l", "Work"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.list, "Work")
+
+    def test_rm_with_id_flag(self):
+        """Test 'rm' command with --id flag"""
+        args = self.parser.parse_args(["rm", "--id", "AAMkABC123", "-y"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertTrue(args.yes)
+
+    def test_show_with_id_flag(self):
+        """Test 'show' command with --id flag"""
+        args = self.parser.parse_args(["show", "--id", "AAMkABC123"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertIsNone(args.task_name)
+
+    def test_update_with_id_flag(self):
+        """Test 'update' command with --id flag"""
+        args = self.parser.parse_args(
+            ["update", "--id", "AAMkABC123", "--title", "New"]
+        )
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.title, "New")
+
+    def test_list_steps_with_id_flag(self):
+        """Test 'list-steps' command with --id flag"""
+        args = self.parser.parse_args(["list-steps", "--id", "AAMkABC123"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+
+    def test_new_step_with_id_flag(self):
+        """Test 'new-step' command with --id flag"""
+        args = self.parser.parse_args(["new-step", "--id", "AAMkABC123", "Step 1"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.step_name, "Step 1")
+
+    def test_complete_step_with_id_flag(self):
+        """Test 'complete-step' command with --id flag"""
+        # When --id is used, the step arg goes into task_name (first positional)
+        # CLI code handles this by using task_name as step when task_id is set
+        args = self.parser.parse_args(["complete-step", "--id", "AAMkABC123", "0"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.task_name, "0")
+
+    def test_rm_step_with_id_flag(self):
+        """Test 'rm-step' command with --id flag"""
+        # When --id is used, the step arg goes into task_name (first positional)
+        # CLI code handles this by using task_name as step when task_id is set
+        args = self.parser.parse_args(["rm-step", "--id", "AAMkABC123", "0"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.task_name, "0")
+
+    def test_tasks_all_flag(self):
+        """Test 'tasks' command with --all flag"""
+        args = self.parser.parse_args(["tasks", "--all"])
+        self.assertTrue(args.all)
+
+    def test_tasks_completed_flag(self):
+        """Test 'tasks' command with --completed flag"""
+        args = self.parser.parse_args(["tasks", "--completed"])
+        self.assertTrue(args.completed)
+
+    def test_uncomplete_command_basic(self):
+        """Test 'uncomplete' command"""
+        args = self.parser.parse_args(["uncomplete", "task"])
+        self.assertEqual(args.task_names, ["task"])
+
+    def test_uncomplete_with_id_flag(self):
+        """Test 'uncomplete' command with --id flag"""
+        args = self.parser.parse_args(["uncomplete", "--id", "AAMkABC123"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+
+    def test_uncomplete_step_command_basic(self):
+        """Test 'uncomplete-step' command"""
+        args = self.parser.parse_args(["uncomplete-step", "task", "0"])
+        self.assertEqual(args.task_name, "task")
+        self.assertEqual(args.step_name, "0")
+
+    def test_uncomplete_step_with_id_flag(self):
+        """Test 'uncomplete-step' command with --id flag"""
+        # When --id is used, the step arg goes into task_name (first positional)
+        # CLI code handles this by using task_name as step when task_id is set
+        args = self.parser.parse_args(["uncomplete-step", "--id", "AAMkABC123", "0"])
+        self.assertEqual(args.task_id, "AAMkABC123")
+        self.assertEqual(args.task_name, "0")
+
+
+class TestParseTaskPath(unittest.TestCase):
+    """Test parse_task_path function"""
+
+    def test_simple_task_name(self):
+        """Test task name without list defaults to 'Tasks'"""
+        list_name, task_name = parse_task_path("buy milk")
+        self.assertEqual(list_name, "Tasks")
+        self.assertEqual(task_name, "buy milk")
+
+    def test_task_with_explicit_list(self):
+        """Test task with explicit list_name parameter"""
+        list_name, task_name = parse_task_path("buy milk", list_name="work")
+        self.assertEqual(list_name, "work")
+        self.assertEqual(task_name, "buy milk")
+
+    def test_task_with_slashes_no_autoparsing(self):
+        """Test that slashes are NOT auto-parsed as list separator"""
+        list_name, task_name = parse_task_path("personal/buy milk")
+        self.assertEqual(list_name, "Tasks")
+        self.assertEqual(task_name, "personal/buy milk")
+
+    def test_url_as_task_name(self):
+        """Test URL as task name works without special handling"""
+        list_name, task_name = parse_task_path("https://www.google.com/")
+        self.assertEqual(list_name, "Tasks")
+        self.assertEqual(task_name, "https://www.google.com/")
+
+    def test_url_with_explicit_list(self):
+        """Test URL task name with explicit list"""
+        list_name, task_name = parse_task_path(
+            "https://example.com/path/to/page", list_name="work"
+        )
+        self.assertEqual(list_name, "work")
+        self.assertEqual(task_name, "https://example.com/path/to/page")
+
+    def test_empty_task_name(self):
+        """Test empty task name"""
+        list_name, task_name = parse_task_path("")
+        self.assertEqual(list_name, "Tasks")
+        self.assertEqual(task_name, "")
+
+    def test_special_characters_in_task_name(self):
+        """Test task names with special characters"""
+        list_name, task_name = parse_task_path("check A/B testing")
+        self.assertEqual(list_name, "Tasks")
+        self.assertEqual(task_name, "check A/B testing")
+
+
+class TestTryParseAsInt(unittest.TestCase):
+    """Test try_parse_as_int helper function"""
+
+    def test_valid_integer_string(self):
+        """Test parsing valid integer string"""
+        result = try_parse_as_int("42")
+        self.assertEqual(result, 42)
+        self.assertIsInstance(result, int)
+
+    def test_zero(self):
+        """Test parsing zero"""
+        result = try_parse_as_int("0")
+        self.assertEqual(result, 0)
+
+    def test_negative_integer(self):
+        """Test parsing negative integer"""
+        result = try_parse_as_int("-5")
+        self.assertEqual(result, -5)
+
+    def test_non_integer_string(self):
+        """Test that non-integer strings are returned as-is"""
+        result = try_parse_as_int("buy milk")
+        self.assertEqual(result, "buy milk")
+        self.assertIsInstance(result, str)
+
+    def test_float_string(self):
+        """Test that float strings are returned as-is"""
+        result = try_parse_as_int("3.14")
+        self.assertEqual(result, "3.14")
+        self.assertIsInstance(result, str)
+
+    def test_empty_string(self):
+        """Test empty string"""
+        result = try_parse_as_int("")
+        self.assertEqual(result, "")
+
+    def test_mixed_alphanumeric(self):
+        """Test mixed alphanumeric string"""
+        result = try_parse_as_int("task123")
+        self.assertEqual(result, "task123")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_cli_output.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Unit tests for confirmation output after mutating CLI commands"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+from io import StringIO
+
+from todocli.cli import (
+    new,
+    newl,
+    complete,
+    rm,
+    update,
+    new_step,
+    complete_step,
+    rm_step,
+)
+
+
+def _make_args(**kwargs):
+    args = MagicMock()
+    for k, v in kwargs.items():
+        setattr(args, k, v)
+    # Defaults for optional flags
+    if "list" not in kwargs:
+        args.list = None
+    if "reminder" not in kwargs:
+        args.reminder = None
+    if "due" not in kwargs:
+        args.due = None
+    if "important" not in kwargs:
+        args.important = False
+    if "recurrence" not in kwargs:
+        args.recurrence = None
+    if "title" not in kwargs:
+        args.title = None
+    if "task_names" not in kwargs:
+        args.task_names = None
+    if "yes" not in kwargs:
+        args.yes = False
+    if "json" not in kwargs:
+        args.json = False
+    if "task_id" not in kwargs:
+        args.task_id = None
+    if "task_index" not in kwargs:
+        args.task_index = None
+    if "step_id" not in kwargs:
+        args.step_id = None
+    return args
+
+
+class TestConfirmationOutput(unittest.TestCase):
+
+    @patch("todocli.cli.wrapper")
+    def test_new_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.create_task.return_value = "task-id-123"
+        args = _make_args(task_name="buy milk")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            new(args)
+            self.assertIn("Created task", out.getvalue())
+            self.assertIn("buy milk", out.getvalue())
+
+    @patch("todocli.cli.wrapper")
+    def test_new_with_steps_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.create_task.return_value = "task-id-123"
+        mock_wrapper.get_list_id_by_name.return_value = "list-id"
+        mock_wrapper.create_checklist_item.return_value = ("step-id-123", "step name")
+        args = _make_args(task_name="buy groceries", step=["milk", "eggs"])
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            new(args)
+            output = out.getvalue()
+            self.assertIn("Created task", output)
+            self.assertIn("buy groceries", output)
+            self.assertIn("2 step(s)", output)
+
+        # Verify steps were created
+        self.assertEqual(mock_wrapper.create_checklist_item.call_count, 2)
+
+    @patch("todocli.cli.wrapper")
+    def test_newl_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.create_list.return_value = ("list-id-123", "Shopping")
+        args = _make_args(list_name="Shopping")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            newl(args)
+            self.assertIn("Created list", out.getvalue())
+            self.assertIn("Shopping", out.getvalue())
+
+    @patch("todocli.cli.wrapper")
+    def test_complete_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.complete_task.return_value = ("task-id-123", "buy milk")
+        args = _make_args(task_name="Tasks/buy milk")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            complete(args)
+            self.assertIn("Completed task", out.getvalue())
+
+    @patch("todocli.cli.wrapper")
+    def test_rm_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.remove_task.return_value = ("task-id-123", "buy milk")
+        args = _make_args(task_name="Tasks/buy milk", yes=True)
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            rm(args)
+            self.assertIn("Removed task", out.getvalue())
+
+    @patch("todocli.cli.confirm_action", return_value=False)
+    def test_rm_skipped_no_error(self, mock_confirm):
+        """Test rm prints 'Skipped' and does not raise when user declines"""
+        args = _make_args(task_name="Tasks/buy milk", yes=False)
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            # Should not raise
+            rm(args)
+            self.assertIn("Skipped", out.getvalue())
+
+    @patch("todocli.cli.confirm_action", return_value=False)
+    def test_rm_multiple_skipped_no_error(self, mock_confirm):
+        """Test rm with multiple tasks all skipped does not raise"""
+        args = _make_args(task_names=["Tasks/task1", "Tasks/task2"], yes=False)
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            rm(args)
+            output = out.getvalue()
+            self.assertIn("Skipped", output)
+            self.assertEqual(output.count("Skipped"), 2)
+
+    @patch("todocli.cli.wrapper")
+    def test_update_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.update_task.return_value = ("task-id-123", "new name")
+        args = _make_args(task_name="Tasks/buy milk", title="new name")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            update(args)
+            self.assertIn("Updated task", out.getvalue())
+
+    @patch("todocli.cli.wrapper")
+    def test_new_step_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.create_checklist_item.return_value = ("step-id-123", "get eggs")
+        args = _make_args(task_name="Tasks/buy milk", step_name="get eggs")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            new_step(args)
+            self.assertIn("Added step", out.getvalue())
+            self.assertIn("get eggs", out.getvalue())
+
+    @patch("todocli.cli.wrapper")
+    def test_complete_step_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.complete_checklist_item.return_value = ("step-id-123", "get eggs")
+        args = _make_args(task_name="Tasks/buy milk", step_name="get eggs")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            complete_step(args)
+            self.assertIn("Completed step", out.getvalue())
+
+    @patch("todocli.cli.wrapper")
+    def test_rm_step_prints_confirmation(self, mock_wrapper):
+        mock_wrapper.delete_checklist_item.return_value = "step-id-123"
+        args = _make_args(task_name="Tasks/buy milk", step_name="get eggs")
+
+        with patch("sys.stdout", new_callable=StringIO) as out:
+            rm_step(args)
+            self.assertIn("Removed step", out.getvalue())
+
+
+if __name__ == "__main__":
+    unittest.main()