icloud-cli-tools 0.1.2__tar.gz → 0.1.3__tar.gz

{icloud_cli_tools-0.1.2/src/icloud_cli_tools.egg-info → icloud_cli_tools-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icloud-cli-tools
-Version: 0.1.2
+Version: 0.1.3
 Summary: Access iCloud Calendar, Reminders, Notes, and Find My from Linux
 Author: alan
 License-Expression: MIT
@@ -120,7 +120,8 @@ icloud-cli calendar delete <event-id>
 ```bash
 icloud-cli reminders list                   # All active reminders
 icloud-cli reminders list --list "Shopping" --completed
-icloud-cli reminders add -t "Buy milk" -d "2025-06-15" -l "Shopping"
+icloud-cli reminders add -t "Buy milk" -d "2025-06-15" -l "Shopping"   # bare date -> all-day reminder
+icloud-cli reminders add -t "Standup" -d "2025-06-15 09:30"            # date + time -> timed reminder
 icloud-cli reminders complete <reminder-id>
 icloud-cli reminders delete <reminder-id>
 ```

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/README.md

@@ -84,7 +84,8 @@ icloud-cli calendar delete <event-id>
 ```bash
 icloud-cli reminders list                   # All active reminders
 icloud-cli reminders list --list "Shopping" --completed
-icloud-cli reminders add -t "Buy milk" -d "2025-06-15" -l "Shopping"
+icloud-cli reminders add -t "Buy milk" -d "2025-06-15" -l "Shopping"   # bare date -> all-day reminder
+icloud-cli reminders add -t "Standup" -d "2025-06-15 09:30"            # date + time -> timed reminder
 icloud-cli reminders complete <reminder-id>
 icloud-cli reminders delete <reminder-id>
 ```

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "icloud-cli-tools"
-version = "0.1.2"
+version = "0.1.3"
 description = "Access iCloud Calendar, Reminders, Notes, and Find My from Linux"
 readme = "README.md"
 license = "MIT"

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/src/icloud_cli/__init__.py

@@ -1,3 +1,3 @@
 """icloud-cli-tools: Access iCloud services from Linux."""
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/src/icloud_cli/auth.py

@@ -87,46 +87,70 @@ class AuthManager:
         return True
 
     def _handle_2fa(self) -> bool:
-        """Handle two-factor authentication (trusted device code)."""
+        """Handle two-factor authentication (HSA2 trusted device or SMS code)."""
         info("Two-factor authentication required.")
 
         try:
-            self._api.request_2fa_code()
+            delivered = self._api.request_2fa_code()
         except Exception as e:
             error(f"Failed to trigger 2FA delivery: {e}")
             return False
 
+        if not delivered:
+            # Don't prompt for a code that never arrived. pyicloud identifies
+            # hardware-key challenges explicitly; a false return with any
+            # other method means Apple offered no supported delivery channel.
+            if self._api.two_factor_delivery_method == "security_key":
+                error(
+                    "This 2FA challenge requires a hardware security key, "
+                    "which icloud-cli does not support."
+                )
+            else:
+                error(
+                    "Apple did not offer a supported 2FA code-delivery channel. "
+                    "Check that your account has a trusted device or phone number."
+                )
+            return False
+
+        # Describe the channel we'll actually validate against. validate_2fa_code()
+        # keys off two_factor_delivery_method, so the prompt must match it — telling
+        # the user to enter the SMS code when we're verifying the trusted-device
+        # code (or vice versa) is what made the old prompt misleading.
         method = self._api.two_factor_delivery_method
         notice = self._api.two_factor_delivery_notice
 
-        if method == "trusted_device":
-            info("Approve the sign-in request on your trusted device.")
-            info("Enter the 6-digit code shown after you approve.")
-        elif method == "sms":
-            info("A verification code has been sent via SMS.")
+        if method == "sms":
+            info("Apple sent a 6-digit verification code by SMS.")
+            info("Enter the code from the text message.")
         else:
-            info("A verification code has been sent to your trusted devices.")
+            info("Apple sent a 6-digit verification code to your trusted devices.")
+            info("Enter the code shown in the trusted-device notification.")
 
         if notice:
             warning(notice)
 
-        code = click.prompt("Enter 2FA code")
+        max_attempts = 3
+        for attempt in range(max_attempts):
+            code = click.prompt("Enter 2FA code")
+            try:
+                if self._api.validate_2fa_code(code):
+                    break
+            except Exception as e:
+                error(f"2FA verification failed: {e}")
+                return False
 
-        try:
-            result = self._api.validate_2fa_code(code)
-            if not result:
+            remaining = max_attempts - attempt - 1
+            if remaining <= 0:
                 error("Invalid 2FA code.")
                 return False
+            warning(f"Invalid 2FA code. {remaining} attempt(s) remaining.")
 
-            if not self._api.is_trusted_session:
-                info("Trusting this session...")
-                self._api.trust_session()
+        if not self._api.is_trusted_session:
+            info("Trusting this session...")
+            self._api.trust_session()
 
-            success("2FA verification successful!")
-            return True
-        except Exception as e:
-            error(f"2FA verification failed: {e}")
-            return False
+        success("2FA verification successful!")
+        return True
 
     def _handle_2sa(self) -> bool:
         """Handle two-step authentication (SMS/phone-based)."""

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/src/icloud_cli/main.py

@@ -206,7 +206,13 @@ def reminders_list(ctx: AppContext, list_name: str | None, completed: bool):
 
 @reminders.command("add")
 @click.option("--title", "-t", required=True, help="Reminder title.")
-@click.option("--due", "-d", default=None, help="Due date (YYYY-MM-DD or YYYY-MM-DD HH:MM).")
+@click.option(
+    "--due",
+    "-d",
+    default=None,
+    help="Due date. A bare date (YYYY-MM-DD) creates an all-day reminder; "
+    "add a time (YYYY-MM-DD HH:MM) for a timed reminder.",
+)
 @click.option("--list", "-l", "list_name", default=None, help="Reminder list name.")
 @click.option("--description", default=None, help="Reminder description.")
 @pass_context

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/src/icloud_cli/services/reminders.py

@@ -1,6 +1,10 @@
 """Reminders service for icloud-cli.
 
 Provides CRUD operations for iCloud Reminders via pyicloud.
+
+Supports cursor-based incremental sync: the first call does a full CloudKit sync.
+Subsequent calls use iter_changes(since=cursor) to fetch only changes.
+State is persisted under config.cache_dir/reminders/.
 """
 
 from __future__ import annotations
@@ -8,7 +12,9 @@ from __future__ import annotations
 import json
 import time
 import uuid
+from contextlib import suppress
 from datetime import datetime
+from pathlib import Path
 from typing import Any
 
 from dateutil import parser as dateutil_parser
@@ -25,12 +31,20 @@ class RemindersService:
         self.config = config
         self._reminders_service = api.reminders
 
+        # Cursor-based incremental sync state
+        self._cache_dir = Path(config.cache_dir) / "reminders"
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+        self._state_file = self._cache_dir / "state.json"
+
     def list_reminders(
         self,
         list_name: str | None = None,
         show_completed: bool = False,
     ) -> list[dict[str, Any]]:
-        """List reminders, optionally filtered by list.
+        """List reminders with cursor-based incremental sync.
+
+        First call triggers a full CloudKit sync (~5 min for 200 reminders).
+        Subsequent calls fetch only changes since the last cursor (~1s).
 
         Args:
             list_name: Filter to specific reminder list.
@@ -39,45 +53,122 @@ class RemindersService:
         Returns:
             List of reminder dictionaries.
         """
+
+        state = self._load_sync_state()
+
         try:
-            lists = list(self._reminders_service.lists())
+            rlists = list(self._reminders_service.lists())
+            list_map = {lst.id: lst.title for lst in rlists}
+
+            # Capture an upper bound before reading any reminder records. If a
+            # change arrives while the read is in progress, keeping this older
+            # cursor makes the next invocation replay that change safely.
+            next_cursor = self._reminders_service.sync_cursor()
+
+            if state is None:
+                data_map = self._full_reminder_snapshot(rlists, list_map)
+            else:
+                cursor, cached_data = state
+                data_map = {entry["id"]: entry for entry in cached_data}
+
+                # List changes are not emitted by iter_changes(), so refresh
+                # cached display names from the lightweight list snapshot.
+                for entry in data_map.values():
+                    entry_list_id = entry.get("list_id")
+                    if entry_list_id:
+                        entry["list"] = list_map.get(entry_list_id, entry_list_id)
+
+                try:
+                    for change in self._reminders_service.iter_changes(since=cursor):
+                        reminder_id = change.reminder_id
+                        reminder = change.reminder
+                        if change.type == "deleted" or not reminder or reminder.deleted:
+                            data_map.pop(reminder_id, None)
+                            continue
+
+                        list_title = list_map.get(reminder.list_id, reminder.list_id)
+                        data_map[reminder_id] = self._reminder_to_entry(
+                            reminder, list_title
+                        )
+                except Exception:
+                    # An expired or account-mismatched cursor requires a fresh
+                    # snapshot. next_cursor was captured before this read, so
+                    # later changes will still be replayed on the next call.
+                    data_map = self._full_reminder_snapshot(rlists, list_map)
         except Exception as e:
             from icloud_cli.output import error
             error(f"Failed to fetch reminders: {e}")
             return []
 
-        result = []
-        for rlist in lists:
-            rlist_title = rlist.title
-            rlist_id = rlist.id
+        cached_data = list(data_map.values())
+        # The old state remains intact on failure because replacement is
+        # atomic, so the next invocation replays from its older cursor.
+        with suppress(OSError):
+            self._write_sync_state(next_cursor, cached_data)
 
-            if list_name and rlist_title.lower() != list_name.lower():
+        result = []
+        for cached_entry in cached_data:
+            entry = {key: value for key, value in cached_entry.items() if key != "list_id"}
+            if list_name and entry["list"].lower() != list_name.lower():
                 continue
+            if not show_completed and entry["completed"]:
+                continue
+            result.append(entry)
+        return result
 
-            reminders = list(self._reminders_service.reminders(list_id=rlist_id))
+    def _load_sync_state(self) -> tuple[str, list[dict[str, Any]]] | None:
+        """Load a complete cursor/data generation, or request a full sync."""
+        if not self._state_file.exists():
+            return None
+        try:
+            state = json.loads(self._state_file.read_text())
+            if state.get("version") != 1 or state.get("account") != self.config.apple_id:
+                return None
+            cursor = state["cursor"]
+            entries = state["entries"]
+            entries_are_valid = isinstance(entries, list) and all(
+                isinstance(entry, dict)
+                and isinstance(entry.get("id"), str)
+                and isinstance(entry.get("list_id"), str)
+                for entry in entries
+            )
+            if not isinstance(cursor, str) or not entries_are_valid:
+                return None
+            return cursor, entries
+        except (json.JSONDecodeError, KeyError, OSError, TypeError, AttributeError):
+            return None
 
-            for reminder in reminders:
-                if not show_completed and reminder.completed:
+    def _write_sync_state(self, cursor: str, entries: list[dict[str, Any]]) -> None:
+        """Atomically persist cursor and entries as one cache generation."""
+        state = {
+            "version": 1,
+            "account": self.config.apple_id,
+            "cursor": cursor,
+            "entries": entries,
+        }
+        temp_file = self._state_file.with_name(
+            f".{self._state_file.name}.{uuid.uuid4().hex}.tmp"
+        )
+        try:
+            temp_file.write_text(json.dumps(state, indent=2))
+            temp_file.replace(self._state_file)
+        finally:
+            if temp_file.exists():
+                temp_file.unlink()
+
+    def _full_reminder_snapshot(
+        self, rlists: list[Any], list_map: dict[str, str]
+    ) -> dict[str, dict[str, Any]]:
+        """Fetch a complete deduplicated reminder snapshot."""
+        data_map: dict[str, dict[str, Any]] = {}
+        for rlist in rlists:
+            for reminder in self._reminders_service.reminders(list_id=rlist.id):
+                if getattr(reminder, "deleted", False):
                     continue
-
-                due_date = ""
-                if reminder.due_date:
-                    due_date = _format_due_date(reminder.due_date)
-
-                priority_map = {0: "", 1: "High", 5: "Medium", 9: "Low"}
-                priority = priority_map.get(reminder.priority, "")
-
-                result.append({
-                    "id": reminder.id,
-                    "title": reminder.title,
-                    "list": rlist_title,
-                    "due_date": due_date,
-                    "priority": priority,
-                    "completed": "✓" if reminder.completed else "",
-                    "description": reminder.desc,
-                })
-
-        return result
+                data_map[reminder.id] = self._reminder_to_entry(
+                    reminder, list_map.get(reminder.list_id, reminder.list_id)
+                )
+        return data_map
 
     def list_reminder_lists(self) -> list[dict[str, Any]]:
         """List reminder lists."""
@@ -249,12 +340,15 @@ class RemindersService:
                 error("No reminder lists found.")
                 return False
 
-            # Parse due date
+            # Parse due date. When the user gives a bare date with no time
+            # (e.g. "2025-06-15"), create an all-day reminder so it shows the
+            # date without a "12:00 AM" time, matching the Reminders app.
             due: datetime | None = None
+            all_day = False
             if due_date:
                 try:
-                    due = dateutil_parser.parse(due_date)
-                except (ValueError, TypeError):
+                    due, all_day = _parse_due_date(due_date)
+                except (ValueError, TypeError, OverflowError):
                     from icloud_cli.output import error
                     error("Invalid date format. Use YYYY-MM-DD or YYYY-MM-DD HH:MM.")
                     return False
@@ -264,6 +358,7 @@ class RemindersService:
                 title=title,
                 desc=description or "",
                 due_date=due,
+                all_day=all_day,
                 priority=0,
             )
             return True
@@ -273,6 +368,27 @@ class RemindersService:
             error(f"Failed to create reminder: {e}")
             return False
 
+    @staticmethod
+    def _reminder_to_entry(r, list_title: str) -> dict[str, Any]:
+        """Convert a pyicloud Reminder model to the icloud-cli dict format."""
+        priority_map = {0: "", 1: "High", 5: "Medium", 9: "Low"}
+        due_date = ""
+        if r.due_date:
+            due_date = _format_due_date(
+                r.due_date,
+                date_only=bool(getattr(r, "all_day", False)),
+            )
+        return {
+            "id": r.id,
+            "list_id": r.list_id,
+            "title": r.title,
+            "list": list_title,
+            "due_date": due_date,
+            "priority": priority_map.get(r.priority, ""),
+            "completed": "✓" if r.completed else "",
+            "description": r.desc,
+        }
+
     def _find_list_id(self, list_name: str) -> str | None:
         for rlist in self._reminders_service.lists():
             if rlist.title.lower() == list_name.lower() or rlist.id == list_name:
@@ -350,29 +466,66 @@ class RemindersService:
             return False
 
 
-def _format_due_date(due_date: Any) -> str:
-    """Format a due date from the API response."""
+def _parse_due_date(due_date: str) -> tuple[datetime, bool]:
+    """Parse a due-date string, detecting whether a time was supplied.
+
+    Returns a ``(datetime, all_day)`` tuple. When the input carries no time
+    component the reminder is treated as all-day and anchored to noon so the
+    stored calendar date stays stable across time zones (pyicloud persists a
+    naive datetime as UTC).
+
+    Date fields the user omits fall back to today, matching ``dateutil``'s
+    default. The two parse defaults share the same date and differ only in
+    their time fields, so a time the user actually typed resolves identically
+    against both while a time left to the default does not -- that is what
+    distinguishes a bare date from a timed one.
+    """
+    today = datetime.now()
+    default_a = today.replace(hour=0, minute=0, second=0, microsecond=0)
+    default_b = today.replace(hour=23, minute=59, second=58, microsecond=0)
+    parsed_a = dateutil_parser.parse(due_date, default=default_a)
+    parsed_b = dateutil_parser.parse(due_date, default=default_b)
+    has_time = (
+        parsed_a.hour == parsed_b.hour
+        or parsed_a.minute == parsed_b.minute
+        or parsed_a.second == parsed_b.second
+    )
+    if has_time:
+        return parsed_a, False
+    anchored = parsed_a.replace(hour=12, minute=0, second=0, microsecond=0)
+    return anchored, True
+
+
+def _format_due_date(due_date: Any, date_only: bool = False) -> str:
+    """Format a due date from the API response.
+
+    When ``date_only`` is True (all-day reminders), the time component is
+    omitted so the reminder shows just its date.
+    """
+    fmt = "%Y-%m-%d" if date_only else "%Y-%m-%d %H:%M"
     if isinstance(due_date, str):
         try:
             dt = dateutil_parser.parse(due_date)
-            return dt.strftime("%Y-%m-%d %H:%M")
+            return dt.strftime(fmt)
         except (ValueError, TypeError):
             return due_date
-    if isinstance(due_date, list) and len(due_date) >= 4:
+    if isinstance(due_date, list) and len(due_date) >= 5:
         # iCloud format: [year, month, day, hour, minute]
         try:
             date_part = f"{due_date[0]:04d}-{due_date[1]:02d}-{due_date[2]:02d}"
+            if date_only:
+                return date_part
             time_part = f"{due_date[3]:02d}:{due_date[4]:02d}"
             return f"{date_part} {time_part}"
         except (IndexError, TypeError):
             return str(due_date)
     if isinstance(due_date, (int, float)):
         try:
-            return datetime.fromtimestamp(due_date / 1000).strftime("%Y-%m-%d %H:%M")
+            return datetime.fromtimestamp(due_date / 1000).strftime(fmt)
         except (ValueError, OSError):
             return str(due_date)
     if isinstance(due_date, datetime):
-        return due_date.strftime("%Y-%m-%d %H:%M")
+        return due_date.strftime(fmt)
     return str(due_date)
 
 

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3/src/icloud_cli_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: icloud-cli-tools
-Version: 0.1.2
+Version: 0.1.3
 Summary: Access iCloud Calendar, Reminders, Notes, and Find My from Linux
 Author: alan
 License-Expression: MIT
@@ -120,7 +120,8 @@ icloud-cli calendar delete <event-id>
 ```bash
 icloud-cli reminders list                   # All active reminders
 icloud-cli reminders list --list "Shopping" --completed
-icloud-cli reminders add -t "Buy milk" -d "2025-06-15" -l "Shopping"
+icloud-cli reminders add -t "Buy milk" -d "2025-06-15" -l "Shopping"   # bare date -> all-day reminder
+icloud-cli reminders add -t "Standup" -d "2025-06-15 09:30"            # date + time -> timed reminder
 icloud-cli reminders complete <reminder-id>
 icloud-cli reminders delete <reminder-id>
 ```

icloud_cli_tools-0.1.3/tests/test_auth.py

@@ -0,0 +1,207 @@
+"""Tests for the auth module."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from icloud_cli.auth import AuthManager
+from icloud_cli.config import Config
+
+
+class TestAuthManager:
+    """Tests for AuthManager."""
+
+    def test_get_status_not_logged_in(self, tmp_path):
+        """Status shows not logged in when no credentials stored."""
+        config = Config(
+            apple_id="",
+            session_dir=str(tmp_path / "session"),
+            config_file=tmp_path / "config.toml",
+        )
+        auth = AuthManager(config)
+        status = auth.get_status()
+
+        assert status["apple_id"] == "(not set)"
+        assert status["password_stored"] == "No"
+        assert status["session_cached"] == "No"
+
+    @patch("icloud_cli.auth.keyring")
+    def test_get_status_logged_in(self, mock_keyring, tmp_path):
+        """Status shows logged in when credentials are stored."""
+        config = Config(
+            apple_id="test@icloud.com",
+            session_dir=str(tmp_path / "session"),
+            config_file=tmp_path / "config.toml",
+        )
+        # Create a session file
+        session_dir = tmp_path / "session"
+        session_dir.mkdir(parents=True)
+        (session_dir / "session_cookie").write_text("fake_cookie")
+
+        mock_keyring.get_password.return_value = "stored_password"
+
+        auth = AuthManager(config)
+        status = auth.get_status()
+
+        assert status["apple_id"] == "test@icloud.com"
+        assert status["password_stored"] == "Yes"
+        assert status["session_cached"] == "Yes"
+
+    @patch("icloud_cli.auth.keyring")
+    def test_logout_clears_session(self, mock_keyring, tmp_path):
+        """Logout clears session files."""
+        config = Config(
+            apple_id="test@icloud.com",
+            session_dir=str(tmp_path / "session"),
+            config_file=tmp_path / "config.toml",
+        )
+        session_dir = tmp_path / "session"
+        session_dir.mkdir(parents=True)
+        (session_dir / "cookie1").write_text("data")
+        (session_dir / "cookie2").write_text("data")
+
+        mock_keyring.delete_password.return_value = None
+
+        auth = AuthManager(config)
+        auth.logout()
+
+        # Session files should be cleared
+        assert list(session_dir.iterdir()) == []
+
+    @patch("icloud_cli.auth.keyring")
+    def test_has_no_cached_session(self, mock_keyring, tmp_path):
+        """Reports no session when session dir is empty."""
+        config = Config(
+            apple_id="test@icloud.com",
+            session_dir=str(tmp_path / "session"),
+            config_file=tmp_path / "config.toml",
+        )
+        (tmp_path / "session").mkdir(parents=True)
+
+        mock_keyring.get_password.return_value = None
+
+        auth = AuthManager(config)
+        assert not auth._has_cached_session()
+
+    @patch("icloud_cli.auth.keyring")
+    def test_imap_credentials_not_set(self, mock_keyring, tmp_path):
+        """Returns None when IMAP credentials are not configured."""
+        config = Config(
+            apple_id="test@icloud.com",
+            session_dir=str(tmp_path / "session"),
+            config_file=tmp_path / "config.toml",
+        )
+        mock_keyring.get_password.return_value = None
+
+        auth = AuthManager(config)
+        assert auth.get_imap_credentials() is None
+
+
+class TestHandle2FA:
+    """Tests for the interactive 2FA prompt flow."""
+
+    def _make_auth(self, tmp_path, api):
+        config = Config(
+            apple_id="test@icloud.com",
+            session_dir=str(tmp_path / "session"),
+            config_file=tmp_path / "config.toml",
+        )
+        auth = AuthManager(config)
+        auth._api = api
+        return auth
+
+    @patch("icloud_cli.auth.click")
+    def test_security_key_challenge_does_not_prompt(self, mock_click, tmp_path):
+        """When request_2fa_code() returns False, no code is requested."""
+        api = MagicMock()
+        api.request_2fa_code.return_value = False
+        api.two_factor_delivery_method = "security_key"
+        auth = self._make_auth(tmp_path, api)
+
+        assert auth._handle_2fa() is False
+        api.request_2fa_code.assert_called_once()
+        # No code should be prompted for or validated when nothing was delivered.
+        mock_click.prompt.assert_not_called()
+        api.validate_2fa_code.assert_not_called()
+
+    @patch("icloud_cli.auth.error")
+    @patch("icloud_cli.auth.click")
+    def test_missing_delivery_channel_has_accurate_error(
+        self, mock_click, mock_error, tmp_path
+    ):
+        """A missing delivery route is not misreported as a security-key challenge."""
+        api = MagicMock()
+        api.request_2fa_code.return_value = False
+        api.two_factor_delivery_method = "unknown"
+        auth = self._make_auth(tmp_path, api)
+
+        assert auth._handle_2fa() is False
+        message = str(mock_error.call_args.args[0]).lower()
+        assert "delivery channel" in message
+        assert "hardware security key" not in message
+        mock_click.prompt.assert_not_called()
+
+    @patch("icloud_cli.auth.click")
+    def test_trusted_device_success(self, mock_click, tmp_path):
+        """A valid trusted-device code trusts the session and succeeds."""
+        api = MagicMock()
+        api.request_2fa_code.return_value = True
+        api.two_factor_delivery_method = "trusted_device"
+        api.two_factor_delivery_notice = None
+        api.validate_2fa_code.return_value = True
+        api.is_trusted_session = False
+        auth = self._make_auth(tmp_path, api)
+        mock_click.prompt.return_value = "123456"
+
+        assert auth._handle_2fa() is True
+        api.validate_2fa_code.assert_called_once_with("123456")
+        api.trust_session.assert_called_once()
+
+    @patch("icloud_cli.auth.info")
+    @patch("icloud_cli.auth.click")
+    def test_prompt_text_matches_delivery_channel(self, mock_click, mock_info, tmp_path):
+        """The prompt describes the trusted-device channel without an approve step."""
+        api = MagicMock()
+        api.request_2fa_code.return_value = True
+        api.two_factor_delivery_method = "trusted_device"
+        api.two_factor_delivery_notice = None
+        api.validate_2fa_code.return_value = True
+        api.is_trusted_session = True
+        auth = self._make_auth(tmp_path, api)
+        mock_click.prompt.return_value = "123456"
+
+        auth._handle_2fa()
+
+        messages = " ".join(str(c.args[0]) for c in mock_info.call_args_list).lower()
+        assert "approve" not in messages
+        assert "trusted device" in messages
+
+    @patch("icloud_cli.auth.click")
+    def test_retries_then_succeeds(self, mock_click, tmp_path):
+        """A mistyped code is retried instead of forcing a re-login."""
+        api = MagicMock()
+        api.request_2fa_code.return_value = True
+        api.two_factor_delivery_method = "sms"
+        api.two_factor_delivery_notice = None
+        api.validate_2fa_code.side_effect = [False, True]
+        api.is_trusted_session = True
+        auth = self._make_auth(tmp_path, api)
+        mock_click.prompt.return_value = "000000"
+
+        assert auth._handle_2fa() is True
+        assert api.validate_2fa_code.call_count == 2
+
+    @patch("icloud_cli.auth.click")
+    def test_invalid_code_exhausts_attempts(self, mock_click, tmp_path):
+        """After three wrong codes the flow fails without trusting the session."""
+        api = MagicMock()
+        api.request_2fa_code.return_value = True
+        api.two_factor_delivery_method = "trusted_device"
+        api.two_factor_delivery_notice = None
+        api.validate_2fa_code.return_value = False
+        auth = self._make_auth(tmp_path, api)
+        mock_click.prompt.return_value = "000000"
+
+        assert auth._handle_2fa() is False
+        assert api.validate_2fa_code.call_count == 3
+        api.trust_session.assert_not_called()

{icloud_cli_tools-0.1.2 → icloud_cli_tools-0.1.3}/tests/test_reminders.py

@@ -5,9 +5,12 @@ from __future__ import annotations
 from datetime import datetime
 from unittest.mock import MagicMock, patch
 
+import pytest
+
 from icloud_cli.services.reminders import (
     RemindersService,
     _format_due_date,
+    _parse_due_date,
     _reminders_color_payload,
 )
 
@@ -51,14 +54,53 @@ class TestFormatDueDate:
         result = _format_due_date(None)
         assert result == "None"
 
+    def test_format_date_only_omits_time(self):
+        result = _format_due_date(datetime(2025, 6, 15, 14, 30), date_only=True)
+        assert result == "2025-06-15"
+
+    def test_format_date_only_list(self):
+        result = _format_due_date([2025, 6, 15, 14, 30], date_only=True)
+        assert result == "2025-06-15"
+
     def test_color_payload_defaults_unknown_color_to_blue(self):
         assert _reminders_color_payload("wat") == _reminders_color_payload("blue")
 
 
+class TestParseDueDate:
+    """Tests for due-date parsing and all-day detection."""
+
+    def test_bare_date_is_all_day_anchored_to_noon(self):
+        due, all_day = _parse_due_date("2025-06-15")
+        assert all_day is True
+        assert (due.year, due.month, due.day) == (2025, 6, 15)
+        assert (due.hour, due.minute, due.second) == (12, 0, 0)
+
+    def test_date_with_time_is_not_all_day(self):
+        due, all_day = _parse_due_date("2025-06-15 14:30")
+        assert all_day is False
+        assert (due.hour, due.minute) == (14, 30)
+
+    def test_explicit_midnight_is_not_all_day(self):
+        # A user who explicitly types 00:00 wants a timed reminder.
+        due, all_day = _parse_due_date("2025-06-15 00:00")
+        assert all_day is False
+        assert (due.hour, due.minute) == (0, 0)
+
+    def test_year_omitted_defaults_to_current_year(self):
+        # Regression: a date without a year should fall back to the current
+        # year, not a hardcoded one.
+        due, all_day = _parse_due_date("June 15")
+        assert all_day is True
+        assert due.year == datetime.now().year
+        assert (due.month, due.day) == (6, 15)
+
+
 class TestRemindersService:
     """Tests for RemindersService with mocked API."""
 
     def _make_service(self, mock_api, mock_config):
+        mock_api.reminders.sync_cursor.return_value = "cursor-1"
+        mock_api.reminders.iter_changes.return_value = []
         return RemindersService(mock_api, mock_config)
 
     def _make_list_model(self, list_id="list-1", title="Personal"):
@@ -83,8 +125,17 @@ class TestRemindersService:
         r.desc = desc
         r.list_id = "list-1"
         r.flagged = False
+        r.all_day = False
+        r.deleted = False
         return r
 
+    def _make_change(self, reminder=None, change_type="updated", reminder_id=None):
+        change = MagicMock()
+        change.type = change_type
+        change.reminder = reminder
+        change.reminder_id = reminder_id or reminder.id
+        return change
+
     def test_list_reminders_empty(self, mock_api, mock_config):
         mock_api.reminders.lists.return_value = []
         mock_api.reminders.reminders.return_value = []
@@ -110,6 +161,32 @@ class TestRemindersService:
         assert result[0]["list"] == "Personal"
         assert result[0]["priority"] == "High"
 
+    def test_list_reminders_all_day_omits_time(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+
+        reminder = self._make_reminder_model(due_date=datetime(2025, 6, 15, 12, 0))
+        reminder.all_day = True
+        mock_api.reminders.reminders.return_value = [reminder]
+
+        service = self._make_service(mock_api, mock_config)
+        result = service.list_reminders()
+
+        assert result[0]["due_date"] == "2025-06-15"
+
+    def test_list_reminders_timed_shows_time(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+
+        reminder = self._make_reminder_model(due_date=datetime(2025, 6, 15, 9, 30))
+        reminder.all_day = False
+        mock_api.reminders.reminders.return_value = [reminder]
+
+        service = self._make_service(mock_api, mock_config)
+        result = service.list_reminders()
+
+        assert result[0]["due_date"] == "2025-06-15 09:30"
+
     def test_list_reminders_filters_completed(self, mock_api, mock_config):
         lst = self._make_list_model(list_id="list-1", title="Work")
         mock_api.reminders.lists.return_value = [lst]
@@ -133,6 +210,92 @@ class TestRemindersService:
         result = service.list_reminders(show_completed=True)
         assert len(result) == 2
 
+    def test_empty_snapshot_uses_incremental_sync_next_time(self, mock_api, mock_config):
+        mock_api.reminders.lists.return_value = []
+        service = self._make_service(mock_api, mock_config)
+
+        assert service.list_reminders() == []
+        assert service.list_reminders() == []
+
+        mock_api.reminders.iter_changes.assert_called_once_with(since="cursor-1")
+
+    def test_incremental_sync_applies_updates_and_deletions(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+        old = self._make_reminder_model(reminder_id="rem-1", title="Old title")
+        removed = self._make_reminder_model(reminder_id="rem-2", title="Remove me")
+        mock_api.reminders.reminders.return_value = [old, removed]
+        service = self._make_service(mock_api, mock_config)
+        assert len(service.list_reminders()) == 2
+
+        updated = self._make_reminder_model(reminder_id="rem-1", title="New title")
+        mock_api.reminders.iter_changes.return_value = [
+            self._make_change(updated),
+            self._make_change(None, "deleted", "rem-2"),
+        ]
+
+        result = service.list_reminders()
+
+        assert [entry["title"] for entry in result] == ["New title"]
+
+    def test_list_rename_refreshes_cached_entries(self, mock_api, mock_config):
+        original_list = self._make_list_model(title="Personal")
+        mock_api.reminders.lists.return_value = [original_list]
+        mock_api.reminders.reminders.return_value = [self._make_reminder_model()]
+        service = self._make_service(mock_api, mock_config)
+        assert service.list_reminders()[0]["list"] == "Personal"
+
+        renamed_list = self._make_list_model(title="Renamed")
+        mock_api.reminders.lists.return_value = [renamed_list]
+
+        assert service.list_reminders()[0]["list"] == "Renamed"
+
+    def test_cursor_is_captured_before_incremental_read(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+        mock_api.reminders.reminders.return_value = [self._make_reminder_model()]
+        service = self._make_service(mock_api, mock_config)
+        service.list_reminders()
+        mock_api.reminders.reset_mock()
+        mock_api.reminders.lists.return_value = [lst]
+        mock_api.reminders.sync_cursor.return_value = "cursor-2"
+        mock_api.reminders.iter_changes.return_value = []
+
+        service.list_reminders()
+
+        method_names = [call[0] for call in mock_api.reminders.method_calls]
+        assert method_names.index("sync_cursor") < method_names.index("iter_changes")
+
+    def test_invalid_cursor_falls_back_to_full_snapshot(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+        original = self._make_reminder_model(title="Original")
+        mock_api.reminders.reminders.return_value = [original]
+        service = self._make_service(mock_api, mock_config)
+        service.list_reminders()
+
+        refreshed = self._make_reminder_model(title="Refreshed")
+        mock_api.reminders.reminders.return_value = [refreshed]
+        mock_api.reminders.iter_changes.side_effect = RuntimeError("expired cursor")
+
+        result = service.list_reminders()
+
+        assert result[0]["title"] == "Refreshed"
+
+    def test_atomic_state_failure_preserves_previous_generation(
+        self, mock_api, mock_config
+    ):
+        service = self._make_service(mock_api, mock_config)
+        service._write_sync_state("cursor-1", [])
+
+        with (
+            patch("pathlib.Path.replace", side_effect=OSError("disk full")),
+            pytest.raises(OSError),
+        ):
+            service._write_sync_state("cursor-2", [{"id": "rem-1"}])
+
+        assert service._load_sync_state() == ("cursor-1", [])
+
     def test_add_reminder_success(self, mock_api, mock_config):
         lst = self._make_list_model()
         mock_api.reminders.lists.return_value = [lst]
@@ -142,6 +305,45 @@ class TestRemindersService:
         assert service.add_reminder(title="New task") is True
         mock_api.reminders.create.assert_called_once()
 
+    def test_add_reminder_bare_date_is_all_day(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+        mock_api.reminders.create.return_value = MagicMock()
+
+        service = self._make_service(mock_api, mock_config)
+        assert service.add_reminder(title="Pay rent", due_date="2025-06-15") is True
+
+        call_kwargs = mock_api.reminders.create.call_args[1]
+        assert call_kwargs["all_day"] is True
+        assert call_kwargs["due_date"].hour == 12
+        assert (
+            call_kwargs["due_date"].year,
+            call_kwargs["due_date"].month,
+            call_kwargs["due_date"].day,
+        ) == (2025, 6, 15)
+
+    def test_add_reminder_with_time_is_not_all_day(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+        mock_api.reminders.create.return_value = MagicMock()
+
+        service = self._make_service(mock_api, mock_config)
+        assert (
+            service.add_reminder(title="Standup", due_date="2025-06-15 09:30") is True
+        )
+
+        call_kwargs = mock_api.reminders.create.call_args[1]
+        assert call_kwargs["all_day"] is False
+        assert (call_kwargs["due_date"].hour, call_kwargs["due_date"].minute) == (9, 30)
+
+    def test_add_reminder_invalid_date_returns_false(self, mock_api, mock_config):
+        lst = self._make_list_model()
+        mock_api.reminders.lists.return_value = [lst]
+
+        service = self._make_service(mock_api, mock_config)
+        assert service.add_reminder(title="Bad", due_date="not-a-date") is False
+        mock_api.reminders.create.assert_not_called()
+
     def test_add_reminder_with_list_name(self, mock_api, mock_config):
         lst1 = self._make_list_model(list_id="list-1", title="Personal")
         lst2 = self._make_list_model(list_id="list-2", title="Shopping")

icloud_cli_tools-0.1.2/tests/test_auth.py

@@ -1,97 +0,0 @@
-"""Tests for the auth module."""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-
-from icloud_cli.auth import AuthManager
-from icloud_cli.config import Config
-
-
-class TestAuthManager:
-    """Tests for AuthManager."""
-
-    def test_get_status_not_logged_in(self, tmp_path):
-        """Status shows not logged in when no credentials stored."""
-        config = Config(
-            apple_id="",
-            session_dir=str(tmp_path / "session"),
-            config_file=tmp_path / "config.toml",
-        )
-        auth = AuthManager(config)
-        status = auth.get_status()
-
-        assert status["apple_id"] == "(not set)"
-        assert status["password_stored"] == "No"
-        assert status["session_cached"] == "No"
-
-    @patch("icloud_cli.auth.keyring")
-    def test_get_status_logged_in(self, mock_keyring, tmp_path):
-        """Status shows logged in when credentials are stored."""
-        config = Config(
-            apple_id="test@icloud.com",
-            session_dir=str(tmp_path / "session"),
-            config_file=tmp_path / "config.toml",
-        )
-        # Create a session file
-        session_dir = tmp_path / "session"
-        session_dir.mkdir(parents=True)
-        (session_dir / "session_cookie").write_text("fake_cookie")
-
-        mock_keyring.get_password.return_value = "stored_password"
-
-        auth = AuthManager(config)
-        status = auth.get_status()
-
-        assert status["apple_id"] == "test@icloud.com"
-        assert status["password_stored"] == "Yes"
-        assert status["session_cached"] == "Yes"
-
-    @patch("icloud_cli.auth.keyring")
-    def test_logout_clears_session(self, mock_keyring, tmp_path):
-        """Logout clears session files."""
-        config = Config(
-            apple_id="test@icloud.com",
-            session_dir=str(tmp_path / "session"),
-            config_file=tmp_path / "config.toml",
-        )
-        session_dir = tmp_path / "session"
-        session_dir.mkdir(parents=True)
-        (session_dir / "cookie1").write_text("data")
-        (session_dir / "cookie2").write_text("data")
-
-        mock_keyring.delete_password.return_value = None
-
-        auth = AuthManager(config)
-        auth.logout()
-
-        # Session files should be cleared
-        assert list(session_dir.iterdir()) == []
-
-    @patch("icloud_cli.auth.keyring")
-    def test_has_no_cached_session(self, mock_keyring, tmp_path):
-        """Reports no session when session dir is empty."""
-        config = Config(
-            apple_id="test@icloud.com",
-            session_dir=str(tmp_path / "session"),
-            config_file=tmp_path / "config.toml",
-        )
-        (tmp_path / "session").mkdir(parents=True)
-
-        mock_keyring.get_password.return_value = None
-
-        auth = AuthManager(config)
-        assert not auth._has_cached_session()
-
-    @patch("icloud_cli.auth.keyring")
-    def test_imap_credentials_not_set(self, mock_keyring, tmp_path):
-        """Returns None when IMAP credentials are not configured."""
-        config = Config(
-            apple_id="test@icloud.com",
-            session_dir=str(tmp_path / "session"),
-            config_file=tmp_path / "config.toml",
-        )
-        mock_keyring.get_password.return_value = None
-
-        auth = AuthManager(config)
-        assert auth.get_imap_credentials() is None