Testing¶

class TestNewCommandSyntax:
    """Test syntax validation for 'azlin new' command."""

    def test_no_arguments_shows_help(self):
        """Test that 'azlin new' with no args shows help."""
        runner = CliRunner()
        result = runner.invoke(main, ["new"])

        assert result.exit_code == 0
        assert "Usage:" in result.output or "Options:" in result.output

    def test_with_repo_only_succeeds(self):
        """Test that 'azlin new --repo URL' is valid minimal syntax."""
        runner = CliRunner()
        with patch("azlin.vm_manager.VMManager.create_vm"):
            result = runner.invoke(main, ["new", "--repo", "https://github.com/user/repo"])

            # Should succeed (or fail for other reasons, not syntax)
            assert "Error: Missing" not in result.output

    def test_empty_string_repo_shows_error(self):
        """Test that 'azlin new --repo \"\"' shows validation error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", ""])

        assert result.exit_code != 0
        assert "empty" in result.output.lower() or "invalid" in result.output.lower()

class TestNewCommandOptions:
    """Test option combinations for 'azlin new' command."""

    def test_pool_and_name_are_mutually_exclusive(self):
        """Test that --pool and --name cannot be used together."""
        runner = CliRunner()
        result = runner.invoke(main, [
            "new",
            "--repo", "https://github.com/user/repo",
            "--pool", "3",
            "--name", "custom-vm"
        ])

        assert result.exit_code != 0
        assert "mutually exclusive" in result.output.lower() or "cannot use" in result.output.lower()

    def test_short_and_long_form_resource_group(self):
        """Test that -rg and --resource-group are equivalent."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            # Test with --resource-group
            result1 = runner.invoke(main, ["new", "--repo", "...", "--resource-group", "test-rg"])

            # Test with -rg
            result2 = runner.invoke(main, ["new", "--repo", "...", "-rg", "test-rg"])

            # Both should call create_vm with same resource_group
            assert mock_create.call_count == 2
            call1_kwargs = mock_create.call_args_list[0][1]
            call2_kwargs = mock_create.call_args_list[1][1]
            assert call1_kwargs.get("resource_group") == call2_kwargs.get("resource_group")

    def test_all_valid_options_together(self):
        """Test maximum valid option combination."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm"):
            result = runner.invoke(main, [
                "new",
                "--repo", "https://github.com/user/repo",
                "--vm-size", "Standard_D2s_v3",
                "--region", "eastus",
                "--resource-group", "test-rg",
                "--config", "/path/to/config.yaml",
                "--template", "python-dev",
                "--nfs-storage", "my-storage",
                "--no-auto-connect"
            ])

            # Should succeed (assuming mocks are proper)
            assert "cannot use" not in result.output.lower()

class TestCommandAliases:
    """Test command aliases (vm/new/create, kill/destroy)."""

    def test_vm_and_new_are_equivalent(self):
        """Test that 'azlin vm' and 'azlin new' are identical."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            # Test with 'vm'
            result1 = runner.invoke(main, ["vm", "--repo", "https://..."])

            mock_create.reset_mock()

            # Test with 'new'
            result2 = runner.invoke(main, ["new", "--repo", "https://..."])

            # Both should call same underlying function
            assert mock_create.call_count == 1  # Each should call once
            # Exit codes should match
            assert result1.exit_code == result2.exit_code

    def test_kill_and_destroy_are_equivalent(self):
        """Test that 'azlin kill' and 'azlin destroy' are identical."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.delete_vm") as mock_delete:
            result1 = runner.invoke(main, ["kill", "test-vm", "--force"])
            mock_delete.reset_mock()
            result2 = runner.invoke(main, ["destroy", "test-vm", "--force"])

            assert result1.exit_code == result2.exit_code

class TestNewCommandErrors:
    """Test error handling for 'azlin new' command."""

    def test_invalid_vm_size_shows_error(self):
        """Test that invalid VM size shows clear error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "...", "--vm-size", "InvalidSize"])

        assert result.exit_code != 0
        assert "invalid" in result.output.lower() or "not valid" in result.output.lower()

    def test_invalid_region_shows_error(self):
        """Test that invalid region shows clear error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "...", "--region", "mars-central"])

        assert result.exit_code != 0
        assert "region" in result.output.lower()

    def test_unknown_option_shows_error(self):
        """Test that unknown option shows helpful error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--unknown-option", "value"])

        assert result.exit_code != 0
        assert "no such option" in result.output.lower() or "unknown option" in result.output.lower()

    def test_missing_azure_credentials_shows_clear_message(self):
        """Test that missing Azure credentials shows helpful error."""
        runner = CliRunner()

        with patch("azure.identity.DefaultAzureCredential", side_effect=Exception("No credentials")):
            result = runner.invoke(main, ["new", "--repo", "https://..."])

            assert result.exit_code != 0
            assert "credential" in result.output.lower() or "authentication" in result.output.lower()

class TestNewCommandHelp:
    """Test help text for 'azlin new' command."""

    def test_help_flag_shows_usage(self):
        """Test that 'azlin new --help' shows complete usage."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--help"])

        assert result.exit_code == 0
        assert "Usage:" in result.output
        assert "Options:" in result.output

    def test_help_documents_all_options(self):
        """Test that help text includes all available options."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--help"])

        required_options = [
            "--repo",
            "--vm-size",
            "--region",
            "--resource-group",
            "--name",
            "--pool",
            "--no-auto-connect",
            "--config",
            "--template",
            "--nfs-storage"
        ]

        for option in required_options:
            assert option in result.output, f"Option {option} not documented in help"

    def test_help_includes_examples(self):
        """Test that help text includes usage examples."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--help"])

        # Check for example patterns
        assert "example" in result.output.lower() or "azlin new" in result.output.lower()

    def test_short_help_flag_works(self):
        """Test that -h works as alias for --help."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "-h"])

        assert result.exit_code == 0
        assert "Usage:" in result.output

"""Unit tests for 'azlin <command>' command syntax."""

from unittest.mock import patch, Mock
import pytest
from click.testing import CliRunner
from azlin.cli import main


class Test<Command>CommandSyntax:
    """Test basic syntax validation for '<command>' command."""

    def test_no_arguments_behavior(self):
        """Test command behavior with no arguments."""
        runner = CliRunner()
        result = runner.invoke(main, ["<command>"])

        # Define expected behavior (error, help, or success)
        assert result.exit_code == 0  # or != 0 for error

    def test_required_arguments_only(self):
        """Test command with only required arguments."""
        runner = CliRunner()
        with patch("<mock_path>"):
            result = runner.invoke(main, ["<command>", "<required_arg>"])

            assert result.exit_code == 0

    def test_with_all_options(self):
        """Test command with all available options."""
        runner = CliRunner()
        with patch("<mock_path>"):
            result = runner.invoke(main, [
                "<command>",
                "<required_arg>",
                "--option1", "value1",
                "--option2", "value2"
            ])

            assert result.exit_code == 0


class Test<Command>CommandOptions:
    """Test option combinations for '<command>' command."""

    def test_mutually_exclusive_options(self):
        """Test that mutually exclusive options show error."""
        runner = CliRunner()
        result = runner.invoke(main, [
            "<command>",
            "--option1", "value1",
            "--option2", "value2"  # Conflicts with option1
        ])

        assert result.exit_code != 0
        assert "cannot use" in result.output.lower()

    def test_option_value_validation(self):
        """Test that invalid option values show error."""
        runner = CliRunner()
        result = runner.invoke(main, ["<command>", "--option", "invalid_value"])

        assert result.exit_code != 0


class Test<Command>CommandErrors:
    """Test error handling for '<command>' command."""

    def test_unknown_option_shows_error(self):
        """Test that unknown options show helpful error."""
        runner = CliRunner()
        result = runner.invoke(main, ["<command>", "--unknown-option", "value"])

        assert result.exit_code != 0
        assert "no such option" in result.output.lower()

    def test_missing_resource_shows_error(self):
        """Test that missing resource shows clear error."""
        runner = CliRunner()
        with patch("<mock_path>", side_effect=Exception("Not found")):
            result = runner.invoke(main, ["<command>", "nonexistent"])

            assert result.exit_code != 0
            assert "not found" in result.output.lower()


class Test<Command>CommandHelp:
    """Test help text for '<command>' command."""

    def test_help_flag_shows_complete_usage(self):
        """Test that --help shows complete usage information."""
        runner = CliRunner()
        result = runner.invoke(main, ["<command>", "--help"])

        assert result.exit_code == 0
        assert "Usage:" in result.output
        assert "Options:" in result.output

"""Unit tests for 'azlin <group>' command group syntax."""

from unittest.mock import patch, Mock
import pytest
from click.testing import CliRunner
from azlin.cli import main


class Test<Group>GroupSyntax:
    """Test basic syntax for '<group>' command group."""

    def test_group_without_subcommand_shows_help(self):
        """Test that 'azlin <group>' shows available subcommands."""
        runner = CliRunner()
        result = runner.invoke(main, ["<group>"])

        assert result.exit_code == 0
        assert "Commands:" in result.output or "Usage:" in result.output

    def test_group_help_flag(self):
        """Test that 'azlin <group> --help' shows group help."""
        runner = CliRunner()
        result = runner.invoke(main, ["<group>", "--help"])

        assert result.exit_code == 0
        assert "<subcommand1>" in result.output
        assert "<subcommand2>" in result.output


class Test<Group><Subcommand>Syntax:
    """Test syntax for '<group> <subcommand>' command."""

    def test_subcommand_no_arguments(self):
        """Test subcommand with no arguments."""
        runner = CliRunner()
        result = runner.invoke(main, ["<group>", "<subcommand>"])

        # Define expected behavior
        assert result.exit_code == 0  # or != 0

    def test_subcommand_with_required_arguments(self):
        """Test subcommand with required arguments."""
        runner = CliRunner()
        with patch("<mock_path>"):
            result = runner.invoke(main, [
                "<group>",
                "<subcommand>",
                "<required_arg>"
            ])

            assert result.exit_code == 0

    def test_subcommand_with_options(self):
        """Test subcommand with options."""
        runner = CliRunner()
        with patch("<mock_path>"):
            result = runner.invoke(main, [
                "<group>",
                "<subcommand>",
                "--option", "value"
            ])

            assert result.exit_code == 0


class Test<Group><Subcommand>Errors:
    """Test error handling for '<group> <subcommand>' command."""

    def test_invalid_subcommand_shows_error(self):
        """Test that invalid subcommand shows error."""
        runner = CliRunner()
        result = runner.invoke(main, ["<group>", "invalid-subcommand"])

        assert result.exit_code != 0
        assert "no such command" in result.output.lower()

    def test_missing_required_argument_shows_error(self):
        """Test that missing required argument shows error."""
        runner = CliRunner()
        result = runner.invoke(main, ["<group>", "<subcommand>"])

        assert result.exit_code != 0
        assert "required" in result.output.lower() or "missing" in result.output.lower()

@pytest.fixture
def cli_runner():
    """CliRunner instance for testing Click commands."""
    return CliRunner()


@pytest.fixture
def mock_vm_manager():
    """Mock VMManager for testing without Azure API calls."""
    with patch("azlin.vm_manager.VMManager") as mock:
        mock_instance = Mock()
        mock_instance.create_vm.return_value = {
            "name": "test-vm",
            "status": "Running",
            "ip": "20.123.45.67"
        }
        mock_instance.list_vms.return_value = [
            {"name": "vm1", "status": "Running"},
            {"name": "vm2", "status": "Stopped"}
        ]
        mock_instance.get_vm.return_value = {"name": "test-vm", "status": "Running"}
        mock_instance.delete_vm.return_value = True
        mock.return_value = mock_instance
        yield mock


@pytest.fixture
def mock_azure_cli_success():
    """Mock successful Azure CLI commands."""
    with patch("subprocess.run") as mock:
        mock.return_value = Mock(
            returncode=0,
            stdout='{"id": "/subscriptions/test", "name": "test-vm"}',
            stderr=""
        )
        yield mock


@pytest.fixture
def mock_azure_cli_failure():
    """Mock failed Azure CLI commands."""
    with patch("subprocess.run") as mock:
        mock.return_value = Mock(
            returncode=1,
            stdout="",
            stderr="Error: Resource not found"
        )
        yield mock


@pytest.fixture
def sample_vm_list():
    """Sample VM list for testing list/status commands."""
    return [
        {
            "name": "test-vm-1",
            "status": "Running",
            "resource_group": "test-rg",
            "location": "eastus",
            "size": "Standard_D2s_v3",
            "public_ip": "20.123.45.67"
        },
        {
            "name": "test-vm-2",
            "status": "Stopped",
            "resource_group": "test-rg",
            "location": "westus",
            "size": "Standard_B2s",
            "public_ip": None
        }
    ]


@pytest.fixture
def invalid_option_values():
    """Common invalid option values for testing validation."""
    return {
        "empty_string": "",
        "whitespace_only": "   ",
        "invalid_url": "not-a-url",
        "invalid_region": "mars-central-1",
        "invalid_vm_size": "NotARealVMSize",
        "negative_number": "-5",
        "non_integer": "abc123",
        "special_chars": "test@#$%^&*()"
    }

def assert_cli_error(result, expected_message_fragment):
    """Assert that CLI invocation failed with expected error message."""
    assert result.exit_code != 0
    assert expected_message_fragment.lower() in result.output.lower()


def assert_cli_success(result):
    """Assert that CLI invocation succeeded."""
    assert result.exit_code == 0
    assert "error" not in result.output.lower()


def assert_help_text_complete(result, expected_options):
    """Assert that help text documents all expected options."""
    assert result.exit_code == 0
    assert "Usage:" in result.output
    for option in expected_options:
        assert option in result.output, f"Option {option} not in help text"


def invoke_with_mock(runner, command_args, mock_target, mock_return_value=None):
    """Invoke CLI with mock for testing."""
    with patch(mock_target) as mock:
        if mock_return_value:
            mock.return_value = mock_return_value
        result = runner.invoke(main, command_args)
        return result, mock

"""Unit tests for 'azlin new' command syntax and behavior."""

from unittest.mock import patch, Mock
import pytest
from click.testing import CliRunner
from azlin.cli import main


class TestNewCommandSyntax:
    """Test basic syntax validation for 'azlin new' command."""

    def test_no_arguments_shows_help(self):
        """Test that 'azlin new' with no arguments shows help text."""
        runner = CliRunner()
        result = runner.invoke(main, ["new"])

        assert result.exit_code == 0
        assert "Usage:" in result.output or "Options:" in result.output

    def test_with_repo_only_is_valid(self):
        """Test that --repo alone is valid minimal syntax."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            result = runner.invoke(main, ["new", "--repo", "https://github.com/user/repo"])

            assert mock_create.called
            assert "Error: Missing" not in result.output

    def test_empty_string_repo_shows_error(self):
        """Test that empty --repo value shows validation error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", ""])

        assert result.exit_code != 0
        assert "empty" in result.output.lower() or "invalid" in result.output.lower()

    def test_whitespace_only_repo_shows_error(self):
        """Test that whitespace-only --repo value shows error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "   "])

        assert result.exit_code != 0

    def test_with_all_valid_options(self):
        """Test command with all valid options specified."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm"):
            result = runner.invoke(main, [
                "new",
                "--repo", "https://github.com/user/repo",
                "--vm-size", "Standard_D2s_v3",
                "--region", "eastus",
                "--resource-group", "test-rg",
                "--name", "custom-vm",
                "--config", "/path/to/config.yaml",
                "--template", "python-dev",
                "--nfs-storage", "my-storage",
                "--no-auto-connect"
            ])

            assert result.exit_code == 0


class TestNewCommandOptions:
    """Test option combinations for 'azlin new' command."""

    def test_pool_and_name_are_mutually_exclusive(self):
        """Test that --pool and --name cannot be used together."""
        runner = CliRunner()
        result = runner.invoke(main, [
            "new",
            "--repo", "https://github.com/user/repo",
            "--pool", "3",
            "--name", "custom-vm"
        ])

        assert result.exit_code != 0
        assert "mutually exclusive" in result.output.lower() or "cannot" in result.output.lower()

    def test_resource_group_short_and_long_form_equivalent(self):
        """Test that -rg and --resource-group are equivalent."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            # Long form
            runner.invoke(main, ["new", "--repo", "https://...", "--resource-group", "test-rg"])
            long_form_call = mock_create.call_args

            mock_create.reset_mock()

            # Short form
            runner.invoke(main, ["new", "--repo", "https://...", "-rg", "test-rg"])
            short_form_call = mock_create.call_args

            # Both should pass same resource_group
            assert long_form_call == short_form_call

    def test_pool_with_positive_integer_succeeds(self):
        """Test that --pool accepts positive integers."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm"):
            result = runner.invoke(main, ["new", "--repo", "https://...", "--pool", "5"])

            assert result.exit_code == 0

    def test_pool_with_zero_shows_error(self):
        """Test that --pool 0 shows validation error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "https://...", "--pool", "0"])

        assert result.exit_code != 0

    def test_pool_with_negative_shows_error(self):
        """Test that --pool with negative number shows error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "https://...", "--pool", "-1"])

        assert result.exit_code != 0

    def test_pool_with_non_integer_shows_error(self):
        """Test that --pool with non-integer shows error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "https://...", "--pool", "abc"])

        assert result.exit_code != 0
        assert "integer" in result.output.lower() or "invalid" in result.output.lower()

    def test_config_file_path_validation(self):
        """Test that --config validates file path format."""
        runner = CliRunner()

        with patch("azlin.config_manager.ConfigManager.load_config"):
            result = runner.invoke(main, ["new", "--repo", "https://...", "--config", "/valid/path.yaml"])

            # Should not fail on path format
            assert "invalid path" not in result.output.lower()

    def test_no_auto_connect_flag(self):
        """Test that --no-auto-connect flag works."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            result = runner.invoke(main, ["new", "--repo", "https://...", "--no-auto-connect"])

            assert mock_create.called
            # Verify no_auto_connect was passed
            call_kwargs = mock_create.call_args[1]
            assert call_kwargs.get("no_auto_connect") is True


class TestNewCommandErrors:
    """Test error handling for 'azlin new' command."""

    def test_unknown_option_shows_error(self):
        """Test that unknown options show helpful error message."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--unknown-option", "value"])

        assert result.exit_code != 0
        assert "no such option" in result.output.lower()

    def test_invalid_vm_size_shows_error(self):
        """Test that invalid VM size shows clear error."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm", side_effect=ValueError("Invalid VM size")):
            result = runner.invoke(main, ["new", "--repo", "https://...", "--vm-size", "InvalidSize"])

            assert result.exit_code != 0
            assert "invalid" in result.output.lower()

    def test_invalid_region_shows_error(self):
        """Test that invalid region shows clear error."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm", side_effect=ValueError("Invalid region")):
            result = runner.invoke(main, ["new", "--repo", "https://...", "--region", "invalid-region"])

            assert result.exit_code != 0
            assert "region" in result.output.lower()

    def test_invalid_repo_url_shows_error(self):
        """Test that invalid repository URL shows error."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--repo", "not-a-valid-url"])

        # May fail at validation or during execution
        # Just ensure error is shown
        assert result.exit_code != 0 or "error" in result.output.lower()

    def test_missing_azure_credentials_shows_helpful_message(self):
        """Test that missing Azure credentials shows helpful error."""
        runner = CliRunner()

        with patch("azure.identity.DefaultAzureCredential", side_effect=Exception("No credentials found")):
            result = runner.invoke(main, ["new", "--repo", "https://..."])

            assert result.exit_code != 0
            assert "credential" in result.output.lower() or "auth" in result.output.lower()

    def test_azure_quota_exceeded_shows_clear_error(self):
        """Test that Azure quota errors show clear message."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm", side_effect=Exception("QuotaExceeded")):
            result = runner.invoke(main, ["new", "--repo", "https://..."])

            assert result.exit_code != 0
            assert "quota" in result.output.lower()

    def test_network_timeout_shows_error(self):
        """Test that network timeouts show appropriate error."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm", side_effect=TimeoutError("Connection timeout")):
            result = runner.invoke(main, ["new", "--repo", "https://..."])

            assert result.exit_code != 0
            assert "timeout" in result.output.lower() or "connection" in result.output.lower()


class TestNewCommandHelp:
    """Test help text for 'azlin new' command."""

    def test_help_flag_shows_complete_usage(self):
        """Test that --help shows complete usage information."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--help"])

        assert result.exit_code == 0
        assert "Usage:" in result.output
        assert "Options:" in result.output

    def test_help_documents_all_options(self):
        """Test that help text includes all available options."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--help"])

        expected_options = [
            "--repo",
            "--vm-size",
            "--region",
            "--resource-group",
            "--name",
            "--pool",
            "--no-auto-connect",
            "--config",
            "--template",
            "--nfs-storage"
        ]

        for option in expected_options:
            assert option in result.output, f"Option {option} not documented"

    def test_help_includes_usage_examples(self):
        """Test that help text includes usage examples."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "--help"])

        # Check for example patterns
        assert "example" in result.output.lower() or "azlin new" in result.output

    def test_short_help_flag_works(self):
        """Test that -h is alias for --help."""
        runner = CliRunner()
        result = runner.invoke(main, ["new", "-h"])

        assert result.exit_code == 0
        assert "Usage:" in result.output


class TestNewCommandAliases:
    """Test aliases for 'azlin new' command (vm, create)."""

    def test_new_and_vm_are_equivalent(self):
        """Test that 'azlin new' and 'azlin vm' produce same result."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            result_new = runner.invoke(main, ["new", "--repo", "https://..."])
            new_exit_code = result_new.exit_code

            mock_create.reset_mock()

            result_vm = runner.invoke(main, ["vm", "--repo", "https://..."])
            vm_exit_code = result_vm.exit_code

            assert new_exit_code == vm_exit_code

    def test_new_and_create_are_equivalent(self):
        """Test that 'azlin new' and 'azlin create' produce same result."""
        runner = CliRunner()

        with patch("azlin.vm_manager.VMManager.create_vm") as mock_create:
            result_new = runner.invoke(main, ["new", "--repo", "https://..."])
            result_create = runner.invoke(main, ["create", "--repo", "https://..."])

            assert result_new.exit_code == result_create.exit_code