Live integration smoke + fix create_folder_recursive cache bug

Live smoke test (tests/test_live_smoke.py) found a real cache-coherency
bug that all the unit-mocked tests missed:

create_folder_recursive() called self.api.create_folder() directly for
intermediate folders (e.g. 'A' and 'B' in '/A/B/C'). That bypasses the
parent-folder cache update that self.create_folder() performs, leaving
the parent cache stale. Subsequent resolve_path() walks then hit the
stale root cache and raised FileNotFoundError, even though the folders
definitely existed on the server.

Fixed by routing all parts through self.create_folder so every parent
cache stays in sync. Only the final part receives timestamp args.

Live smoke design:
- Auto-skips unless IXT_ACCOUNT and IXT_PWD are set in env (or .env).
- All operations confined to /__pytest_internxt_cli_smoke__/<run-uuid>/
  with a fresh UUID per run.
- try/finally cleanup trashes the sentinel folder at module teardown,
  even on assertion failure.
- No cassette recording — bytes/responses live only in memory; nothing
  about the user's account is written to the repo.
- 4 tests: login+whoami, list root, full upload→list→download cycle
  with byte-for-byte verification, path resolution.

.gitignore now excludes .env / .env.* (with .env.example escape hatch).
.env was never tracked; verified before push.

requirements-dev.txt: added python-dotenv (optional; tests fall back to
a built-in parser if not installed).

Updated test_create_folder_recursive_creates_missing_parts to match
the new (correct) cache-invalidating behavior; added regression note
referencing the live-smoke discovery.

CHANGELOG.md and readme.md updated with the new bug entry and live-
smoke documentation.

Stats: 557/557 unit tests + 4/4 live tests pass; 90% coverage holds.

Author: CrispStrobe

.gitignore

@@ -23,3 +23,8 @@ env/
 # Editor
 .vscode/
 .idea/
+
+# Secrets — never commit
+.env
+.env.*
+!.env.example

CHANGELOG.md

@@ -30,7 +30,23 @@ End state: **0 ruff errors, 0 mypy errors, 0 Bandit medium+ findings,
    `import internxt_cli` raised `SyntaxError`.
    **Fixed:** added the missing triple-quote.
 
-3. **`services/webdav_provider.py:set_property` — every PROPPATCH crashed**
+3. **`services/drive.py:create_folder_recursive` — stale parent cache after intermediate folder creation** *(found by live integration test)*
+   When creating intermediate folders for a nested path like
+   `/A/B/C`, the function called `self.api.create_folder` directly,
+   which does **not** invalidate the parent folder's content cache. The
+   final folder went through `self.create_folder` (which does update the
+   cache), but by then the parent caches for `A` and `B` were stale.
+   Subsequent `resolve_path()` calls would walk the tree using the stale
+   root cache and fail with `FileNotFoundError`, even though the folder
+   chain definitely existed on the server. This was masked in unit
+   tests by stubbing `get_folder_content` directly. **Caught only when
+   the live smoke test (`tests/test_live_smoke.py`) ran the create →
+   resolve cycle against the real backend.**
+   **Fixed:** route all parts (intermediate + final) through
+   `self.create_folder` so every parent cache stays in sync; only the
+   final part receives timestamp arguments.
+
+4. **`services/webdav_provider.py:set_property` — every PROPPATCH crashed**
    This is the handler macOS Finder and Windows Explorer use to set
    creation/modification times on remote folders. Two broken pieces:
    - It imported `rfc_1123_to_timestamp` and `rfc_3339_to_timestamp` from
@@ -253,10 +269,42 @@ The trust roots (auth + crypto) are at 100%. The remaining gaps in
 diagnostic branches that are best exercised by integration tests against
 a live Internxt backend, not more unit mocks.
 
-#### Not yet covered (intentional)
-
-- A vcrpy-recorded contract test against the real Internxt API for one
-  full upload→download cycle. Needs test credentials and a one-time
-  recording session; would lock in the exact wire-format expectations of
-  the production backend so future API changes fail the test in CI
-  rather than in the field.
+#### Live integration smoke test
+
+`tests/test_live_smoke.py` — opt-in test that runs against the real
+Internxt backend. Auto-skipped unless `IXT_ACCOUNT` and `IXT_PWD` are
+set in env (or in a gitignored `.env` file). Safety properties:
+
+- All operations happen under a **sentinel folder**
+  `/__pytest_internxt_cli_smoke__/<run-uuid>/` with a fresh UUID per
+  run. Nothing outside that prefix is touched.
+- A try/finally cleanup trashes the entire sentinel folder at module
+  teardown, even on test failure.
+- **No cassette recording** — bytes and responses live only in memory;
+  nothing about the user's account is written to the repo.
+
+Tests covered:
+1. Login + whoami (read-only)
+2. List root folder (read-only)
+3. End-to-end cycle: create folder → upload → list → download → assert
+   byte-for-byte recovery
+4. Path resolution against the live folder tree
+
+To run:
+
+```bash
+# Once: put creds in .env (gitignored)
+echo 'IXT_ACCOUNT=you@example.com' > .env
+echo 'IXT_PWD=your-password' >> .env
+
+# Run the live smoke
+pytest tests/test_live_smoke.py -v -s
+
+# Force-skip (e.g., in CI)
+PYTEST_SKIP_LIVE=1 pytest
+```
+
+This test surfaced the `create_folder_recursive` cache-coherency bug
+listed above (item 3 in the Critical bug-fix section), which all the
+unit-mocked tests missed because they stubbed `get_folder_content`
+directly.

readme.md

@@ -330,6 +330,24 @@ Per-module coverage:
 See [`CHANGELOG.md`](CHANGELOG.md) for the full audit summary and the
 list of bugs found and fixed during the test build-out.
 
+#### Live integration smoke (optional)
+
+`tests/test_live_smoke.py` runs an end-to-end cycle (login → create
+folder → upload → list → download → verify bytes → trash) against the
+real Internxt backend. Auto-skipped unless credentials are present.
+
+```bash
+# Put creds in a .env file (gitignored — never committed)
+echo 'IXT_ACCOUNT=you@example.com' > .env
+echo 'IXT_PWD=your-password' >> .env
+
+pytest tests/test_live_smoke.py -v -s
+```
+
+All operations happen inside a unique sentinel folder
+(`/__pytest_internxt_cli_smoke__/<run-uuid>/`) which is always trashed
+at teardown — your real files are never touched.
+
 ### Quality Gates
 
 The CI runs four gates on every push/PR:

requirements-dev.txt

@@ -5,3 +5,7 @@ pytest-cov>=4.1.0
 ruff>=0.1.0
 mypy>=1.5.0
 bandit>=1.7.0
+
+# Optional: load IXT_ACCOUNT/IXT_PWD from .env for the live smoke test
+# (tests fall back to a built-in parser if not installed)
+python-dotenv>=1.0.0

services/drive.py

@@ -1278,22 +1278,20 @@ def create_folder_recursive(self, path: str,
                     try:
                         print(f"  -> Creating new folder: {part} in {current_path_so_far}")
 
-                        # We only pass timestamps if this is the *final* folder
+                        # Use self.create_folder for both intermediate and final
+                        # parts so the parent cache is invalidated/updated. Only
+                        # the final part gets timestamps applied.
                         if is_last_part:
                             print(f"  -> 🕐 Applying timestamps to new folder: {part}")
                             new_folder = self.create_folder(
-                                part, 
+                                part,
                                 current_parent_uuid,
                                 creation_time=creation_time,
-                                modification_time=modification_time
+                                modification_time=modification_time,
                             )
                         else:
-                            # Create intermediate folders *without* timestamps
-                            new_folder = self.api.create_folder({
-                                'plainName': part, 
-                                'parentFolderUuid': current_parent_uuid
-                            })
-                        
+                            new_folder = self.create_folder(part, current_parent_uuid)
+
                         current_parent_uuid = new_folder['uuid']
                         final_folder_info = new_folder
 

tests/test_drive_path_resolution.py

@@ -175,16 +175,18 @@ def test_create_folder_recursive_existing_no_api_call():
 
 
 def test_create_folder_recursive_creates_missing_parts():
-    """Intermediate folders go through api.create_folder; final folder uses
-    drive_service.create_folder so timestamps can be applied."""
-    # Initially empty tree at every level.
+    """All parts (intermediate + final) go through drive_service.create_folder
+    so the parent cache is updated for each. Only the final part gets
+    timestamps applied.
+
+    Regression: prior implementation called api.create_folder directly for
+    intermediate parts, which bypassed the parent-cache update and made
+    subsequent resolve_path() calls fail with FileNotFoundError when reading
+    from a stale root cache. Caught by tests/test_live_smoke.py.
+    """
     tree = {'root-uuid': {'folders': [], 'files': []}}
 
-    def fake_create_intermediate(payload):
-        # Simulate the server returning a uuid for the new intermediate folder
-        return {'uuid': f"new-{payload['plainName']}", 'plainName': payload['plainName']}
-
-    def fake_create_final(name, parent_uuid, creation_time=None, modification_time=None):
+    def fake_create(name, parent_uuid, creation_time=None, modification_time=None):
         return {
             'uuid': f"new-{name}", 'plainName': name,
             'parentFolderUuid': parent_uuid,
@@ -193,28 +195,31 @@ def fake_create_final(name, parent_uuid, creation_time=None, modification_time=N
 
     with _set_root(), \
          _stub_get_folder_content(tree), \
-         patch.object(drive_service.api, 'create_folder',
-                      side_effect=fake_create_intermediate) as mock_api_create, \
+         patch.object(drive_service.api, 'create_folder') as mock_api_create, \
          patch.object(drive_service, 'create_folder',
-                      side_effect=fake_create_final) as mock_create_final_top:
+                      side_effect=fake_create) as mock_create:
         out = drive_service.create_folder_recursive(
             '/A/B/C',
             creation_time='2026-01-01T00:00:00Z',
             modification_time='2026-01-02T00:00:00Z',
         )
 
-    # /A and /A/B are intermediate -> 2 api.create_folder calls
-    assert mock_api_create.call_count == 2
-    intermediate_names = [call.args[0]['plainName'] for call in mock_api_create.call_args_list]
-    assert intermediate_names == ['A', 'B']
-
-    # /A/B/C is the final part -> 1 drive_service.create_folder call
-    # with timestamps preserved.
-    mock_create_final_top.assert_called_once()
-    args, kwargs = mock_create_final_top.call_args
-    assert args[0] == 'C'
-    assert kwargs.get('creation_time') == '2026-01-01T00:00:00Z'
-    assert kwargs.get('modification_time') == '2026-01-02T00:00:00Z'
+    # All 3 parts go through self.create_folder (which keeps the parent
+    # cache in sync). The raw api.create_folder is NOT called directly.
+    mock_api_create.assert_not_called()
+    assert mock_create.call_count == 3
+    names_in_order = [call.args[0] for call in mock_create.call_args_list]
+    assert names_in_order == ['A', 'B', 'C']
+
+    # Only the LAST call (for 'C') gets timestamps; intermediates pass None.
+    intermediate_call = mock_create.call_args_list[0]
+    assert intermediate_call.kwargs.get('creation_time') is None
+    assert intermediate_call.kwargs.get('modification_time') is None
+
+    final_call = mock_create.call_args_list[-1]
+    assert final_call.args[0] == 'C'
+    assert final_call.kwargs.get('creation_time') == '2026-01-01T00:00:00Z'
+    assert final_call.kwargs.get('modification_time') == '2026-01-02T00:00:00Z'
 
     # Returned info points at the final folder
     assert out['uuid'] == 'new-C'