Consolidate API access check and folder listing into single request

main.py

@@ -718,118 +718,125 @@
         return {}
 
 
 def verify_access_and_get_folders(
     client: httpx.Client, profile_id: str
 ) -> Optional[Dict[str, str]]:
     """Combine access check and folder listing into a single API request.
 
     Returns:
         Dict of {folder_name: folder_id} on success.
         None if access is denied or the request fails after retries.
     """
     url = f"{API_BASE}/{profile_id}/groups"
 
     for attempt in range(MAX_RETRIES):
         try:
             resp = client.get(url)
             resp.raise_for_status()
 
             try:
                 data = resp.json()
 
                 # Ensure we got the expected top-level JSON structure.
                 # We defensively validate types here so that unexpected but valid
                 # JSON (e.g., a list or a scalar) doesn't cause AttributeError/TypeError
-                # and crash the sync logic.
+                # and cause the operation to fail unexpectedly.
                 if not isinstance(data, dict):
                     log.error(
                         "Failed to parse folders data: expected JSON object at top level, "
                         f"got {type(data).__name__}"
                     )
                     return None
 
                 body = data.get("body")
                 if not isinstance(body, dict):
                     log.error(
                         "Failed to parse folders data: expected 'body' to be an object, "
                         f"got {type(body).__name__ if body is not None else 'None'}"
                     )
                     return None
 
                 folders = body.get("groups", [])
                 if not isinstance(folders, list):
                     log.error(
                         "Failed to parse folders data: expected 'body[\"groups\"]' to be a list, "
                         f"got {type(folders).__name__}"
                     )
                     return None
 
                 # Only process entries that are dicts and have the required keys.
                 result: Dict[str, str] = {}
                 for f in folders:
                     if not isinstance(f, dict):
                         # Skip non-dict entries instead of crashing; this protects
                         # against partial data corruption or unexpected API changes.
                         continue
                     name = f.get("group")
                     pk = f.get("PK")
+                    # Skip entries with empty or None values for required fields
                     if not name or not pk:
                         continue
                     result[str(name).strip()] = str(pk)
 
                 return result
-            except (KeyError, ValueError, TypeError, AttributeError) as e:
+            except (ValueError, TypeError, AttributeError) as err:
                 # As a final safeguard, catch any remaining parsing/shape errors so
                 # that a malformed response cannot crash the caller.
-                log.error(f"Failed to parse folders data: {sanitize_for_log(e)}")
+                log.error(
+                    "Failed to parse folders data: %s", sanitize_for_log(err)
+                )
                 return None
 
         except httpx.HTTPStatusError as e:
             code = e.response.status_code
             if code in (401, 403, 404):
                 if code == 401:
                     log.critical(
                         f"{Colors.FAIL}❌ Authentication Failed: The API Token is invalid.{Colors.ENDC}"
                     )
                     log.critical(
                         f"{Colors.FAIL}   Please check your token at: https://controld.com/account/manage-account{Colors.ENDC}"
                     )
                 elif code == 403:
                     log.critical(
-                        f"{Colors.FAIL}🚫 Access Denied: Token lacks permission for Profile {sanitize_for_log(profile_id)}.{Colors.ENDC}"
+                        "%s🚫 Access Denied: Token lacks permission for "
+                        "Profile %s.%s",
+                        Colors.FAIL,
+                        sanitize_for_log(profile_id),
+                        Colors.ENDC,
                     )
                 elif code == 404:
                     log.critical(
                         f"{Colors.FAIL}🔍 Profile Not Found: The ID '{sanitize_for_log(profile_id)}' does not exist.{Colors.ENDC}"
                     )
                     log.critical(
                         f"{Colors.FAIL}   Please verify the Profile ID from your Control D Dashboard URL.{Colors.ENDC}"
                     )
                 return None
 
             if attempt == MAX_RETRIES - 1:
                 log.error(f"API Request Failed ({code}): {sanitize_for_log(e)}")
                 return None
 
-        except httpx.RequestError as e:
+        except httpx.RequestError as err:
             if attempt == MAX_RETRIES - 1:
                 log.error(
-                    f"Network error during access verification: {sanitize_for_log(e)}"
+                    "Network error during access verification: %s",
+                    sanitize_for_log(err),
                 )
                 return None
 
         wait_time = RETRY_DELAY * (2**attempt)
         log.warning(
-            f"Request failed (attempt {attempt + 1}/{MAX_RETRIES}). Retrying in {wait_time}s..."
+            "Request failed (attempt %d/%d). Retrying in %ds...",
+            attempt + 1,
+            MAX_RETRIES,
+            wait_time,
         )
         time.sleep(wait_time)
 
-    log.error("Access verification failed after all retries")
-    return None
-
-
 def get_all_existing_rules(
     client: httpx.Client,
     profile_id: str,
     known_folders: Optional[Dict[str, str]] = None,
 ) -> Set[str]:

test_main.py

@@ -332,6 +332,7 @@
 
 
 def test_verify_access_and_get_folders_500_retry(monkeypatch):
+    """Test that verify_access_and_get_folders retries on 500 errors."""
     m = reload_main_with_env(monkeypatch)
     mock_client = MagicMock()
 
@@ -356,6 +357,7 @@
 
 
 def test_verify_access_and_get_folders_network_error(monkeypatch):
+    """Test that verify_access_and_get_folders handles network errors."""
     m = reload_main_with_env(monkeypatch)
     mock_client = MagicMock()
 
@@ -372,7 +374,8 @@
     assert m.verify_access_and_get_folders(mock_client, "profile") is None
     assert mock_client.get.call_count == 2
     assert mock_log.error.called
-    assert "Network error" in str(mock_log.error.call_args) or "access verification" in str(mock_log.error.call_args)
+    error_msg = str(mock_log.error.call_args)
+    assert "Network error" in error_msg or "access verification" in error_msg
 
 
 # Case 8: extract_profile_id correctly extracts ID from URL or returns input

tests/test_parallel_deletion.py

@@ -36,7 +36,11 @@ def test_parallel_deletion_uses_threadpool(mock_env, monkeypatch):
         __enter__=lambda self: mock_client, __exit__=lambda *args: None
     )
     monkeypatch.setattr(main, "_api_client", lambda: mock_client_ctx)
-    monkeypatch.setattr(main, "verify_access_and_get_folders", lambda *args: {"FolderA": "id1", "FolderB": "id2"})
+    monkeypatch.setattr(
+        main,
+        "verify_access_and_get_folders",
+        lambda *args: {"FolderA": "id1", "FolderB": "id2"},
+    )
     monkeypatch.setattr(main, "delete_folder", lambda *args: True)
     monkeypatch.setattr(main, "get_all_existing_rules", lambda *args: set())
     monkeypatch.setattr(main, "countdown_timer", lambda *args: None)
@@ -90,7 +94,11 @@ def test_parallel_deletion_handles_exceptions(mock_env, monkeypatch):
         __enter__=lambda self: mock_client, __exit__=lambda *args: None
     )
     monkeypatch.setattr(main, "_api_client", lambda: mock_client_ctx)
-    monkeypatch.setattr(main, "verify_access_and_get_folders", lambda *args: {"Folder1": "id1"})
+    monkeypatch.setattr(
+        main,
+        "verify_access_and_get_folders",
+        lambda *args: {"Folder1": "id1"},
+    )
 
     # Mock delete_folder to raise an exception
     def failing_delete(*args):
@@ -140,7 +148,11 @@ def test_parallel_deletion_sanitizes_exception(mock_env, monkeypatch):
         __enter__=lambda self: mock_client, __exit__=lambda *args: None
     )
     monkeypatch.setattr(main, "_api_client", lambda: mock_client_ctx)
-    monkeypatch.setattr(main, "verify_access_and_get_folders", lambda *args: {"TestFolder": "id1"})
+    monkeypatch.setattr(
+        main,
+        "verify_access_and_get_folders",
+        lambda *args: {"TestFolder": "id1"},
+    )
 
     # Mock delete_folder to raise exception with potentially dangerous content
     def failing_delete(*args):