@ngocsangairvds/vsaf 3.1.27 → 3.2.2

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

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from vds_jira_orchestrator.adapter import JiraAdapter, JiraAuthError, JiraNotFound
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboard_calls_client(mock_jira: MagicMock) -> None:
+    """Test that get_dashboard calls the SDK client."""
+    client = MagicMock()
+    client.get_dashboard.return_value = {"id": "10000", "name": "Test Dashboard"}
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_dashboard("10000")
+
+    client.get_dashboard.assert_called_once_with("10000")
+    assert result == {"id": "10000", "name": "Test Dashboard"}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboard_with_int_id(mock_jira: MagicMock) -> None:
+    """Test that get_dashboard works with integer ID."""
+    client = MagicMock()
+    client.get_dashboard.return_value = {"id": 10000, "name": "Test Dashboard"}
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_dashboard(10000)
+
+    client.get_dashboard.assert_called_once_with(10000)
+    assert result == {"id": 10000, "name": "Test Dashboard"}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboard_not_found(mock_jira: MagicMock) -> None:
+    """Test that get_dashboard raises JiraNotFound when dashboard is not found."""
+    client = MagicMock()
+    client.get_dashboard.return_value = None
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    with pytest.raises(JiraNotFound, match="Dashboard not found: 99999"):
+        adapter.get_dashboard("99999")
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboard_maps_error(mock_jira: MagicMock) -> None:
+    """Test that get_dashboard maps authentication errors."""
+    client = MagicMock()
+    client.get_dashboard.side_effect = Exception("401 unauthorized")
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    with pytest.raises(JiraAuthError):
+        adapter.get_dashboard("10000")
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboards_calls_client(mock_jira: MagicMock) -> None:
+    """Test that get_dashboards calls the SDK client."""
+    client = MagicMock()
+    client.get_dashboards.return_value = {
+        "dashboards": [{"id": "10000", "name": "Dashboard 1"}, {"id": "10001", "name": "Dashboard 2"}]
+    }
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_dashboards()
+
+    client.get_dashboards.assert_called_once_with(filter="", start=0, limit=10)
+    assert len(result["dashboards"]) == 2
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboards_with_filter(mock_jira: MagicMock) -> None:
+    """Test that get_dashboards works with filter and pagination."""
+    client = MagicMock()
+    client.get_dashboards.return_value = {"dashboards": []}
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_dashboards(filter="test", start=10, limit=20)
+
+    client.get_dashboards.assert_called_once_with(filter="test", start=10, limit=20)
+    assert result == {"dashboards": []}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboards_returns_empty_dict_when_none(mock_jira: MagicMock) -> None:
+    """Test that get_dashboards returns empty dict when client returns None."""
+    client = MagicMock()
+    client.get_dashboards.return_value = None
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_dashboards()
+
+    assert result == {}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_dashboards_maps_error(mock_jira: MagicMock) -> None:
+    """Test that get_dashboards maps authentication errors."""
+    client = MagicMock()
+    client.get_dashboards.side_effect = Exception("401 unauthorized")
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    with pytest.raises(JiraAuthError):
+        adapter.get_dashboards()
+

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

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from vds_jira_orchestrator.adapter import JiraAdapter
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_issue_property_keys_calls_sdk(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    client.get_issue_property_keys.return_value = {"keys": [{"key": "custom"}]}
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    payload = adapter.get_issue_property_keys("NTTC-1")
+
+    client.get_issue_property_keys.assert_called_once_with("NTTC-1")
+    assert payload == {"keys": [{"key": "custom"}]}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_set_issue_property_calls_sdk(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    mock_jira.return_value = client
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    adapter.set_issue_property("NTTC-2", "custom.key", {"foo": "bar"})
+
+    client.set_issue_property.assert_called_once_with("NTTC-2", "custom.key", {"foo": "bar"})
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_issue_property_calls_sdk(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    client.get_issue_property.return_value = {"value": {"foo": "bar"}}
+    mock_jira.return_value = client
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    payload = adapter.get_issue_property("NTTC-3", "custom.key")
+
+    client.get_issue_property.assert_called_once_with("NTTC-3", "custom.key")
+    assert payload == {"value": {"foo": "bar"}}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_delete_issue_property_calls_sdk(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    mock_jira.return_value = client
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    adapter.delete_issue_property("NTTC-4", "custom.key")
+
+    client.delete_issue_property.assert_called_once_with("NTTC-4", "custom.key")
+

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from vds_jira_orchestrator.adapter import JiraAdapter
+from vds_jira_orchestrator.errors import JiraAdapterError
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_permissions_uses_official_get_permissions(mock_jira: Mock) -> None:
+    class Client:
+        def __init__(self) -> None:
+            self.get_permissions = Mock(return_value={"permissions": {}})
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.get_permissions(permissions=["BROWSE_PROJECTS", "ADMINISTER_PROJECTS"], project_key="NTTC")
+
+    client.get_permissions.assert_called_once_with(
+        permissions="BROWSE_PROJECTS,ADMINISTER_PROJECTS",
+        project_id=None,
+        project_key="NTTC",
+        issue_id=None,
+        issue_key=None,
+    )
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_permissions_raises_when_not_supported(mock_jira: Mock) -> None:
+    class Client:
+        pass
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    with pytest.raises(JiraAdapterError):
+        adapter.get_permissions(permissions=["BROWSE_PROJECTS"])

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from vds_jira_orchestrator.adapter import JiraAdapter, JiraAuthError
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_reindex_calls_client(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    client.reindex.return_value = {"taskId": 123}
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.reindex()
+
+    client.reindex.assert_called_once_with()
+    assert result == {"taskId": 123}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_reindex_status_maps_error(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    client.reindex_status.side_effect = Exception("401 unauthorized")
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    with pytest.raises(JiraAuthError):
+        adapter.reindex_status()
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_move_issues_to_backlog(mock_jira: MagicMock) -> None:
+    client = MagicMock()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.move_issues_to_backlog(["NTTC-1", "NTTC-2"])
+
+    client.move_issues_to_backlog.assert_called_once_with(["NTTC-1", "NTTC-2"])

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

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from vds_jira_orchestrator.adapter import JiraAdapter
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_issue_remote_links_returns_list(mock_jira: MagicMock) -> None:
+    """Ensure get_issue_remote_links proxies to SDK and normalises response."""
+    client = MagicMock()
+    client.get_issue_remote_links.return_value = [{"id": 1}, {"id": 2}]
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_issue_remote_links("NTTC-1")
+
+    client.get_issue_remote_links.assert_called_once_with("NTTC-1")
+    assert result == [{"id": 1}, {"id": 2}]
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_create_or_update_issue_remote_link_calls_sdk(mock_jira: MagicMock) -> None:
+    """Ensure create_or_update_issue_remote_link delegates to SDK."""
+    client = MagicMock()
+    client.create_or_update_issue_remote_links.return_value = {"created": True}
+    mock_jira.return_value = client
+    payload = {"object": {"url": "https://example.com"}}
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.create_or_update_issue_remote_link("NTTC-2", payload)
+
+    client.create_or_update_issue_remote_links.assert_called_once_with("NTTC-2", payload)
+    assert result == {"created": True}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_issue_remote_link_by_id_calls_sdk(mock_jira: MagicMock) -> None:
+    """Ensure get_issue_remote_link_by_id delegates to SDK."""
+    client = MagicMock()
+    client.get_issue_remote_link_by_id.return_value = {"id": 5}
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.get_issue_remote_link_by_id("NTTC-3", 5)
+
+    client.get_issue_remote_link_by_id.assert_called_once_with("NTTC-3", 5)
+    assert result == {"id": 5}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_update_issue_remote_link_by_id_calls_sdk(mock_jira: MagicMock) -> None:
+    """Ensure update_issue_remote_link_by_id delegates to SDK."""
+    client = MagicMock()
+    client.update_issue_remote_link_by_id.return_value = {"updated": True}
+    mock_jira.return_value = client
+    payload = {"object": {"url": "https://example.com/updated"}}
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.update_issue_remote_link_by_id("NTTC-4", "abc", payload)
+
+    client.update_issue_remote_link_by_id.assert_called_once_with("NTTC-4", "abc", payload)
+    assert result == {"updated": True}
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_delete_issue_remote_link_by_id_calls_sdk(mock_jira: MagicMock) -> None:
+    """Ensure delete_issue_remote_link_by_id delegates to SDK."""
+    client = MagicMock()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.delete_issue_remote_link_by_id("NTTC-5", 9)
+
+    client.delete_issue_remote_link_by_id.assert_called_once_with("NTTC-5", 9)
+

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

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from vds_jira_orchestrator.adapter import JiraAdapter
+from vds_jira_orchestrator.errors import JiraAdapterError
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_transition_issue_uses_issue_transition(mock_jira: Mock) -> None:
+    class Client:
+        def __init__(self) -> None:
+            self.get_issue_transitions = Mock(return_value=[{"id": 71, "name": "Cancelled"}])
+            self.issue_transition = Mock()
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.transition_issue("NTTC-1", "Cancelled")
+
+    client.get_issue_transitions.assert_called_once_with("NTTC-1")
+    client.issue_transition.assert_called_once_with("NTTC-1", "Cancelled")
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_transition_issue_falls_back_to_set_issue_status_by_transition_name(mock_jira: Mock) -> None:
+    class Client:
+        def __init__(self) -> None:
+            self.get_issue_transitions = Mock(return_value=[{"id": "11", "name": "Develop"}])
+            self.set_issue_status_by_transition_name = Mock()
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.transition_issue("NTTC-2", "Develop")
+
+    client.get_issue_transitions.assert_called_once_with("NTTC-2")
+    client.set_issue_status_by_transition_name.assert_called_once_with("NTTC-2", "Develop")
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_transition_issue_falls_back_to_set_issue_status_by_transition_id(mock_jira: Mock) -> None:
+    class Client:
+        def __init__(self) -> None:
+            self.get_issue_transitions = Mock(return_value=[{"id": 81, "name": "Pending"}])
+            self.set_issue_status_by_transition_id = Mock()
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.transition_issue("NTTC-3", "Pending")
+
+    client.get_issue_transitions.assert_called_once_with("NTTC-3")
+    client.set_issue_status_by_transition_id.assert_called_once_with("NTTC-3", 81)
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_issue_transitions_falls_back_to_full_payload(mock_jira: Mock) -> None:
+    class Client:
+        def __init__(self) -> None:
+            self.get_issue_transitions_full = Mock(
+                return_value={"transitions": [{"id": "41", "name": "Assign OS", "to": {"name": "Assign OS"}}]}
+            )
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    transitions = adapter.get_issue_transitions("NTTC-4")
+
+    assert transitions[0]["name"] == "Assign OS"
+    client.get_issue_transitions_full.assert_called_once_with("NTTC-4")
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_transition_issue_raises_when_transition_not_found(mock_jira: Mock) -> None:
+    class Client:
+        def __init__(self) -> None:
+            self.get_issue_transitions = Mock(return_value=[{"id": 71, "name": "Cancelled"}])
+
+    client = Client()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    with pytest.raises(JiraAdapterError):
+        adapter.transition_issue("NTTC-5", "Done")

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

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from vds_jira_orchestrator.adapter import JiraAdapter, JiraAdapterError
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_find_users_calls_client(mock_jira: MagicMock) -> None:
+    """Test that find_users calls the SDK client."""
+    client = MagicMock()
+    client.user_find_by_user_string.return_value = [
+        {"accountId": "123", "displayName": "Test User", "emailAddress": "test@example.com"}
+    ]
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    result = adapter.find_users(query="test@example.com")
+
+    client.user_find_by_user_string.assert_called_once_with(
+        query="test@example.com", start=0, limit=50, include_inactive_users=False
+    )
+    assert len(result) == 1
+    assert result[0]["accountId"] == "123"
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_find_users_with_pagination(mock_jira: MagicMock) -> None:
+    """Test that find_users passes pagination parameters."""
+    client = MagicMock()
+    client.user_find_by_user_string.return_value = []
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.find_users(query="test", start=10, limit=20, include_inactive=True)
+
+    client.user_find_by_user_string.assert_called_once_with(
+        query="test", start=10, limit=20, include_inactive_users=True
+    )
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_user_groups_cloud_mode(mock_jira: MagicMock) -> None:
+    """Test that get_user_groups works in Cloud mode."""
+    client = MagicMock()
+    client.get_user_groups.return_value = [{"name": "jira-users"}, {"name": "jira-administrators"}]
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://test.atlassian.net", username="user", password="pass")
+    result = adapter.get_user_groups("account-123")
+
+    client.get_user_groups.assert_called_once_with("account-123")
+    assert len(result) == 2
+    assert result[0]["name"] == "jira-users"
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_user_groups_server_mode_raises_error(mock_jira: MagicMock) -> None:
+    """Test that get_user_groups raises error in Server/DC mode."""
+    client = MagicMock()
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    with pytest.raises(JiraAdapterError, match="only available in Jira Cloud mode"):
+        adapter.get_user_groups("account-123")
+
+    client.get_user_groups.assert_not_called()
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_get_user_groups_explicit_cloud_mode(mock_jira: MagicMock) -> None:
+    """Test that get_user_groups works with explicit cloud=True."""
+    client = MagicMock()
+    client.get_user_groups.return_value = [{"name": "jira-users"}]
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass", cloud=True)
+    result = adapter.get_user_groups("account-123")
+
+    client.get_user_groups.assert_called_once_with("account-123")
+    assert len(result) == 1
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_deactivate_user_calls_client(mock_jira: MagicMock) -> None:
+    """Test that deactivate_user calls the SDK client."""
+    client = MagicMock()
+    client.user_deactivate.return_value = None
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+    adapter.deactivate_user("testuser")
+
+    client.user_deactivate.assert_called_once_with("testuser")
+
+
+@patch("vds_jira_orchestrator.adapter.Jira")
+def test_deactivate_user_handles_error(mock_jira: MagicMock) -> None:
+    """Test that deactivate_user handles errors correctly."""
+    client = MagicMock()
+    client.user_deactivate.side_effect = Exception("User not found")
+    mock_jira.return_value = client
+
+    adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+
+    with pytest.raises(JiraAdapterError):
+        adapter.deactivate_user("nonexistent")
+

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

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from vds_jira_orchestrator.adapter import JiraAdapter, JiraAdapterError
+
+
+@pytest.fixture
+def mock_adapter() -> JiraAdapter:
+    """Fixture for a JiraAdapter."""
+    with patch("vds_jira_orchestrator.adapter.Jira") as mock_jira_class:
+        mock_client = MagicMock()
+        mock_jira_class.return_value = mock_client
+        adapter = JiraAdapter(url="https://jira.example.com", username="user", password="pass")
+        adapter._client = mock_client
+        return adapter
+
+
+def test_get_project_versions_paginated_calls_client(mock_adapter: JiraAdapter) -> None:
+    """Test that get_project_versions_paginated calls the SDK client with correct parameters."""
+    mock_adapter._client.get_project_versions_paginated.return_value = {
+        "values": [{"id": "10000", "name": "1.0.0"}],
+        "startAt": 0,
+        "maxResults": 25,
+    }
+    result = mock_adapter.get_project_versions_paginated(project_key="TEST")
+    mock_adapter._client.get_project_versions_paginated.assert_called_once_with(
+        "TEST", start=None, limit=None, order_by=None, expand=None, query=None, status=None
+    )
+    assert "values" in result
+    assert len(result["values"]) == 1
+
+
+def test_get_project_versions_paginated_with_pagination(mock_adapter: JiraAdapter) -> None:
+    """Test get_project_versions_paginated with pagination parameters."""
+    mock_adapter._client.get_project_versions_paginated.return_value = {
+        "values": [{"id": "10001", "name": "1.0.1"}],
+        "startAt": 10,
+        "maxResults": 20,
+    }
+    result = mock_adapter.get_project_versions_paginated(project_key="TEST", start=10, limit=20)
+    mock_adapter._client.get_project_versions_paginated.assert_called_once_with(
+        "TEST", start=10, limit=20, order_by=None, expand=None, query=None, status=None
+    )
+    assert result["startAt"] == 10
+
+
+def test_get_project_versions_paginated_with_filtering(mock_adapter: JiraAdapter) -> None:
+    """Test get_project_versions_paginated with filtering and sorting."""
+    mock_adapter._client.get_project_versions_paginated.return_value = {
+        "values": [{"id": "10002", "name": "2.0.0"}],
+        "startAt": 0,
+        "maxResults": 25,
+    }
+    result = mock_adapter.get_project_versions_paginated(
+        project_key="TEST", order_by="name", query="2.0", status="released"
+    )
+    mock_adapter._client.get_project_versions_paginated.assert_called_once_with(
+        "TEST", start=None, limit=None, order_by="name", expand=None, query="2.0", status="released"
+    )
+    assert len(result["values"]) == 1
+
+
+def test_add_version_calls_client(mock_adapter: JiraAdapter) -> None:
+    """Test that add_version calls the SDK client."""
+    mock_adapter._client.add_version.return_value = {"id": "10000", "name": "1.0.0"}
+    result = mock_adapter.add_version(key="TEST", project_id="10000", version="1.0.0")
+    mock_adapter._client.add_version.assert_called_once_with("TEST", "10000", "1.0.0", is_archived=False, is_released=False)
+    assert result["name"] == "1.0.0"
+
+
+def test_add_version_with_flags(mock_adapter: JiraAdapter) -> None:
+    """Test add_version with archived and released flags."""
+    mock_adapter._client.add_version.return_value = {"id": "10001", "name": "1.0.1", "archived": True, "released": True}
+    result = mock_adapter.add_version(key="TEST", project_id="10000", version="1.0.1", is_archived=True, is_released=True)
+    mock_adapter._client.add_version.assert_called_once_with("TEST", "10000", "1.0.1", is_archived=True, is_released=True)
+    assert result["archived"] is True
+
+
+def test_add_version_handles_error(mock_adapter: JiraAdapter) -> None:
+    """Test that add_version handles errors from the SDK client."""
+    mock_adapter._client.add_version.side_effect = Exception("API Error")
+    with pytest.raises(JiraAdapterError, match="API Error"):
+        mock_adapter.add_version(key="TEST", project_id="10000", version="1.0.0")
+
+
+def test_update_version_calls_client(mock_adapter: JiraAdapter) -> None:
+    """Test that update_version calls the SDK client."""
+    mock_adapter._client.update_version.return_value = {"id": "10000", "name": "1.0.1"}
+    result = mock_adapter.update_version(version="10000", name="1.0.1")
+    mock_adapter._client.update_version.assert_called_once_with(
+        "10000", name="1.0.1", description=None, is_archived=None, is_released=None, start_date=None, release_date=None
+    )
+    assert result["name"] == "1.0.1"
+
+
+def test_update_version_partial_update(mock_adapter: JiraAdapter) -> None:
+    """Test update_version with partial updates."""
+    mock_adapter._client.update_version.return_value = {
+        "id": "10000",
+        "name": "1.0.0",
+        "description": "Updated description",
+        "archived": True,
+    }
+    result = mock_adapter.update_version(version="10000", description="Updated description", is_archived=True)
+    mock_adapter._client.update_version.assert_called_once_with(
+        "10000", name=None, description="Updated description", is_archived=True, is_released=None, start_date=None, release_date=None
+    )
+    assert result["description"] == "Updated description"
+
+
+def test_update_version_with_dates(mock_adapter: JiraAdapter) -> None:
+    """Test update_version with start and release dates."""
+    mock_adapter._client.update_version.return_value = {
+        "id": "10000",
+        "name": "1.0.0",
+        "startDate": "2025-01-01",
+        "releaseDate": "2025-01-31",
+    }
+    result = mock_adapter.update_version(version="10000", start_date="2025-01-01", release_date="2025-01-31")
+    mock_adapter._client.update_version.assert_called_once_with(
+        "10000", name=None, description=None, is_archived=None, is_released=None, start_date="2025-01-01", release_date="2025-01-31"
+    )
+    assert result["startDate"] == "2025-01-01"
+
+
+def test_update_version_handles_error(mock_adapter: JiraAdapter) -> None:
+    """Test that update_version handles errors from the SDK client."""
+    mock_adapter._client.update_version.side_effect = Exception("API Error")
+    with pytest.raises(JiraAdapterError, match="API Error"):
+        mock_adapter.update_version(version="10000", name="1.0.1")
+