@ngocsangairvds/vsaf 3.1.26 → 3.2.1

package/tools/vds-scripts/jira_orchestrator/tests/test_config.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from vds_jira_orchestrator.config import JiraSettings, SettingsError, load_settings
+
+
+@pytest.fixture(autouse=True)
+def _isolate_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    for key in ("VDS_USERNAME", "VDS_PASSWORD", "JIRA_TOKEN", "JIRA_BASE_URL"):
+        monkeypatch.delenv(key, raising=False)
+    monkeypatch.setattr("vds_jira_orchestrator.config.DEFAULT_ENV_PATHS", (), raising=False)
+
+
+class TestJiraSettings:
+    """Test suite for JiraSettings."""
+
+    def test_default_settings(self) -> None:
+        """Test default settings values."""
+        settings = JiraSettings()
+        assert settings.base_url == "http://jira.digital.vn"
+        assert settings.username is None
+        assert settings.password is None
+        assert settings.token is None
+
+    def test_settings_from_dict(self) -> None:
+        """Test creating settings from dictionary."""
+        data = {
+            "VDS_USERNAME": "test_user",
+            "VDS_PASSWORD": "test_pass",
+            "JIRA_TOKEN": "test_token",
+            "JIRA_BASE_URL": "https://jira.test.com",
+        }
+        settings = JiraSettings.model_validate(data)
+        assert settings.username == "test_user"
+        assert settings.password == "test_pass"
+        assert settings.token == "test_token"
+        assert settings.base_url == "https://jira.test.com"
+
+    def test_require_basic_or_token_success_with_token(self) -> None:
+        """Test require_basic_or_token with token."""
+        settings = JiraSettings(JIRA_TOKEN="test_token")
+        settings.require_basic_or_token()  # Should not raise
+
+    def test_require_basic_or_token_success_with_basic(self) -> None:
+        """Test require_basic_or_token with username/password."""
+        settings = JiraSettings(VDS_USERNAME="test_user", VDS_PASSWORD="test_pass")
+        settings.require_basic_or_token()  # Should not raise
+
+    def test_require_basic_or_token_failure(self) -> None:
+        """Test require_basic_or_token with no credentials."""
+        settings = JiraSettings()
+        with pytest.raises(ValueError, match="Missing credentials"):
+            settings.require_basic_or_token()
+
+
+class TestLoadSettings:
+    """Test suite for load_settings function."""
+
+    def test_load_settings_from_env(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Test loading settings from environment variables."""
+        monkeypatch.setenv("VDS_USERNAME", "env_user")
+        monkeypatch.setenv("VDS_PASSWORD", "env_pass")
+        monkeypatch.setenv("JIRA_TOKEN", "env_token")
+
+        settings = load_settings()
+        assert settings.username == "env_user"
+        assert settings.password == "env_pass"
+        assert settings.token == "env_token"
+
+    def test_load_settings_from_file(self, tmp_path: Path) -> None:
+        """Test loading settings from .env file."""
+        env_content = """
+VDS_USERNAME=file_user
+VDS_PASSWORD=file_pass
+JIRA_TOKEN=file_token
+JIRA_BASE_URL=https://jira.file.com
+        """.strip()
+        env_path = tmp_path / ".env"
+        env_path.write_text(env_content)
+
+        settings = load_settings(env_path=env_path)
+        assert settings.username == "file_user"
+        assert settings.password == "file_pass"
+        assert settings.token == "file_token"
+        assert settings.base_url == "https://jira.file.com"
+
+    def test_load_settings_with_overrides(self) -> None:
+        """Test loading settings with overrides."""
+        overrides = {
+            "VDS_USERNAME": "override_user",
+            "VDS_PASSWORD": "override_pass",
+            "JIRA_TOKEN": "override_token",
+        }
+
+        settings = load_settings(overrides=overrides)
+        assert settings.username == "override_user"
+        assert settings.password == "override_pass"
+        assert settings.token == "override_token"
+
+    def test_load_settings_strict_success(self) -> None:
+        """Test loading settings in strict mode with valid credentials."""
+        overrides = {"JIRA_TOKEN": "test_token"}
+        settings = load_settings(overrides=overrides, strict=True)
+        assert settings.token == "test_token"
+
+    def test_load_settings_strict_failure(self) -> None:
+        """Test loading settings in strict mode with invalid credentials."""
+        with pytest.raises(SettingsError):
+            load_settings(strict=True)
+
+    def test_load_settings_invalid_data(self) -> None:
+        """Test loading settings with invalid data."""
+        overrides = {"JIRA_BASE_URL": "invalid_url"}  # Invalid URL format
+        with pytest.raises(SettingsError):
+            load_settings(overrides=overrides)
+
+    def test_env_file_parsing(self, tmp_path: Path) -> None:
+        """Test .env file parsing with various formats."""
+        env_content = """
+# Comment line
+VDS_USERNAME = "quoted_user"
+VDS_PASSWORD=unquoted_pass
+JIRA_TOKEN='single_quotes_token'
+EMPTY_VAR=
+# Another comment
+JIRA_BASE_URL=https://jira.test.com
+        """.strip()
+        env_path = tmp_path / ".env"
+        env_path.write_text(env_content)
+
+        settings = load_settings(env_path=env_path)
+        assert settings.username == "quoted_user"
+        assert settings.password == "unquoted_pass"
+        assert settings.token == "single_quotes_token"
+        assert settings.base_url == "https://jira.test.com"
+
+    def test_load_settings_precedence(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Test settings precedence: overrides > env > file."""
+        # Set up file
+        env_content = """
+VDS_USERNAME=file_user
+VDS_PASSWORD=file_pass
+JIRA_TOKEN=file_token
+        """.strip()
+        env_path = tmp_path / ".env"
+        env_path.write_text(env_content)
+
+        # Set up environment
+        monkeypatch.setenv("VDS_USERNAME", "env_user")
+        monkeypatch.setenv("VDS_PASSWORD", "env_pass")
+
+        # Set up overrides
+        overrides = {"VDS_USERNAME": "override_user"}
+
+        settings = load_settings(env_path=env_path, overrides=overrides)
+
+        # Override should win
+        assert settings.username == "override_user"
+        # Environment should be next
+        assert settings.password == "env_pass"
+        # File should be last
+        assert settings.token == "file_token"

package/tools/vds-scripts/jira_orchestrator/tests/test_dashboard.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+from typer.testing import CliRunner
+from vds_jira_orchestrator.cli import app
+from vds_jira_orchestrator.errors import JiraAdapterError, JiraNotFound
+
+
+def _runner() -> CliRunner:
+    return CliRunner()
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_get_requires_id(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test that dashboard get requires --dashboard-id."""
+    runner = _runner()
+    result = runner.invoke(app, ["dashboard", "get"])
+    assert result.exit_code != 0
+    assert "--dashboard-id required" in result.stderr
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_get_success_int(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test successful dashboard get with integer ID."""
+    runner = _runner()
+    mock_adapter = Mock()
+    mock_adapter.get_dashboard.return_value = {"id": "10000", "name": "Test Dashboard"}
+    mock_adapter_cls.return_value = mock_adapter
+
+    result = runner.invoke(app, ["dashboard", "get", "--dashboard-id", "10000"])
+    assert result.exit_code == 0
+    mock_adapter.get_dashboard.assert_called_once_with(10000)
+    assert "Test Dashboard" in result.stdout or "10000" in result.stdout
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_get_success_string(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test successful dashboard get with string ID."""
+    runner = _runner()
+    mock_adapter = Mock()
+    mock_adapter.get_dashboard.return_value = {"id": "abc123", "name": "Test Dashboard"}
+    mock_adapter_cls.return_value = mock_adapter
+
+    result = runner.invoke(app, ["dashboard", "get", "--dashboard-id", "abc123"])
+    assert result.exit_code == 0
+    mock_adapter.get_dashboard.assert_called_once_with("abc123")
+    assert "Test Dashboard" in result.stdout or "abc123" in result.stdout
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_list_success(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test successful dashboard list."""
+    runner = _runner()
+    mock_adapter = Mock()
+    mock_adapter.get_dashboards.return_value = {
+        "dashboards": [{"id": "10000", "name": "Dashboard 1"}, {"id": "10001", "name": "Dashboard 2"}]
+    }
+    mock_adapter_cls.return_value = mock_adapter
+
+    result = runner.invoke(app, ["dashboard", "list"])
+    assert result.exit_code == 0
+    mock_adapter.get_dashboards.assert_called_once_with(filter="", start=0, limit=10)
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_list_with_filter(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test dashboard list with filter and pagination."""
+    runner = _runner()
+    mock_adapter = Mock()
+    mock_adapter.get_dashboards.return_value = {"dashboards": []}
+    mock_adapter_cls.return_value = mock_adapter
+
+    result = runner.invoke(
+        app, ["dashboard", "list", "--filter", "test", "--start", "10", "--limit", "20"]
+    )
+    assert result.exit_code == 0
+    mock_adapter.get_dashboards.assert_called_once_with(filter="test", start=10, limit=20)
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_unknown_action(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test that unknown action raises error."""
+    runner = _runner()
+    result = runner.invoke(app, ["dashboard", "unknown"])
+    assert result.exit_code != 0
+    assert "Unknown action" in result.stderr
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_adapter_error(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test that adapter errors are handled."""
+    runner = _runner()
+    mock_adapter = Mock()
+    mock_adapter.get_dashboard.side_effect = JiraAdapterError("Adapter error")
+    mock_adapter_cls.return_value = mock_adapter
+
+    result = runner.invoke(app, ["dashboard", "get", "--dashboard-id", "10000"])
+    assert result.exit_code != 0
+    assert "Error" in result.stderr
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_dashboard_not_found(mock_settings: Mock, mock_adapter_cls: Mock) -> None:
+    """Test that not found errors are handled."""
+    runner = _runner()
+    mock_adapter = Mock()
+    mock_adapter.get_dashboard.side_effect = JiraNotFound("Dashboard not found: 99999")
+    mock_adapter_cls.return_value = mock_adapter
+
+    result = runner.invoke(app, ["dashboard", "get", "--dashboard-id", "99999"])
+    assert result.exit_code != 0
+    assert "Error" in result.stderr
+

package/tools/vds-scripts/jira_orchestrator/tests/test_discover_fields.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import json
+from unittest.mock import MagicMock, patch
+
+from typer.testing import CliRunner
+from vds_jira_orchestrator import cli
+
+
+def _mock_settings(mock_settings_cls: MagicMock) -> None:
+    settings = mock_settings_cls.return_value
+    settings.require_basic_or_token.return_value = None
+    settings.username = "user"
+    settings.password = "pass"
+    settings.token = "token"
+    settings.base_url = "https://jira.test"
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_discover_fields_outputs_sorted_fields(
+    mock_settings_cls: MagicMock,
+    mock_adapter_cls: MagicMock,
+) -> None:
+    _mock_settings(mock_settings_cls)
+    mock_adapter = mock_adapter_cls.return_value
+    mock_adapter.get_createmeta.return_value = {
+        "projects": [
+            {
+                "key": "TEST",
+                "issuetypes": [
+                    {
+                        "name": "Task",
+                        "fields": {
+                            "summary": {
+                                "name": "Summary",
+                                "required": True,
+                                "schema": {"type": "string"},
+                            },
+                            "customfield_10000": {
+                                "name": "Choice",
+                                "required": False,
+                                "schema": {"type": "option"},
+                                "allowedValues": [{"id": 1, "value": "Option A"}],
+                            },
+                        },
+                    }
+                ],
+            }
+        ]
+    }
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli.app,
+        ["discover-fields", "--project", "TEST", "--issuetype", "Task", "--include-system"],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["count"] == 2
+    assert "duration_ms" in payload
+    assert payload["fields"][0]["name"] == "Summary"
+    assert payload["fields"][0]["required"] is True
+    assert payload["fields"][1]["allowedValues"] == [{"id": "1", "value": "Option A"}]
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_discover_fields_excludes_system_by_default(
+    mock_settings_cls: MagicMock,
+    mock_adapter_cls: MagicMock,
+) -> None:
+    _mock_settings(mock_settings_cls)
+    mock_adapter = mock_adapter_cls.return_value
+    mock_adapter.get_createmeta.return_value = {
+        "projects": [
+            {
+                "key": "TEST",
+                "issuetypes": [
+                    {
+                        "name": "Task",
+                        "fields": {
+                            "summary": {
+                                "name": "Summary",
+                                "required": True,
+                                "schema": {"type": "string"},
+                            },
+                            "customfield_10000": {
+                                "name": "Choice",
+                                "required": False,
+                                "schema": {"type": "option"},
+                            },
+                        },
+                    }
+                ],
+            }
+        ]
+    }
+
+    runner = CliRunner()
+    result = runner.invoke(cli.app, ["discover-fields", "--project", "TEST", "--issuetype", "Task"])
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["count"] == 1
+    assert payload["fields"][0]["id"] == "customfield_10000"
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_discover_fields_filters_by_name(
+    mock_settings_cls: MagicMock,
+    mock_adapter_cls: MagicMock,
+) -> None:
+    _mock_settings(mock_settings_cls)
+    mock_adapter = mock_adapter_cls.return_value
+    mock_adapter.get_createmeta.return_value = {
+        "projects": [
+            {
+                "key": "TEST",
+                "issuetypes": [
+                    {
+                        "name": "Task",
+                        "fields": {
+                            "customfield_10000": {
+                                "name": "Choice",
+                                "required": False,
+                                "schema": {"type": "option"},
+                            },
+                            "customfield_10001": {
+                                "name": "Owner",
+                                "required": False,
+                                "schema": {"type": "user"},
+                            },
+                        },
+                    }
+                ],
+            }
+        ]
+    }
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli.app,
+        ["discover-fields", "--project", "TEST", "--issuetype", "Task", "--field", "choice"],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["count"] == 1
+    assert payload["fields"][0]["name"] == "Choice"
+
+
+@patch("vds_jira_orchestrator.cli.JiraAdapter")
+@patch("vds_jira_orchestrator.cli.JiraSettings")
+def test_discover_fields_merges_allowed_values_from_editmeta(
+    mock_settings_cls: MagicMock,
+    mock_adapter_cls: MagicMock,
+) -> None:
+    _mock_settings(mock_settings_cls)
+    mock_adapter = mock_adapter_cls.return_value
+    mock_adapter.get_createmeta.return_value = {
+        "projects": [
+            {
+                "key": "TEST",
+                "issuetypes": [
+                    {
+                        "name": "Task",
+                        "fields": {
+                            "customfield_10000": {
+                                "name": "Choice",
+                                "required": False,
+                                "schema": {"type": "option"},
+                            },
+                        },
+                    }
+                ],
+            }
+        ]
+    }
+    mock_adapter.get_editmeta.return_value = {
+        "fields": {
+            "customfield_10000": {
+                "allowedValues": [{"id": 10, "value": "Option X"}],
+            }
+        }
+    }
+
+    runner = CliRunner()
+    result = runner.invoke(
+        cli.app,
+        [
+            "discover-fields",
+            "--project",
+            "TEST",
+            "--issuetype",
+            "Task",
+            "--issue-key",
+            "TEST-1",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["count"] == 1
+    assert payload["fields"][0]["allowedValues"] == [{"id": "10", "value": "Option X"}]