feat: add generate command

- Add generate command to create values files for deployments
- Add pyyaml dependency for YAML file generation
- Update CLI with generate command and flags
- Add integration tests for generate command
- Update test plugin script with generate command tests
- Update sequence diagrams with correct command flags

The generate command allows users to create values.yaml files for specific
deployments, with support for custom output paths. Required values are
validated before generation.

Author: ritwik-g

helm_values_manager/cli.py

@@ -4,6 +4,7 @@
 
 from helm_values_manager.commands.add_deployment_command import AddDeploymentCommand
 from helm_values_manager.commands.add_value_config_command import AddValueConfigCommand
+from helm_values_manager.commands.generate_command import GenerateCommand
 from helm_values_manager.commands.init_command import InitCommand
 from helm_values_manager.commands.set_value_command import SetValueCommand
 from helm_values_manager.models.config_metadata import ConfigMetadata
@@ -125,5 +126,24 @@ def set_value(
         raise typer.Exit(code=1) from e
 
 
+@app.command("generate")
+def generate(
+    deployment: str = typer.Option(
+        ..., "--deployment", "-d", help="Deployment to generate values for (e.g., 'dev', 'prod')"
+    ),
+    output_path: str = typer.Option(
+        ".", "--output", "-o", help="Directory to output the values file to (default: current directory)"
+    ),
+):
+    """Generate a values file for a specific deployment."""
+    try:
+        command = GenerateCommand()
+        result = command.execute(deployment=deployment, output_path=output_path)
+        typer.echo(result)
+    except Exception as e:
+        HelmLogger.error("Failed to generate values file: %s", str(e))
+        raise typer.Exit(code=1) from e
+
+
 if __name__ == "__main__":
     app(prog_name=COMMAND_INFO)

helm_values_manager/commands/generate_command.py

@@ -0,0 +1,122 @@
+"""Command to generate values file for a specific deployment."""
+
+import os
+from typing import Any, Dict, Optional
+
+import yaml
+
+from helm_values_manager.commands.base_command import BaseCommand
+from helm_values_manager.models.helm_values_config import HelmValuesConfig
+from helm_values_manager.utils.logger import HelmLogger
+
+
+class GenerateCommand(BaseCommand):
+    """Command to generate values file for a specific deployment."""
+
+    def run(self, config: Optional[HelmValuesConfig] = None, **kwargs) -> str:
+        """
+        Generate a values file for a specific deployment.
+
+        Args:
+            config: The loaded configuration
+            **kwargs: Command arguments
+                - deployment (str): The deployment to generate values for (e.g., 'dev', 'prod')
+                - output_path (str, optional): Directory to output the values file to
+
+        Returns:
+            str: Success message with the path to the generated file
+
+        Raises:
+            ValueError: If deployment is empty
+            KeyError: If deployment doesn't exist in the configuration
+            FileNotFoundError: If the configuration file doesn't exist
+        """
+        if config is None:
+            raise ValueError("Configuration not loaded")
+
+        deployment = kwargs.get("deployment")
+        if not deployment:
+            raise ValueError("Deployment cannot be empty")
+
+        output_path = kwargs.get("output_path", ".")
+
+        # Validate that the deployment exists
+        if deployment not in config.deployments:
+            raise KeyError(f"Deployment '{deployment}' not found")
+
+        # Create output directory if it doesn't exist
+        if not os.path.exists(output_path):
+            os.makedirs(output_path)
+            HelmLogger.debug("Created output directory: %s", output_path)
+
+        # Generate values dictionary from configuration
+        values_dict = self._generate_values_dict(config, deployment)
+
+        # Generate filename based on deployment and release
+        filename = f"{deployment}.{config.release}.values.yaml"
+        file_path = os.path.join(output_path, filename)
+
+        # Write values to file
+        with open(file_path, "w", encoding="utf-8") as f:
+            yaml.dump(values_dict, f, default_flow_style=False)
+
+        HelmLogger.debug("Generated values file for deployment '%s' at '%s'", deployment, file_path)
+        return f"Successfully generated values file for deployment '{deployment}' at '{file_path}'"
+
+    def _generate_values_dict(self, config: HelmValuesConfig, deployment: str) -> Dict[str, Any]:
+        """
+        Generate a nested dictionary of values from the configuration.
+
+        Args:
+            config: The loaded configuration
+            deployment: The deployment to generate values for
+
+        Returns:
+            Dict[str, Any]: Nested dictionary of values
+
+        Raises:
+            ValueError: If a required value is missing for the deployment
+        """
+        values_dict = {}
+        missing_required_paths = []
+
+        # Get all paths from the configuration
+        for path in config._path_map.keys():
+            path_data = config._path_map[path]
+
+            # Check if this is a required value
+            is_required = path_data._metadata.required
+
+            # Get the value for this path and deployment
+            value = config.get_value(path, deployment, resolve=True)
+
+            # If the value is None and it's required, add to missing list
+            if value is None and is_required:
+                missing_required_paths.append(path)
+                continue
+
+            # Skip if no value is set
+            if value is None:
+                continue
+
+            # Convert dot-separated path to nested dictionary
+            path_parts = path.split(".")
+            current_dict = values_dict
+
+            # Navigate to the correct nested level
+            for i, part in enumerate(path_parts):
+                # If we're at the last part, set the value
+                if i == len(path_parts) - 1:
+                    current_dict[part] = value
+                else:
+                    # Create nested dictionary if it doesn't exist
+                    if part not in current_dict:
+                        current_dict[part] = {}
+                    current_dict = current_dict[part]
+
+        # If there are missing required values, raise an error
+        if missing_required_paths:
+            paths_str = ", ".join(missing_required_paths)
+            raise ValueError(f"Missing required values for deployment '{deployment}': {paths_str}")
+
+        return values_dict

pyproject.toml

@@ -16,6 +16,7 @@ urls = { Homepage = "https://github.com/zipstack/helm-values-manager" }
 dependencies = [
     "typer>=0.15.1,<0.16.0",
     "jsonschema>=4.21.1",
+    "pyyaml>=6.0.2",
 ]
 classifiers = [
     "Development Status :: 4 - Beta",

tests/integration/test_cli_integration.py

@@ -6,6 +6,7 @@
 from pathlib import Path
 
 import pytest
+import yaml
 
 
 def run_helm_command(command: list[str]) -> tuple[str, str, int]:
@@ -325,7 +326,7 @@ def test_set_value_nonexistent_path(plugin_install, tmp_path):
         ["values-manager", "init", "--release", "test-release"]
     )
     assert init_returncode == 0
-    assert Path("helm-values.json").exists()
+    assert Path(work_dir, "helm-values.json").exists()
 
     # Add a deployment
     add_deployment_stdout, add_deployment_stderr, add_deployment_returncode = run_helm_command(
@@ -375,3 +376,190 @@ def test_set_value_nonexistent_deployment(plugin_install, tmp_path):
     )
     assert returncode == 1
     assert "Deployment 'nonexistent' not found" in stderr
+
+
+def test_generate_help_command(plugin_install):
+    """Test that the generate help command works and shows expected output."""
+    stdout, stderr, returncode = run_helm_command(["values-manager", "generate", "--help"])
+    assert returncode == 0, f"Failed to run help command: {stderr}"
+    assert "Generate a values file for a specific deployment" in stdout, "Help text should include command description"
+    assert "--deployment" in stdout, "Help text should include deployment option"
+    assert "--output" in stdout, "Help text should include output option"
+
+
+def test_generate_command(plugin_install, tmp_path):
+    """Test that the generate command works correctly."""
+    # Create a test directory
+    test_dir = tmp_path / "test_generate_command"
+    test_dir.mkdir()
+    os.chdir(test_dir)
+
+    # Initialize the plugin
+    stdout, stderr, returncode = run_helm_command(["values-manager", "init", "--release", "test-release"])
+    assert returncode == 0, f"Failed to initialize plugin: {stderr}"
+
+    # Add a deployment
+    stdout, stderr, returncode = run_helm_command(["values-manager", "add-deployment", "dev"])
+    assert returncode == 0, f"Failed to add deployment: {stderr}"
+
+    # Add value configs
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "add-value-config", "--path", "app.replicas", "--description", "Number of replicas"]
+    )
+    assert returncode == 0, f"Failed to add value config: {stderr}"
+
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "add-value-config", "--path", "app.image.repository", "--description", "Image repository"]
+    )
+    assert returncode == 0, f"Failed to add value config: {stderr}"
+
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "add-value-config", "--path", "app.image.tag", "--description", "Image tag"]
+    )
+    assert returncode == 0, f"Failed to add value config: {stderr}"
+
+    # Set values
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "set-value", "--path", "app.replicas", "--deployment", "dev", "--value", "3"]
+    )
+    assert returncode == 0, f"Failed to set value: {stderr}"
+
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "set-value", "--path", "app.image.repository", "--deployment", "dev", "--value", "myapp"]
+    )
+    assert returncode == 0, f"Failed to set value: {stderr}"
+
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "set-value", "--path", "app.image.tag", "--deployment", "dev", "--value", "latest"]
+    )
+    assert returncode == 0, f"Failed to set value: {stderr}"
+
+    # Generate values file
+    stdout, stderr, returncode = run_helm_command(["values-manager", "generate", "--deployment", "dev"])
+    assert returncode == 0, f"Failed to generate values file: {stderr}"
+    assert "Successfully generated values file for deployment 'dev'" in stdout, f"Unexpected output: {stdout}"
+
+    # Verify the values file exists
+    values_file = test_dir / "dev.test-release.values.yaml"
+    assert values_file.exists(), "Values file should exist"
+
+    # Verify the content of the values file
+    with open(values_file, "r") as f:
+        values = yaml.safe_load(f)
+        assert values["app"]["replicas"] == "3", "Values file should contain correct replicas value"
+        assert values["app"]["image"]["repository"] == "myapp", "Values file should contain correct repository value"
+        assert values["app"]["image"]["tag"] == "latest", "Values file should contain correct tag value"
+
+
+def test_generate_with_output_path(plugin_install, tmp_path):
+    """Test that the generate command works with a custom output path."""
+    # Create a test directory
+    test_dir = tmp_path / "test_generate_with_output_path"
+    test_dir.mkdir()
+    os.chdir(test_dir)
+
+    # Create a custom output directory
+    output_dir = test_dir / "output"
+    output_dir.mkdir()
+
+    # Initialize the plugin
+    stdout, stderr, returncode = run_helm_command(["values-manager", "init", "--release", "test-release"])
+    assert returncode == 0, f"Failed to initialize plugin: {stderr}"
+
+    # Add a deployment
+    stdout, stderr, returncode = run_helm_command(["values-manager", "add-deployment", "prod"])
+    assert returncode == 0, f"Failed to add deployment: {stderr}"
+
+    # Add value configs
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "add-value-config", "--path", "app.replicas", "--description", "Number of replicas"]
+    )
+    assert returncode == 0, f"Failed to add value config: {stderr}"
+
+    # Set values
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "set-value", "--path", "app.replicas", "--deployment", "prod", "--value", "5"]
+    )
+    assert returncode == 0, f"Failed to set value: {stderr}"
+
+    # Generate values file with custom output path
+    stdout, stderr, returncode = run_helm_command(
+        ["values-manager", "generate", "--deployment", "prod", "--output", str(output_dir)]
+    )
+    assert returncode == 0, f"Failed to generate values file: {stderr}"
+    assert "Successfully generated values file for deployment 'prod'" in stdout, f"Unexpected output: {stdout}"
+
+    # Verify the values file exists in the custom output directory
+    values_file = output_dir / "prod.test-release.values.yaml"
+    assert values_file.exists(), "Values file should exist in the custom output directory"
+
+    # Verify the content of the values file
+    with open(values_file, "r") as f:
+        values = yaml.safe_load(f)
+        assert values["app"]["replicas"] == "5", "Values file should contain correct replicas value"
+
+
+def test_generate_nonexistent_deployment(plugin_install, tmp_path):
+    """Test that generating values for a nonexistent deployment fails with the correct error message."""
+    # Create a test directory
+    test_dir = tmp_path / "test_generate_nonexistent_deployment"
+    test_dir.mkdir()
+    os.chdir(test_dir)
+
+    # Initialize the plugin
+    stdout, stderr, returncode = run_helm_command(["values-manager", "init", "--release", "test-release"])
+    assert returncode == 0, f"Failed to initialize plugin: {stderr}"
+
+    # Try to generate values for a nonexistent deployment
+    stdout, stderr, returncode = run_helm_command(["values-manager", "generate", "--deployment", "nonexistent"])
+    assert returncode != 0, "Expected command to fail but it succeeded"
+    assert "Deployment 'nonexistent' not found" in stderr, f"Unexpected error message: {stderr}"
+
+
+def test_generate_no_config(plugin_install, tmp_path):
+    """Test that generating values without initializing fails with the correct error message."""
+    # Create a test directory
+    test_dir = tmp_path / "test_generate_no_config"
+    test_dir.mkdir()
+    os.chdir(test_dir)
+
+    # Try to generate values without initializing
+    stdout, stderr, returncode = run_helm_command(["values-manager", "generate", "--deployment", "dev"])
+    assert returncode != 0, "Expected command to fail but it succeeded"
+    assert "Configuration file helm-values.json not found" in stderr, f"Unexpected error message: {stderr}"
+
+
+def test_generate_with_missing_required_value(plugin_install, tmp_path):
+    """Test generate command with missing required values."""
+    # Change to temp directory
+    os.chdir(tmp_path)
+
+    # Initialize the config
+    stdout, stderr, returncode = run_helm_command(["values-manager", "init", "--release", "test-release"])
+    assert returncode == 0, f"Failed to initialize config: {stderr}"
+
+    # Add a deployment
+    stdout, stderr, returncode = run_helm_command(["values-manager", "add-deployment", "dev"])
+    assert returncode == 0, f"Failed to add deployment: {stderr}"
+
+    # Add a required value config but don't set a value for it
+    stdout, stderr, returncode = run_helm_command(
+        [
+            "values-manager",
+            "add-value-config",
+            "--path",
+            "app.required",
+            "--description",
+            "Required value",
+            "--required",
+        ]
+    )
+    assert returncode == 0, f"Failed to add value config: {stderr}"
+
+    # Try to generate values without setting the required value
+    stdout, stderr, returncode = run_helm_command(["values-manager", "generate", "--deployment", "dev"])
+
+    # Verify the command failed
+    assert returncode != 0, "Expected command to fail but it succeeded"
+    assert "Missing required values for deployment 'dev'" in stderr
+    assert "app.required" in stderr