python-jira-plus 2.0.7__tar.gz → 2.0.8__tar.gz

{python_jira_plus-2.0.7/python_jira_plus.egg-info → python_jira_plus-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jira-plus
-Version: 2.0.7
+Version: 2.0.8
 Summary: Enhanced Python client for JIRA with better error handling, pagination, and metadata validation.
 Author: Avi Zaguri
 License: MIT
@@ -17,14 +17,16 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: custom-python-logger>=2.0.10
-Requires-Dist: dotenv>=0.9.9
+Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: jira>=3.10.5
-Requires-Dist: pre-commit>=4.5.0
-Requires-Dist: pytest>=9.0.1
+Requires-Dist: packaging>=26.2
 Requires-Dist: requests>=2.32.5
 Requires-Dist: retrying>=1.4.2
-Requires-Dist: setuptools>=80.9.0
-Requires-Dist: wheel>=0.45.1
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.5.0; extra == "dev"
+Requires-Dist: pytest>=9.0.1; extra == "dev"
+Requires-Dist: setuptools>=80.9.0; extra == "dev"
+Requires-Dist: wheel>=0.45.1; extra == "dev"
 Dynamic: license-file
 
 ![PyPI version](https://img.shields.io/pypi/v/python-jira-plus)
@@ -59,7 +61,7 @@ pip install python-jira-plus
 ---
 
 ## Requirements
-- Python 3.9+
+- Python 3.12+
 - `jira` package
 - `retrying` package
 - `custom-python-logger` package

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/README.md

@@ -30,7 +30,7 @@ pip install python-jira-plus
 ---
 
 ## Requirements
-- Python 3.9+
+- Python 3.12+
 - `jira` package
 - `retrying` package
 - `custom-python-logger` package

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-jira-plus"
-version = "2.0.7"
+version = "2.0.8"
 description = "Enhanced Python client for JIRA with better error handling, pagination, and metadata validation."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -22,12 +22,17 @@ classifiers = [
 
 dependencies = [
     "custom-python-logger>=2.0.10",
-    "dotenv>=0.9.9",
+    "python-dotenv>=1.0.0",
     "jira>=3.10.5",
-    "pre-commit>=4.5.0",
-    "pytest>=9.0.1",
+    "packaging>=26.2",
     "requests>=2.32.5",
     "retrying>=1.4.2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pre-commit>=4.5.0",
+    "pytest>=9.0.1",
     "setuptools>=80.9.0",
     "wheel>=0.45.1",
 ]

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/python_jira_plus/__init__.py

@@ -8,7 +8,7 @@ pagination, metadata validation, and more.
 from dotenv import load_dotenv
 
 from python_jira_plus.describe_allowed_value import describe_allowed_value
-from python_jira_plus.jira_plus import JiraPlus, ServerType
+from python_jira_plus.jira_plus import JiraPlus, ServerType, UrlScheme
 
 load_dotenv()
 
@@ -27,4 +27,4 @@ BASIC_FIELDS = [
     "resolution",
     "parent",
 ]
-__all__ = ["JiraPlus", "ServerType", "BASIC_FIELDS"]
+__all__ = ["JiraPlus", "ServerType", "UrlScheme", "BASIC_FIELDS"]

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/python_jira_plus/describe_allowed_value.py

@@ -11,17 +11,17 @@ def describe_allowed_value(value: Any, allowed_values: set = None) -> bool:
 
 @describe_allowed_value.register
 def _(value: int, allowed_values: list = None) -> bool:
-    return value == allowed_values
+    return value in allowed_values
 
 
 @describe_allowed_value.register
 def _(value: float, allowed_values: list = None) -> bool:
-    return value == allowed_values
+    return value in allowed_values
 
 
 @describe_allowed_value.register
 def _(value: str, allowed_values: list = None) -> bool:
-    return value == allowed_values
+    return value in allowed_values
 
 
 @describe_allowed_value.register

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/python_jira_plus/jira_plus.py

@@ -53,10 +53,12 @@ class JiraPlus:
 
         self.jira_client = self.create_connection()
         self.check_client_connection()
+        self.server_version = self.get_server_version()
+        self.use_legacy_api = self._resolve_use_legacy_api()
 
     @retry(stop_max_attempt_number=3, wait_fixed=180000)
-    def create_connection(self, timeout: int = 580) -> JIRA | None:
-        if self.server_type == ServerType.ON_PREMISE and not self.sso:  # pylint: disable=W0160:
+    def create_connection(self, timeout: int = 580) -> JIRA:
+        if self.server_type == ServerType.ON_PREMISE and not self.sso:
             jira_client = JIRA(
                 token_auth=self.jira_token, options={"server": self.server, "verify": self.verify_ssl}, timeout=timeout
             )
@@ -142,12 +144,16 @@ class JiraPlus:
         all_issues = []
         retries = 0
         page = None
-        while True:  # pylint: disable=W0149
+        while True:
             try:
+                next_token = None
+                if page is not None:
+                    next_token = page.get('nextPageToken') if json_result else page.nextPageToken
+
                 self.logger.debug(f"Fetching issues from startAt={len(all_issues)}")
                 page = self.jira_client.enhanced_search_issues(
                     jql_str=query,
-                    nextPageToken=page['nextPageToken'] if page else None,
+                    nextPageToken=next_token,
                     maxResults=max_results,
                     fields=specific_fields,
                     json_result=json_result,
@@ -156,7 +162,8 @@ class JiraPlus:
                     break
 
                 all_issues += page["issues"] if json_result else page
-                if page['isLast']:
+                is_last = page['isLast'] if json_result else page.isLast
+                if is_last:
                     break
                 retries = 0  # reset on success
             except JIRAError as err:
@@ -268,21 +275,16 @@ class JiraPlus:
     def get_server_version(self) -> tuple[int, ...]:
         return tuple(self.jira_client.server_info()["versionNumbers"])
 
-    def check_server_createmeta_compatibility(self) -> bool:
-        server_version = self.get_server_version()
-        if (
-                self.server_type == ServerType.ON_PREMISE and
-                Version(".".join(str(x) for x in server_version)) > Version("9.0.0")
-        ):
-            self.logger.warning(
-                f"JIRA server version {server_version} is not fully compatible with createmeta-based field validation. "
-                "Some features may not work as expected."
-            )
-            return False
+    def _resolve_use_legacy_api(self) -> bool:
+        if self.server_type == ServerType.ON_PREMISE:
+            use_legacy = Version(".".join(str(x) for x in self.server_version)) < Version("9.0.0")
+            self.logger.debug(f"Using {'legacy createmeta' if use_legacy else 'project_issue_types'} API (ON_PREMISE {self.server_version})")
+            return use_legacy
+        self.logger.debug("Using legacy createmeta API (Cloud)")
         return True
 
     def get_project_fields_metadata(self, project_key: str, issue_type: str) -> dict:
-        if self.check_server_createmeta_compatibility():
+        if self.use_legacy_api:
             _, issue_meta = self._fetch_metadata(project_key=project_key, issue_type=issue_type)
             return issue_meta["fields"]
         _project_issue_types = self.jira_client.project_issue_types(project_key)
@@ -291,7 +293,7 @@ class JiraPlus:
         return {f.fieldId: f.raw for f in field_list}
 
     def validate_fields(  # pylint: disable=R1260
-        self, project_key: str, issue_type: str, fields: dict | None = None
+        self, project_key: str, issue_type: str, fields: dict
     ) -> None:
         fields_metadata = self.get_project_fields_metadata(project_key=project_key, issue_type=issue_type)
         for custom_field, value in fields.items():
@@ -370,7 +372,7 @@ class JiraPlus:
 
     def delete_issue(self, issue_key: str) -> bool:
         try:
-            issue = self.get_issue_by_key(key=issue_key)
+            issue = self.get_issue_by_key(key=issue_key, json_result=False)
             issue.delete()
             self.logger.info(f"Issue {issue_key} deleted successfully.")
             return True
@@ -455,10 +457,13 @@ class JiraPlus:
             return False
 
     def get_account_data(self, user_mail: str) -> list[dict]:
-        jira_rst_url = (
-            f"https://{self.jira_username}:{self.jira_token}@{self.base_url}/rest/api/{3}/user/search?query={user_mail}"
+        response = requests.get(
+            f"{self.server}/rest/api/3/user/search",
+            params={"query": user_mail},
+            auth=(self.jira_username, self.jira_token),
+            timeout=30,
         )
-        response = requests.get(jira_rst_url)
+        response.raise_for_status()
         return response.json()
 
     def get_account_id(self, user_mail: str) -> str:

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8/python_jira_plus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jira-plus
-Version: 2.0.7
+Version: 2.0.8
 Summary: Enhanced Python client for JIRA with better error handling, pagination, and metadata validation.
 Author: Avi Zaguri
 License: MIT
@@ -17,14 +17,16 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: custom-python-logger>=2.0.10
-Requires-Dist: dotenv>=0.9.9
+Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: jira>=3.10.5
-Requires-Dist: pre-commit>=4.5.0
-Requires-Dist: pytest>=9.0.1
+Requires-Dist: packaging>=26.2
 Requires-Dist: requests>=2.32.5
 Requires-Dist: retrying>=1.4.2
-Requires-Dist: setuptools>=80.9.0
-Requires-Dist: wheel>=0.45.1
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.5.0; extra == "dev"
+Requires-Dist: pytest>=9.0.1; extra == "dev"
+Requires-Dist: setuptools>=80.9.0; extra == "dev"
+Requires-Dist: wheel>=0.45.1; extra == "dev"
 Dynamic: license-file
 
 ![PyPI version](https://img.shields.io/pypi/v/python-jira-plus)
@@ -59,7 +61,7 @@ pip install python-jira-plus
 ---
 
 ## Requirements
-- Python 3.9+
+- Python 3.12+
 - `jira` package
 - `retrying` package
 - `custom-python-logger` package

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/python_jira_plus.egg-info/SOURCES.txt

@@ -9,4 +9,7 @@ python_jira_plus.egg-info/PKG-INFO
 python_jira_plus.egg-info/SOURCES.txt
 python_jira_plus.egg-info/dependency_links.txt
 python_jira_plus.egg-info/requires.txt
-python_jira_plus.egg-info/top_level.txt
+python_jira_plus.egg-info/top_level.txt
+tests/test_describe_allowed_value.py
+tests/test_jira_cloud_integration.py
+tests/test_jira_plus.py

{python_jira_plus-2.0.7 → python_jira_plus-2.0.8}/python_jira_plus.egg-info/requires.txt

@@ -1,9 +1,12 @@
 custom-python-logger>=2.0.10
-dotenv>=0.9.9
+python-dotenv>=1.0.0
 jira>=3.10.5
-pre-commit>=4.5.0
-pytest>=9.0.1
+packaging>=26.2
 requests>=2.32.5
 retrying>=1.4.2
+
+[dev]
+pre-commit>=4.5.0
+pytest>=9.0.1
 setuptools>=80.9.0
 wheel>=0.45.1

python_jira_plus-2.0.8/tests/test_describe_allowed_value.py

@@ -0,0 +1,77 @@
+import pytest
+
+from python_jira_plus.describe_allowed_value import describe_allowed_value
+
+
+class TestDescribeAllowedValueStr:
+    def test_str_in_allowed_set_returns_true(self) -> None:
+        assert describe_allowed_value("High", allowed_values={"High", "Medium", "Low"}), \
+            "Expected True for 'High' in allowed set"
+
+    def test_str_not_in_allowed_set_returns_false(self) -> None:
+        assert not describe_allowed_value("Critical", allowed_values={"High", "Medium", "Low"}), \
+            "Expected False for 'Critical' not in allowed set"
+
+
+class TestDescribeAllowedValueInt:
+    def test_int_in_allowed_set_returns_true(self) -> None:
+        assert describe_allowed_value(1, allowed_values={1, 2, 3}), \
+            "Expected True for 1 in allowed set"
+
+    def test_int_not_in_allowed_set_returns_false(self) -> None:
+        assert not describe_allowed_value(9, allowed_values={1, 2, 3}), \
+            "Expected False for 9 not in allowed set"
+
+
+class TestDescribeAllowedValueFloat:
+    def test_float_in_allowed_set_returns_true(self) -> None:
+        assert describe_allowed_value(1.5, allowed_values={1.5, 2.5}), \
+            "Expected True for 1.5 in allowed set"
+
+    def test_float_not_in_allowed_set_returns_false(self) -> None:
+        assert not describe_allowed_value(9.9, allowed_values={1.5, 2.5}), \
+            "Expected False for 9.9 not in allowed set"
+
+
+class TestDescribeAllowedValueList:
+    def test_list_of_strings_with_match_returns_true(self) -> None:
+        assert describe_allowed_value(["High", "Unknown"], allowed_values={"High", "Medium"}), \
+            "Expected True when at least one item matches"
+
+    def test_list_of_strings_no_match_returns_false(self) -> None:
+        assert not describe_allowed_value(["Critical", "Unknown"], allowed_values={"High", "Medium"}), \
+            "Expected False when no items match"
+
+    def test_list_of_dicts_with_match_returns_true(self) -> None:
+        assert describe_allowed_value([{"name": "High"}], allowed_values={"High", "Medium"}), \
+            "Expected True when dict value matches"
+
+    def test_list_of_dicts_no_match_returns_false(self) -> None:
+        assert not describe_allowed_value([{"name": "Critical"}], allowed_values={"High", "Medium"}), \
+            "Expected False when dict value doesn't match"
+
+
+class TestDescribeAllowedValueSet:
+    def test_set_with_match_returns_true(self) -> None:
+        assert describe_allowed_value({"High", "Unknown"}, allowed_values={"High", "Medium"}), \
+            "Expected True when set contains a match"
+
+    def test_set_no_match_returns_false(self) -> None:
+        assert not describe_allowed_value({"Critical"}, allowed_values={"High", "Medium"}), \
+            "Expected False when set has no match"
+
+
+class TestDescribeAllowedValueDict:
+    def test_dict_value_in_allowed_set_returns_true(self) -> None:
+        assert describe_allowed_value({"name": "High"}, allowed_values={"High", "Medium"}), \
+            "Expected True when dict value matches"
+
+    def test_dict_value_not_in_allowed_set_returns_false(self) -> None:
+        assert not describe_allowed_value({"name": "Critical"}, allowed_values={"High", "Medium"}), \
+            "Expected False when dict value doesn't match"
+
+
+class TestDescribeAllowedValueUnknownType:
+    def test_unknown_type_raises_not_implemented_error(self) -> None:
+        with pytest.raises(NotImplementedError):
+            describe_allowed_value(object(), allowed_values={"High"})

python_jira_plus-2.0.8/tests/test_jira_cloud_integration.py

@@ -0,0 +1,150 @@
+"""
+Integration tests against a real Jira Cloud instance.
+
+Required env vars:
+    JIRA_USER_NAME      your Jira email
+    JIRA_TOKEN          your Jira API token
+    JIRA_BASE_URL       e.g. your-instance.atlassian.net
+
+Optional env vars (fall back to defaults if not set):
+    JIRA_TEST_PROJECT       project key to query  (default: SUP)
+    JIRA_TEST_ISSUE_TYPE    issue type to query   (default: [System] Service request)
+    JIRA_TEST_ISSUE_KEY     a known issue key     (default: SUP-1)
+    JIRA_TEST_FIELD         field for allowed values check (default: Priority)
+
+Run only integration tests:
+    uv run pytest -m integration -v
+"""
+
+import os
+
+import pytest
+
+from python_jira_plus import BASIC_FIELDS
+from python_jira_plus.jira_plus import JiraPlus
+
+pytestmark = pytest.mark.integration
+
+_REQUIRED_ENV = ("JIRA_USER_NAME", "JIRA_TOKEN", "JIRA_BASE_URL")
+
+
+def _missing_env() -> list[str]:
+    return [var for var in _REQUIRED_ENV if not os.getenv(var)]
+
+
+@pytest.fixture(scope="module")
+def jira() -> JiraPlus:
+    missing = _missing_env()
+    if missing:
+        pytest.skip(f"Missing required env vars: {', '.join(missing)}")
+    return JiraPlus()
+
+
+@pytest.fixture(scope="module")
+def project_key() -> str:
+    return os.getenv("JIRA_TEST_PROJECT", "SUP")
+
+
+@pytest.fixture(scope="module")
+def issue_type() -> str:
+    return os.getenv("JIRA_TEST_ISSUE_TYPE", "[System] Service request")
+
+
+@pytest.fixture(scope="module")
+def issue_key() -> str:
+    return os.getenv("JIRA_TEST_ISSUE_KEY", "SUP-1")
+
+
+@pytest.fixture(scope="module")
+def test_field() -> str:
+    return os.getenv("JIRA_TEST_FIELD", "Priority")
+
+
+class TestConnection:
+    def test_client_is_connected(self, jira: JiraPlus) -> None:
+        result = jira.check_client_connection()
+        assert result is True, "Expected active connection to Jira Cloud"
+
+    def test_server_version_is_tuple(self, jira: JiraPlus) -> None:
+        assert isinstance(jira.server_version, tuple), \
+            f"Expected tuple, got {type(jira.server_version)}"
+        assert len(jira.server_version) > 0, "Expected non-empty version tuple"
+
+    def test_cloud_uses_legacy_api(self, jira: JiraPlus) -> None:
+        assert jira.use_legacy_api is True, \
+            "Cloud uses legacy createmeta API — project_issue_types is not supported for Cloud by the jira library"
+
+
+class TestGetObjectsByQuery:
+    def test_returns_list_of_issues(self, jira: JiraPlus, project_key: str, issue_type: str) -> None:
+        query = f'project = "{project_key}" AND issuetype = "{issue_type}"'
+        result = jira.get_objects_by_query(
+            query=query,
+            specific_fields=BASIC_FIELDS,
+            max_results=10,
+            json_result=True,
+        )
+        assert isinstance(result, list), f"Expected list, got {type(result)}"
+
+    def test_returned_issues_have_basic_fields(self, jira: JiraPlus, project_key: str, issue_type: str) -> None:
+        query = f'project = "{project_key}" AND issuetype = "{issue_type}"'
+        result = jira.get_objects_by_query(
+            query=query,
+            specific_fields=BASIC_FIELDS,
+            max_results=5,
+            json_result=True,
+        )
+        if not result:
+            pytest.skip(f"No issues found in project '{project_key}' with issue type '{issue_type}'")
+
+        issue = result[0]
+        assert "key" in issue, f"Expected 'key' in issue, got keys: {list(issue.keys())}"
+        assert "fields" in issue, f"Expected 'fields' in issue, got keys: {list(issue.keys())}"
+
+    def test_invalid_jql_raises(self, jira: JiraPlus) -> None:
+        from jira import JIRAError
+        with pytest.raises(JIRAError):
+            jira.get_objects_by_query(query="INVALID JQL !!!", max_results=1)
+
+
+class TestGetIssueByKey:
+    def test_json_result_true_returns_dict(self, jira: JiraPlus, issue_key: str) -> None:
+        result = jira.get_issue_by_key(key=issue_key, json_result=True)
+        if result is None:
+            pytest.skip(f"Issue '{issue_key}' not found — set JIRA_TEST_ISSUE_KEY to a valid key")
+        assert isinstance(result, dict), f"Expected dict, got {type(result)}"
+        assert "key" in result, f"Expected 'key' in result"
+
+    def test_json_result_false_returns_issue_object(self, jira: JiraPlus, issue_key: str) -> None:
+        from jira import Issue
+        result = jira.get_issue_by_key(key=issue_key, json_result=False)
+        if result is None:
+            pytest.skip(f"Issue '{issue_key}' not found — set JIRA_TEST_ISSUE_KEY to a valid key")
+        assert isinstance(result, Issue), f"Expected Issue object, got {type(result)}"
+
+    def test_nonexistent_issue_returns_none(self, jira: JiraPlus) -> None:
+        result = jira.get_issue_by_key(key="NONEXISTENT-99999999")
+        assert result is None, "Expected None for a nonexistent issue key"
+
+
+class TestGetAllowedValues:
+    def test_returns_list_for_valid_field(
+        self, jira: JiraPlus, project_key: str, issue_type: str, test_field: str
+    ) -> None:
+        result = jira.get_allowed_values(
+            project_key=project_key,
+            issue_type=issue_type,
+            field_id_or_name=test_field,
+        )
+        assert result is None or isinstance(result, list), \
+            f"Expected list or None, got {type(result)}"
+
+    def test_invalid_field_raises_value_error(
+        self, jira: JiraPlus, project_key: str, issue_type: str
+    ) -> None:
+        with pytest.raises(ValueError, match="not found"):
+            jira.get_allowed_values(
+                project_key=project_key,
+                issue_type=issue_type,
+                field_id_or_name="nonexistent_field_xyz_999",
+            )

python_jira_plus-2.0.8/tests/test_jira_plus.py

@@ -0,0 +1,227 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from jira import JIRAError
+
+from python_jira_plus.jira_plus import JiraPlus
+
+
+def _make_issue_type_mock(name: str, issue_id: str) -> MagicMock:
+    mock = MagicMock()
+    mock.name = name
+    mock.id = issue_id
+    return mock
+
+
+def _make_field_mock(field_id: str, raw: dict) -> MagicMock:
+    mock = MagicMock()
+    mock.fieldId = field_id
+    mock.raw = raw
+    return mock
+
+
+class TestResolveLegacyApi:
+    def test_cloud_uses_legacy_api(self, jira_plus_cloud: JiraPlus) -> None:
+        assert jira_plus_cloud.use_legacy_api is True, \
+            "Cloud uses legacy createmeta API — project_issue_types is not supported for Cloud by the jira library"
+
+    def test_on_premise_below_9_uses_legacy_api(self, jira_plus_on_premise_legacy: JiraPlus) -> None:
+        assert jira_plus_on_premise_legacy.use_legacy_api is True, \
+            "ON_PREMISE < 9.0 should use legacy createmeta API"
+
+    def test_on_premise_9_and_above_uses_new_api(self, jira_plus_on_premise_new: JiraPlus) -> None:
+        assert jira_plus_on_premise_new.use_legacy_api is False, \
+            "ON_PREMISE >= 9.0 should use project_issue_types API"
+
+
+class TestGetIssueByKey:
+    def test_json_result_true_returns_raw_dict(self, jira_plus_cloud: JiraPlus) -> None:
+        mock_issue = MagicMock()
+        mock_issue.raw = {"key": "PROJ-1", "fields": {}}
+        jira_plus_cloud.jira_client.issue.return_value = mock_issue
+
+        result = jira_plus_cloud.get_issue_by_key(key="PROJ-1", json_result=True)
+
+        assert result == {"key": "PROJ-1", "fields": {}}, f"Expected raw dict, got {result}"
+
+    def test_json_result_false_returns_issue_object(self, jira_plus_cloud: JiraPlus) -> None:
+        mock_issue = MagicMock()
+        jira_plus_cloud.jira_client.issue.return_value = mock_issue
+
+        result = jira_plus_cloud.get_issue_by_key(key="PROJ-1", json_result=False)
+
+        assert result is mock_issue, "Expected Issue object, not raw dict"
+
+    def test_jira_error_returns_none(self, jira_plus_cloud: JiraPlus) -> None:
+        jira_plus_cloud.jira_client.issue.side_effect = JIRAError("Not found", status_code=404)
+
+        result = jira_plus_cloud.get_issue_by_key(key="PROJ-999")
+
+        assert result is None, "Expected None on JIRAError"
+
+    def test_unexpected_error_returns_none(self, jira_plus_cloud: JiraPlus) -> None:
+        jira_plus_cloud.jira_client.issue.side_effect = RuntimeError("network failure")
+
+        result = jira_plus_cloud.get_issue_by_key(key="PROJ-1")
+
+        assert result is None, "Expected None on unexpected error"
+
+
+class TestDeleteIssue:
+    def test_success_returns_true_and_calls_delete(self, jira_plus_cloud: JiraPlus) -> None:
+        mock_issue = MagicMock()
+        jira_plus_cloud.jira_client.issue.return_value = mock_issue
+
+        result = jira_plus_cloud.delete_issue("PROJ-1")
+
+        assert result is True, "Expected True on successful delete"
+        mock_issue.delete.assert_called_once()
+
+    def test_jira_error_returns_false(self, jira_plus_cloud: JiraPlus) -> None:
+        jira_plus_cloud.jira_client.issue.side_effect = JIRAError("Forbidden", status_code=403)
+
+        result = jira_plus_cloud.delete_issue("PROJ-1")
+
+        assert result is False, "Expected False on JIRAError"
+
+    def test_unexpected_error_returns_false(self, jira_plus_cloud: JiraPlus) -> None:
+        jira_plus_cloud.jira_client.issue.side_effect = RuntimeError("network failure")
+
+        result = jira_plus_cloud.delete_issue("PROJ-1")
+
+        assert result is False, "Expected False on unexpected error"
+
+
+class TestValidateFields:
+    def _setup_createmeta(self, jira_plus: JiraPlus, fields: dict) -> None:
+        jira_plus.jira_client.createmeta.return_value = {
+            "projects": [{
+                "key": "PROJ",
+                "issuetypes": [{"name": "Story", "fields": fields}],
+            }]
+        }
+
+    def test_valid_string_field_raises_no_error(self, jira_plus_cloud: JiraPlus) -> None:
+        self._setup_createmeta(jira_plus_cloud, {
+            "summary": {"schema": {"type": "string"}, "name": "Summary"},
+        })
+
+        jira_plus_cloud.validate_fields("PROJ", "Story", {"summary": "Hello"})
+
+    def test_field_not_in_metadata_raises_value_error(self, jira_plus_cloud: JiraPlus) -> None:
+        self._setup_createmeta(jira_plus_cloud, {
+            "summary": {"schema": {"type": "string"}, "name": "Summary"},
+        })
+
+        with pytest.raises(ValueError, match="Invalid field"):
+            jira_plus_cloud.validate_fields("PROJ", "Story", {"nonexistent_field": "value"})
+
+    def test_wrong_type_for_string_field_raises_value_error(self, jira_plus_cloud: JiraPlus) -> None:
+        self._setup_createmeta(jira_plus_cloud, {
+            "summary": {"schema": {"type": "string"}, "name": "Summary"},
+        })
+
+        with pytest.raises(ValueError, match="must be a string"):
+            jira_plus_cloud.validate_fields("PROJ", "Story", {"summary": 123})
+
+    def test_wrong_type_for_number_field_raises_value_error(self, jira_plus_cloud: JiraPlus) -> None:
+        self._setup_createmeta(jira_plus_cloud, {
+            "story_points": {"schema": {"type": "number"}, "name": "Story Points"},
+        })
+
+        with pytest.raises(ValueError, match="must be a number"):
+            jira_plus_cloud.validate_fields("PROJ", "Story", {"story_points": "five"})
+
+    def test_invalid_allowed_value_raises_value_error(self, jira_plus_cloud: JiraPlus) -> None:
+        self._setup_createmeta(jira_plus_cloud, {
+            "priority": {
+                "schema": {"type": "string"},
+                "name": "Priority",
+                "allowedValues": [{"name": "High"}, {"name": "Low"}],
+            },
+        })
+
+        with pytest.raises(ValueError, match="Invalid value"):
+            jira_plus_cloud.validate_fields("PROJ", "Story", {"priority": "Critical"})
+
+
+class TestPaginateQueryNew:
+    def test_single_page_returns_issues(self, jira_plus_cloud: JiraPlus) -> None:
+        issues = [{"key": "PROJ-1"}, {"key": "PROJ-2"}]
+        jira_plus_cloud.jira_client.enhanced_search_issues.return_value = {
+            "issues": issues,
+            "isLast": True,
+        }
+
+        result = jira_plus_cloud._paginate_query_new(
+            query="project = PROJ",
+            max_results=50,
+            specific_fields="*all",
+            jira_err_limit=3,
+            json_result=True,
+        )
+
+        assert result == issues, f"Expected {issues}, got {result}"
+
+    def test_multiple_pages_accumulates_all_issues(self, jira_plus_cloud: JiraPlus) -> None:
+        page1 = {"issues": [{"key": "PROJ-1"}], "isLast": False, "nextPageToken": "token-2"}
+        page2 = {"issues": [{"key": "PROJ-2"}], "isLast": True}
+        jira_plus_cloud.jira_client.enhanced_search_issues.side_effect = [page1, page2]
+
+        result = jira_plus_cloud._paginate_query_new(
+            query="project = PROJ",
+            max_results=50,
+            specific_fields="*all",
+            jira_err_limit=3,
+            json_result=True,
+        )
+
+        assert result == [{"key": "PROJ-1"}, {"key": "PROJ-2"}], \
+            f"Expected both pages merged, got {result}"
+
+    def test_empty_page_returns_empty_list(self, jira_plus_cloud: JiraPlus) -> None:
+        jira_plus_cloud.jira_client.enhanced_search_issues.return_value = {}
+
+        result = jira_plus_cloud._paginate_query_new(
+            query="project = PROJ",
+            max_results=50,
+            specific_fields="*all",
+            jira_err_limit=3,
+            json_result=True,
+        )
+
+        assert result == [], f"Expected empty list, got {result}"
+
+    def test_bad_request_raises_jira_error(self, jira_plus_cloud: JiraPlus) -> None:
+        jira_plus_cloud.jira_client.enhanced_search_issues.side_effect = JIRAError(
+            "Bad JQL", status_code=400
+        )
+
+        with pytest.raises(JIRAError):
+            jira_plus_cloud._paginate_query_new(
+                query="invalid JQL !!!",
+                max_results=50,
+                specific_fields="*all",
+                jira_err_limit=3,
+                json_result=True,
+            )
+
+
+class TestGetAccountData:
+    def test_success_returns_user_list(self, jira_plus_cloud: JiraPlus) -> None:
+        mock_response = MagicMock()
+        mock_response.json.return_value = [{"accountId": "abc123", "displayName": "Test User"}]
+
+        with patch("python_jira_plus.jira_plus.requests.get", return_value=mock_response):
+            result = jira_plus_cloud.get_account_data("test@test.com")
+
+        assert result[0]["accountId"] == "abc123", f"Expected 'abc123', got {result[0]['accountId']}"
+        mock_response.raise_for_status.assert_called_once()
+
+    def test_http_error_raises(self, jira_plus_cloud: JiraPlus) -> None:
+        mock_response = MagicMock()
+        mock_response.raise_for_status.side_effect = Exception("401 Unauthorized")
+
+        with patch("python_jira_plus.jira_plus.requests.get", return_value=mock_response):
+            with pytest.raises(Exception, match="401"):
+                jira_plus_cloud.get_account_data("bad@test.com")