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

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

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

easyrunner_cli-0.0.8.dev130/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.dev130}/pyproject.toml

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

{easyrunner_cli-0.0.8.dev128 → easyrunner_cli-0.0.8.dev130}/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.dev130}/source/integrations/secret_store/keyring_secret_store.py

@@ -171,13 +171,13 @@ class KeyringSecretStore(SecretStore):
                 )
                 return True
             else:
-                logger.warning(
+                logger.debug(
                     f"Failed to store secret (status: {status}), falling back to standard keyring"
                 )
                 return self._store_secret_standard(service, account, value)
 
         except Exception as e:
-            logger.warning(
+            logger.debug(
                 f"Failed to store secret securely: {e}, falling back to standard keyring"
             )
             return self._store_secret_standard(service, account, value)
@@ -210,7 +210,7 @@ class KeyringSecretStore(SecretStore):
                 kSecReturnData: True,
             }
 
-            result = None
+            result = []
             status = SecItemCopyMatching(query, result)
 
             if status == errSecSuccess and result:
@@ -224,13 +224,13 @@ class KeyringSecretStore(SecretStore):
                 logger.error("Authentication failed when retrieving secret")
                 return None
             else:
-                logger.warning(
+                logger.debug(
                     f"Failed to retrieve secret (status: {status}), falling back to standard keyring"
                 )
                 return self._get_secret_standard(service, account)
 
         except Exception as e:
-            logger.warning(
+            logger.debug(
                 f"Failed to retrieve secret securely: {e}, falling back to standard keyring"
             )
             return self._get_secret_standard(service, account)
@@ -264,13 +264,13 @@ class KeyringSecretStore(SecretStore):
                 logger.debug(f"Secret deleted from keyring: {service}/{account}")
                 return True
             else:
-                logger.warning(
+                logger.debug(
                     f"Failed to delete secret (status: {status}), falling back to standard keyring"
                 )
                 return self._delete_secret_standard(service, account)
 
         except Exception as e:
-            logger.warning(
+            logger.debug(
                 f"Failed to delete secret securely: {e}, falling back to standard keyring"
             )
             return self._delete_secret_standard(service, account)

{easyrunner_cli-0.0.8.dev128 → easyrunner_cli-0.0.8.dev130}/source/link_sub_command.py

@@ -438,9 +438,7 @@ class LinkSubCommand:
     @staticmethod
     def link_status() -> None:
         """Show link status for all services."""
-        LinkSubCommand._progress_callback(
-            "[bold blue]� Link Status[/bold blue]\n", "\n"
-        )
+        LinkSubCommand._progress_callback("[bold blue]Link Status[/bold blue]\n", "\n")
 
         # Check GitHub
         token_manager = GitHubTokenManager(secret_store=KeyringSecretStore())
@@ -481,6 +479,21 @@ class LinkSubCommand:
                 "Hetzner (default): [yellow]⚠️  Not linked[/yellow]", "\n"
             )
 
+        # Check Cloudflare (default account)
+        api_token_manager = CloudflareApiTokenManager(
+            account_name="default", secret_store=KeyringSecretStore()
+        )
+        stored_api_token = api_token_manager.get_api_token()
+
+        if stored_api_token:
+            LinkSubCommand._progress_callback(
+                "Cloudflare (default): [green]✅ Linked[/green]", "\n"
+            )
+        else:
+            LinkSubCommand._progress_callback(
+                "Cloudflare (default): [yellow]⚠️  Not linked[/yellow]", "\n"
+            )
+
         LinkSubCommand._progress_callback(
             "\n💡 Use 'er link github' to authenticate with GitHub", "\n"
         )