add folder name as part of workato init workflow

Author: shihanpan

src/workato_platform_cli/cli/commands/init.py

@@ -43,6 +43,10 @@
     default="table",
     help="Output format: table (default) or json (only with --non-interactive)",
 )
+@click.option(
+    "--folder-name",
+    help="Custom folder name for the project (defaults to project name)",
+)
 @handle_cli_exceptions
 @handle_api_exceptions
 async def init(
@@ -54,6 +58,7 @@ async def init(
     project_id: int | None = None,
     non_interactive: bool = False,
     output_mode: str = "table",
+    folder_name: str | None = None,
 ) -> None:
     """Initialize Workato CLI for a new project
 
@@ -156,6 +161,7 @@ async def init(
         project_id=project_id,
         output_mode=output_mode,
         non_interactive=non_interactive,
+        folder_name=folder_name,
     )
 
     # Check if project directory exists and is non-empty

src/workato_platform_cli/cli/utils/config/manager.py

@@ -56,6 +56,7 @@ async def initialize(
         project_id: int | None = None,
         output_mode: str = "table",
         non_interactive: bool = False,
+        folder_name: str | None = None,
     ) -> "ConfigManager":
         """Initialize workspace with interactive or non-interactive setup"""
         if output_mode == "table":
@@ -80,14 +81,15 @@ async def initialize(
                 api_url=api_url,
                 project_name=project_name,
                 project_id=project_id,
+                folder_name=folder_name,
             )
         else:
             # Run setup flow
-            await manager._run_setup_flow()
+            await manager._run_setup_flow(folder_name=folder_name)
 
         return manager
 
-    async def _run_setup_flow(self) -> None:
+    async def _run_setup_flow(self, folder_name: str | None = None) -> None:
         """Run the complete setup flow"""
         workspace_root = self.workspace_manager.find_workspace_root()
         self.config_dir = workspace_root
@@ -99,7 +101,7 @@ async def _run_setup_flow(self) -> None:
         profile_name = await self._setup_profile()
 
         # Step 2: Project setup
-        await self._setup_project(profile_name, workspace_root)
+        await self._setup_project(profile_name, workspace_root, folder_name)
 
         # Step 3: Create workspace files
         self._create_workspace_files(workspace_root)
@@ -114,6 +116,7 @@ async def _setup_non_interactive(
         api_url: str | None = None,
         project_name: str | None = None,
         project_id: int | None = None,
+        folder_name: str | None = None,
     ) -> None:
         """Perform all setup actions non-interactively"""
 
@@ -238,7 +241,9 @@ async def _setup_non_interactive(
 
             # Project doesn't exist locally - create new directory
             current_dir = Path.cwd().resolve()
-            project_path = current_dir / selected_project.name
+            # Use custom folder name if provided, otherwise use project name
+            directory_name = folder_name if folder_name else selected_project.name
+            project_path = current_dir / directory_name
 
             # Create project directory
             project_path.mkdir(parents=True, exist_ok=True)
@@ -552,7 +557,9 @@ async def _create_new_profile(self, profile_name: str) -> None:
         # Save profile and token
         self.profile_manager.set_profile(profile_name, profile_data, token)
 
-    async def _setup_project(self, profile_name: str, workspace_root: Path) -> None:
+    async def _setup_project(
+        self, profile_name: str, workspace_root: Path, folder_name: str | None = None
+    ) -> None:
         """Setup project interactively"""
         click.echo("📁 Step 2: Setup project")
 
@@ -607,6 +614,16 @@ async def _setup_project(self, profile_name: str, workspace_root: Path) -> None:
             if not selected_project:
                 raise click.ClickException("No project selected")
 
+            # Prompt for custom folder name if not provided via CLI
+            if folder_name is None:
+                click.echo()
+                custom_name = await click.prompt(
+                    "Folder name (leave blank for default)",
+                    default=selected_project.name,
+                    type=str,
+                )
+                folder_name = custom_name.strip() if custom_name.strip() else None
+
             # Check if this specific project already exists locally in the workspace
             local_projects = self._find_all_projects(workspace_root)
             existing_local_path = None
@@ -641,7 +658,9 @@ async def _setup_project(self, profile_name: str, workspace_root: Path) -> None:
             else:
                 # Project doesn't exist locally - create new directory
                 current_dir = Path.cwd().resolve()
-                project_path = current_dir / selected_project.name
+                # Use custom folder name if provided, otherwise use project name
+                directory_name = folder_name if folder_name else selected_project.name
+                project_path = current_dir / directory_name
 
             # Validate project path
             try:

tests/unit/commands/conftest.py

@@ -0,0 +1,157 @@
+"""Shared test fixtures for command tests."""
+
+from collections.abc import Callable
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from workato_platform_cli.cli.utils.config import ConfigData, ProfileData
+
+
+@pytest.fixture
+def profile_data_factory() -> Callable[..., ProfileData]:
+    """Create ProfileData instances for test scenarios."""
+
+    def _factory(
+        *,
+        region: str = "us",
+        region_url: str = "https://app.workato.com",
+        workspace_id: int = 123,
+    ) -> ProfileData:
+        return ProfileData(
+            region=region,
+            region_url=region_url,
+            workspace_id=workspace_id,
+        )
+
+    return _factory
+
+
+@pytest.fixture
+def make_config_manager() -> Callable[..., Mock]:
+    """Factory for building config manager stubs with attached profile manager."""
+
+    def _factory(**profile_methods: Mock) -> Mock:
+        profile_manager = Mock()
+        config_manager = Mock()
+        config_manager.profile_manager = profile_manager
+        # Provide deterministic config data unless overridden in tests
+        config_manager.load_config.return_value = ConfigData()
+
+        config_methods = {
+            "load_config",
+            "save_config",
+            "get_workspace_root",
+            "get_project_directory",
+        }
+
+        for name, value in profile_methods.items():
+            if name in config_methods:
+                setattr(config_manager, name, value)
+            else:
+                setattr(profile_manager, name, value)
+
+        return config_manager
+
+    return _factory
+
+
+@pytest.fixture
+def mock_workato_context() -> Callable[..., tuple[Mock, AsyncMock]]:
+    """Create mock Workato client and context for async operations.
+
+    Returns:
+        Callable that returns (mock_client, async_context) tuple
+    """
+
+    def _factory() -> tuple[Mock, AsyncMock]:
+        mock_client = Mock()
+        context = AsyncMock()
+        context.__aenter__.return_value = mock_client
+        context.__aexit__.return_value = False
+        return mock_client, context
+
+    return _factory
+
+
+@pytest.fixture
+def mock_init_dependencies(monkeypatch) -> Callable[..., dict[str, Mock | AsyncMock]]:
+    """Setup common init command dependencies and mocks.
+
+    Returns a factory that creates and patches all common init test dependencies.
+
+    Usage:
+        mocks = mock_init_dependencies(
+            profile="test-profile",
+            token="test-token",
+            api_url="https://api.workato.com"
+        )
+        # mocks contains: config_manager, workato_client, initialize_mock, pull_mock
+    """
+
+    def _factory(
+        profile: str = "default",
+        token: str = "test-token",
+        api_url: str = "https://api.workato.com",
+        project_id: int | None = None,
+        **config_overrides,
+    ) -> dict[str, Mock | AsyncMock]:
+        from workato_platform_cli.cli.commands import init as init_module
+
+        # Create mocks
+        mock_config_manager = Mock()
+        mock_workato_client = Mock()
+        workato_context = AsyncMock()
+
+        # Setup config manager defaults
+        mock_config_manager.load_config.return_value = Mock(profile=profile)
+        mock_config_manager.get_project_directory.return_value = project_id
+        mock_config_manager.profile_manager.resolve_environment_variables.return_value = (
+            token,
+            api_url,
+        )
+
+        # Apply any config overrides
+        for attr, value in config_overrides.items():
+            if "." in attr:
+                # Support nested attributes like "profile_manager.get_profile"
+                obj = mock_config_manager
+                parts = attr.split(".")
+                for part in parts[:-1]:
+                    obj = getattr(obj, part)
+                setattr(obj, parts[-1], value)
+            else:
+                setattr(mock_config_manager, attr, value)
+
+        # Setup Workato context
+        workato_context.__aenter__.return_value = mock_workato_client
+        workato_context.__aexit__.return_value = False
+
+        # Create and patch initialize mock
+        mock_initialize = AsyncMock(return_value=mock_config_manager)
+        monkeypatch.setattr(
+            init_module.ConfigManager,
+            "initialize",
+            mock_initialize,
+        )
+
+        # Create and patch pull mock
+        mock_pull = AsyncMock()
+        monkeypatch.setattr(init_module, "_pull_project", mock_pull)
+
+        # Patch Workato and Configuration
+        monkeypatch.setattr(init_module, "Workato", lambda **_: workato_context)
+        monkeypatch.setattr(init_module, "Configuration", lambda **_: Mock())
+
+        # Silence click.echo
+        monkeypatch.setattr(init_module.click, "echo", lambda _="": None)
+
+        return {
+            "config_manager": mock_config_manager,
+            "workato_client": mock_workato_client,
+            "workato_context": workato_context,
+            "initialize_mock": mock_initialize,
+            "pull_mock": mock_pull,
+        }
+
+    return _factory