easyrunner-cli 0.0.8.dev128__tar.gz → 0.0.8.dev129__tar.gz

{easyrunner_cli-0.0.8.dev128 → easyrunner_cli-0.0.8.dev129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easyrunner_cli
-Version: 0.0.8.dev128
+Version: 0.0.8.dev129
 Summary: EasyRunner CLI.
 License: Proprietary
 Author: Janaka Abeywardhana

easyrunner_cli-0.0.8.dev129/easyrunner/tests/test_cli_service_integration.py

@@ -0,0 +1,348 @@
+"""CLI + Services Integration Tests.
+
+Tests that CLI commands properly use the service layer and maintain
+consistent behavior between CLI and service layer interfaces.
+
+These tests verify:
+- CLI ServerSubCommand uses ServerService
+- CLI AppSubCommand uses AppService and DeploymentService
+- End-to-end workflows work correctly
+- Error handling is consistent across layers
+"""
+
+import logging
+from unittest.mock import Mock
+
+import pytest
+
+from easyrunner.source.services import (
+    AppService,
+    DeploymentService,
+    ServerService,
+    ServiceResult,
+)
+from easyrunner.source.store.data_models import App, Server
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture
+def mock_store() -> Mock:
+    """Create a mock EasyRunnerStore."""
+    store = Mock()
+    store.list_servers.return_value = []
+    store.add_server.return_value = None
+    store.update_server.return_value = None
+    # By default, return None for server lookups (server doesn't exist)
+    store.get_server_by_name.return_value = None
+    store.get_server_by_hostname_or_ip.return_value = None
+    return store
+
+
+@pytest.fixture
+def mock_secret_store() -> Mock:
+    """Create a mock SecretStore."""
+    return Mock()
+
+
+@pytest.fixture
+def server_service(mock_store: Mock) -> ServerService:
+    """Create a ServerService with mocked store."""
+    return ServerService(store=mock_store)
+
+
+@pytest.fixture
+def app_service(mock_store: Mock) -> AppService:
+    """Create an AppService with mocked store."""
+    return AppService(store=mock_store)
+
+
+@pytest.fixture
+def deployment_service(
+    mock_store: Mock, mock_secret_store: Mock
+) -> DeploymentService:
+    """Create a DeploymentService with mocked dependencies."""
+    return DeploymentService(store=mock_store, secret_store=mock_secret_store)
+
+
+class TestServerServiceUsage:
+    """Test that ServerService is properly used for server operations."""
+
+    def test_server_service_add_server_called_from_cli(
+        self, server_service: ServerService
+    ):
+        """Test ServerService.add_server is called correctly."""
+        # Arrange
+        test_server_name = "test-server"
+        test_server_ip = "192.168.1.1"
+
+        # Act
+        result = server_service.add_server(
+            name=test_server_name, hostname_or_ip=test_server_ip
+        )
+
+        # Assert
+        assert result.success
+        assert result.data is not None
+        assert result.data.name == test_server_name
+        assert result.data.hostname_or_ip == test_server_ip
+        assert result.message == f"Server '{test_server_name}' added successfully"
+
+    def test_server_service_delete_server_called_from_cli(
+        self, server_service: ServerService, mock_store: Mock
+    ):
+        """Test ServerService.delete_server removes server correctly."""
+        # Arrange
+        test_server = Server(name="test-server", hostname_or_ip="192.168.1.1")
+        mock_store.get_server_by_name.return_value = test_server
+
+        # Act
+        result = server_service.delete_server(name=test_server.name)
+
+        # Assert
+        assert result.success
+        assert result.message == f"Server '{test_server.name}' deleted successfully"
+        mock_store.remove_server.assert_called_once_with(server_id=test_server.id)
+
+    def test_server_service_respects_uniqueness_constraints(
+        self, server_service: ServerService, mock_store: Mock
+    ):
+        """Test ServerService enforces name/address uniqueness."""
+        # Arrange
+        existing_server = Server(
+            name="existing", hostname_or_ip="192.168.1.1"
+        )
+        mock_store.get_server_by_name.return_value = existing_server
+
+        # Act - try to add server with duplicate name
+        result = server_service.add_server(
+            name="existing", hostname_or_ip="192.168.1.2"
+        )
+
+        # Assert
+        assert not result.success
+        assert result.error_code == "DUPLICATE_NAME"
+
+
+class TestAppServiceUsage:
+    """Test that AppService is properly used for app operations."""
+
+    def test_app_service_validate_for_deployment(
+        self, app_service: AppService, mock_store: Mock
+    ):
+        """Test AppService validates app for deployment."""
+        # Arrange
+        test_server = Server(name="test-server", hostname_or_ip="192.168.1.1")
+        test_app = App(
+            name="test-app",
+            repo_url="https://github.com/user/repo.git",
+            custom_domain="app.example.com",
+        )
+        test_server.apps = [test_app]
+        mock_store.get_server_by_name.return_value = test_server
+
+        # Act
+        result = app_service.validate_app_for_deployment(
+            server_name="test-server", app_name="test-app"
+        )
+
+        # Assert
+        assert result.success
+        assert result.data == test_app
+        assert (
+            result.message
+            == "App 'test-app' is ready for deployment"
+        )
+
+    def test_app_service_rejects_missing_custom_domain(
+        self, app_service: AppService, mock_store: Mock
+    ):
+        """Test AppService rejects app without custom domain."""
+        # Arrange
+        test_server = Server(name="test-server", hostname_or_ip="192.168.1.1")
+        test_app = App(
+            name="test-app",
+            repo_url="https://github.com/user/repo.git",
+            custom_domain=None,
+        )
+        test_server.apps = [test_app]
+        mock_store.get_server_by_name.return_value = test_server
+
+        # Act
+        result = app_service.validate_app_for_deployment(
+            server_name="test-server", app_name="test-app"
+        )
+
+        # Assert
+        assert not result.success
+        assert result.error_code == "MISSING_CUSTOM_DOMAIN"
+
+    def test_app_service_rejects_missing_repo_url(
+        self, app_service: AppService, mock_store: Mock
+    ):
+        """Test AppService rejects app without repo URL."""
+        # Arrange
+        test_server = Server(name="test-server", hostname_or_ip="192.168.1.1")
+        test_app = App(
+            name="test-app",
+            repo_url="",
+            custom_domain="app.example.com",
+        )
+        test_server.apps = [test_app]
+        mock_store.get_server_by_name.return_value = test_server
+
+        # Act
+        result = app_service.validate_app_for_deployment(
+            server_name="test-server", app_name="test-app"
+        )
+
+        # Assert
+        assert not result.success
+        assert result.error_code == "MISSING_REPO_URL"
+
+
+class TestDeploymentServiceUsage:
+    """Test that DeploymentService is properly used for deployments."""
+
+    def test_deployment_service_validates_app_before_deploy(
+        self, deployment_service: DeploymentService, mock_store: Mock
+    ):
+        """Test DeploymentService validates app before attempting deployment."""
+        # Arrange
+        mock_store.get_server_by_name.return_value = None
+
+        # Act
+        result = deployment_service.deploy_app(
+            server_name="nonexistent",
+            app_name="test-app",
+            ssh_username="easyrunner",
+            ssh_key_path="/path/to/key",
+            github_token="dummy_token",
+            debug=False,
+            silent=False,
+        )
+
+        # Assert
+        assert not result.success
+        assert "not found" in result.message.lower()
+
+    def test_deployment_service_returns_structured_error(
+        self, deployment_service: DeploymentService, mock_store: Mock
+    ):
+        """Test DeploymentService returns structured error information."""
+        # Arrange
+        mock_store.get_server_by_name.return_value = None
+
+        # Act
+        result = deployment_service.deploy_app(
+            server_name="nonexistent",
+            app_name="test-app",
+            ssh_username="easyrunner",
+            ssh_key_path="/path/to/key",
+            debug=False,
+            silent=False,
+        )
+
+        # Assert - verify ServiceResult structure
+        assert isinstance(result, ServiceResult)
+        assert result.error_code is not None
+        assert result.message is not None
+
+
+class TestCLIServiceConsistency:
+    """Test that CLI and service layer behaviors are consistent."""
+
+    def test_service_result_success_field_matches_cli_expectations(
+        self, server_service: ServerService
+    ):
+        """Test ServiceResult.success matches CLI error handling expectations."""
+        # Arrange
+        test_server = Server(name="test-server", hostname_or_ip="192.168.1.1")
+
+        # Act
+        result = server_service.add_server(
+            name=test_server.name, hostname_or_ip=test_server.hostname_or_ip
+        )
+
+        # Assert - CLI checks 'if result.success:'
+        assert isinstance(result.success, bool)
+        assert hasattr(result, "message")
+        assert hasattr(result, "data")
+        assert hasattr(result, "error_code")
+
+    def test_service_result_contains_cli_required_fields(
+        self, server_service: ServerService, mock_store: Mock
+    ):
+        """Test ServiceResult has all fields CLI needs for error display."""
+        # Arrange
+        mock_store.get_server_by_name.return_value = Server(
+            name="existing", hostname_or_ip="192.168.1.1"
+        )
+
+        # Act
+        result = server_service.add_server(
+            name="existing", hostname_or_ip="192.168.1.2"
+        )
+
+        # Assert - CLI uses these fields for error messages
+        assert not result.success
+        assert result.error_code in ["DUPLICATE_NAME", "DUPLICATE_ADDRESS"]
+        assert "already exists" in result.message.lower()
+        if result.details:
+            assert "existing_server" in result.details
+
+
+class TestEndToEndWorkflows:
+    """Test complete workflows from CLI through services to store."""
+
+    def test_add_server_workflow(
+        self, server_service: ServerService, mock_store: Mock
+    ):
+        """Test complete add server workflow."""
+        # Arrange
+        server_name = "production"
+        server_ip = "192.168.1.100"
+
+        # Act - add server
+        add_result = server_service.add_server(
+            name=server_name, hostname_or_ip=server_ip
+        )
+
+        # Assert
+        assert add_result.success
+        assert add_result.data is not None
+        assert add_result.data.name == server_name
+        assert add_result.data.hostname_or_ip == server_ip
+        mock_store.add_server.assert_called_once()
+
+    def test_add_and_validate_app_workflow(
+        self,
+        app_service: AppService,
+        mock_store: Mock,
+    ):
+        """Test complete add and validate app workflow."""
+        # Arrange
+        test_server = Server(name="prod", hostname_or_ip="192.168.1.1")
+        test_app = App(
+            name="webapp",
+            repo_url="https://github.com/user/webapp.git",
+            custom_domain="app.prod.com",
+        )
+        test_server.apps = [test_app]
+        mock_store.get_server_by_name.return_value = test_server
+
+        # Act - get app
+        get_result = app_service.get_app(server_name="prod", app_name="webapp")
+
+        # Assert - got app
+        assert get_result.success
+        assert get_result.data == test_app
+
+        # Act - validate for deployment
+        validate_result = app_service.validate_app_for_deployment(
+            server_name="prod", app_name="webapp"
+        )
+
+        # Assert - app is valid
+        assert validate_result.success
+        assert validate_result.data == test_app

{easyrunner_cli-0.0.8.dev128 → easyrunner_cli-0.0.8.dev129}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "easyrunner_cli"
-version = "0.0.8.dev128"
+version = "0.0.8.dev129"
 description = "EasyRunner CLI."
 authors = ["Janaka Abeywardhana <janaka@easyrunner.xyz>"]
 license = "Proprietary"

{easyrunner_cli-0.0.8.dev128 → easyrunner_cli-0.0.8.dev129}/source/app_sub_command.py

@@ -13,6 +13,7 @@ from easyrunner.source.commands.ubuntu.caddy_commands_container_ubuntu import (
     CaddyCommandsContainerUbuntu,
 )
 from easyrunner.source.resources.os_resources import Caddy, HostServerUbuntu
+from easyrunner.source.services import AppService, DeploymentService
 from easyrunner.source.store.data_models.app import App
 from easyrunner.source.store.data_models.server import Server
 from easyrunner.source.store.easyrunner_store import EasyRunnerStore
@@ -97,26 +98,13 @@ class AppSubCommand:
     ) -> None:
 
         try:
+            # Get server to validate it exists and get SSH key path
             server: Server | None = AppSubCommand._store.get_server_by_name(
                 name=server_name
             )
             if not server:
                 AppSubCommand._print(f"Server with name '{server_name}' not found.")
                 return
-            app = next((app for app in server.apps if app.name == name), None)
-            if not app:
-                AppSubCommand._print(
-                    f"App with name '{name}' not found on server '{server_name}'."
-                )
-                return
-
-            if not app.custom_domain:
-                AppSubCommand._print(
-                    f"App with name '{name}' must have a custom domain name set because this is used to uniquely identify this app in configuration. The custom domain name must be unique amongst all the apps on each server."
-                )
-                return
-
-            hostname_or_ipv4: str = server.hostname_or_ip
 
             # Initial deployment info
             AppSubCommand._print("🚀 [bold blue]Starting deployment...[/bold blue]")
@@ -130,27 +118,26 @@ class AppSubCommand:
                 )
                 return
 
-            with Ssh(
-                hostname_or_ipv4=hostname_or_ipv4,
-                username=ssh_config.username,
-                key_filename=build_private_key_path(hostname_or_ipv4),
+            # Use DeploymentService to orchestrate deployment
+            deployment_service = DeploymentService(
+                store=AppSubCommand._store,
+                secret_store=KeyringSecretStore(),
+            )
+            result = deployment_service.deploy_app(
+                server_name=server_name,
+                app_name=name,
+                ssh_username=ssh_config.username,
+                ssh_key_path=build_private_key_path(server.hostname_or_ip),
+                github_token=github_access_token,
                 debug=AppSubCommand.debug,
                 silent=AppSubCommand.silent,
-            ) as ssh_client:
-                executor = CommandExecutor(ssh_client=ssh_client)
-                host_server_instance = HostServerUbuntu(
-                    easyrunner_username=ssh_config.username,
-                    executor=executor,
-                    debug=AppSubCommand.debug,
-                    silent=AppSubCommand.silent,
-                    progress_callback=AppSubCommand._progress_callback,
-                )
+            )
+
+            if result.success:
+                AppSubCommand._print(f"✅ {result.message}")
+            else:
+                AppSubCommand._print(f"❌ Deployment failed: {result.message}")
 
-                host_server_instance.deploy_app_flow_a(
-                    repo_url=app.repo_url,
-                    custom_app_domain_name=app.custom_domain,
-                    github_access_token=github_access_token,
-                )
         except Exception as e:
             AppSubCommand._print(
                 f"[red]Oops, something went wrong while deploying the app:[/red] {str(e)}"
@@ -286,6 +273,14 @@ class AppSubCommand:
             help="The HTTPS URL of the application repository. Currently only supports GitHub repositories.",
         ),
     ) -> None:
+        # Get server
+        app_service = AppService(store=AppSubCommand._store)
+        server_result = app_service.list_apps(server_name=server_name)
+
+        if not server_result.success:
+            echo(message=f"Server with name '{server_name}' not found.")
+            return
+
         server: Server | None = AppSubCommand._store.get_server_by_name(
             name=server_name
         )
@@ -293,6 +288,7 @@ class AppSubCommand:
             echo(message=f"Server with name '{server_name}' not found.")
             return
 
+        # Check if app already exists
         if not any(app.name == name for app in server.apps):
             server.apps.append(
                 App(

{easyrunner_cli-0.0.8.dev128 → easyrunner_cli-0.0.8.dev129}/source/servers_sub_command.py

@@ -18,6 +18,7 @@ from easyrunner.source.known_host_ssh_keys import KNOWN_HOST_SSH_KEYS
 from easyrunner.source.resources.cloud_resources.hetzner import HetznerStack
 from easyrunner.source.resources.os_resources import HostServerUbuntu
 from easyrunner.source.resources.web_security_scanner import WebSecurityScanner
+from easyrunner.source.services import LicenseService, ServerService
 from easyrunner.source.ssh import with_ssh_retry
 from easyrunner.source.store import EasyRunnerStore
 from easyrunner.source.store.data_models import Server
@@ -82,43 +83,48 @@ class ServerSubCommand:
 
         Displays error message to user if limit is exceeded.
         """
-        # Get license info
-        manager = LicenseManager()
-        license_info = manager.get_license_info()
-
-        if license_info is None:
-            # This shouldn't happen as main.py checks license on startup
-            # But handle it gracefully just in case
-            ServerSubCommand._print(
-                "[red]Error:[/red] No valid license found. Run [cyan]er license status[/cyan] for details."
-            )
-            return False
-
-        # Get current server count
-        current_servers = ServerSubCommand._store.list_servers()
-        current_count = len(current_servers)
-
-        # Check if we're at or over the limit
-        if current_count >= license_info.server_limit:
-            ServerSubCommand._print()
-            ServerSubCommand._print(f"[red]✗ Server limit reached[/red]")
-            ServerSubCommand._print()
-            ServerSubCommand._print(
-                f"Your license allows [bold]{license_info.server_limit}[/bold] server(s)."
-            )
-            ServerSubCommand._print(
-                f"You currently have [bold]{current_count}[/bold] server(s) registered."
-            )
-            ServerSubCommand._print()
-            ServerSubCommand._print("To add more servers:")
-            ServerSubCommand._print(
-                "  • Remove an existing server: [cyan]er server remove <name>[/cyan]"
-            )
-            ServerSubCommand._print(
-                "  • Upgrade your license at [link]https://easyrunner.xyz[/link]"
-            )
-            ServerSubCommand._print()
-            return False
+        # Use LicenseService to check server quota
+        license_service = LicenseService(store=ServerSubCommand._store)
+        limit_result = license_service.can_add_server()
+
+        # If there's an error with license check, use LicenseManager as fallback
+        if not limit_result.success:
+            manager = LicenseManager()
+            license_info = manager.get_license_info()
+
+            if license_info is None:
+                # This shouldn't happen as main.py checks license on startup
+                # But handle it gracefully just in case
+                ServerSubCommand._print(
+                    "[red]Error:[/red] No valid license found. Run [cyan]er license status[/cyan] for details."
+                )
+                return False
+
+            # Get current server count
+            current_servers = ServerSubCommand._store.list_servers()
+            current_count = len(current_servers)
+
+            # Check if we're at or over the limit
+            if current_count >= license_info.server_limit:
+                ServerSubCommand._print()
+                ServerSubCommand._print("[red]✗ Server limit reached[/red]")
+                ServerSubCommand._print()
+                ServerSubCommand._print(
+                    f"Your license allows [bold]{license_info.server_limit}[/bold] server(s)."
+                )
+                ServerSubCommand._print(
+                    f"You currently have [bold]{current_count}[/bold] server(s) registered."
+                )
+                ServerSubCommand._print()
+                ServerSubCommand._print("To add more servers:")
+                ServerSubCommand._print(
+                    "  • Remove an existing server: [cyan]er server remove <name>[/cyan]"
+                )
+                ServerSubCommand._print(
+                    "  • Upgrade your license at [link]https://easyrunner.xyz[/link]"
+                )
+                ServerSubCommand._print()
+                return False
 
         return True
 
@@ -189,38 +195,34 @@ class ServerSubCommand:
         Returns:
             Server object if successfully added, None if validation failed
         """
-        # Check if server name already exists
-        server_name_exists: Server | None = ServerSubCommand._store.get_server_by_name(
-            name=name
-        )
-        if server_name_exists:
-            ServerSubCommand._print(
-                f"⚠️  Server with the name '[bold yellow]{server_name_exists.name}[/bold yellow]' already exists in EasyRunner."
-            )
+        # Use ServerService to add server with validation
+        server_service = ServerService(store=ServerSubCommand._store)
+        result = server_service.add_server(name=name, hostname_or_ip=hostname_or_ip)
+
+        if not result.success:
+            # Display appropriate error message based on error code
+            if result.error_code == "DUPLICATE_NAME":
+                existing_server = result.details.get("existing_server") if result.details else name
+                ServerSubCommand._print(
+                    f"⚠️  Server with the name '[bold yellow]{existing_server}[/bold yellow]' already exists in EasyRunner."
+                )
+            elif result.error_code == "DUPLICATE_ADDRESS":
+                existing_server = result.details.get("existing_server") if result.details else hostname_or_ip
+                ServerSubCommand._print(
+                    f"⚠️  Server with the address '[bold yellow]{existing_server}[/bold yellow]' already exists in EasyRunner."
+                )
+            else:
+                ServerSubCommand._print(f"⚠️  {result.message}")
             return None
 
-        # Check if server address already exists
-        server_address_exists: Server | None = (
-            ServerSubCommand._store.get_server_by_hostname_or_ip(
-                hostname_or_ip=hostname_or_ip
-            )
-        )
-        if server_address_exists:
+        # Display success message
+        server = result.data
+        if server:
             ServerSubCommand._print(
-                f"⚠️  Server with the address '[bold yellow]{server_address_exists.hostname_or_ip}[/bold yellow]' already exists in EasyRunner."
+                f"✅ Server [bold green]{server.name}[/bold green]([italic cyan]{server.hostname_or_ip}[/italic cyan]) added to EasyRunner."
             )
-            return None
-
-        # Create and persist the server
-        server: Server = Server(
-            name=name,
-            hostname_or_ip=hostname_or_ip,
-        )
-        ServerSubCommand._store.add_server(server=server)
-        ServerSubCommand._print(
-            f"✅ Server [bold green]{server.name}[/bold green]([italic cyan]{server.hostname_or_ip}[/italic cyan]) added to EasyRunner."
-        )
-        return server
+            return server
+        return None
 
     @staticmethod
     def _cancel_stack(name: str, cloud_provider_name: CloudProviders) -> None:
@@ -584,20 +586,31 @@ class ServerSubCommand:
     )
     @staticmethod
     def remove_server(name: str = NAME_ARG) -> None:
-        server = ServerSubCommand._store.get_server_by_name(name=name)
-        if not server:
+        # Use ServerService to get server
+        server_service = ServerService(store=ServerSubCommand._store)
+        server_result = server_service.get_server(name=name)
+
+        if not server_result.success:
+            echo(message=f"Server {name} not found in EasyRunner.")
+            return
+
+        server = server_result.data
+        if server is None:
             echo(message=f"Server {name} not found in EasyRunner.")
             return
 
         # Remove SSH key files for the server
         ServerSubCommand._cleanup_ssh_keys(server.hostname_or_ip)
 
-        # Remove the server from the store database
-        ServerSubCommand._store.remove_server(server_id=server.id)
+        # Use ServerService to remove the server
+        delete_result = server_service.delete_server(name=name)
 
-        echo(
-            message=f"Server {server.name}({server.hostname_or_ip}) removed from EasyRunner."
-        )
+        if delete_result.success:
+            echo(
+                message=f"Server {server.name}({server.hostname_or_ip}) removed from EasyRunner."
+            )
+        else:
+            echo(message=f"Failed to remove server: {delete_result.message}")
 
     @typer_app.command(
         name="create",