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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jira-plus
-Version: 2.0.7
+Version: 3.0.0
 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-3.0.0}/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-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-jira-plus"
-version = "2.0.7"
+version = "3.0.0"
 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-3.0.0}/python_jira_plus/__init__.py

@@ -8,7 +8,9 @@ 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_base import JiraBase, UrlScheme
+from python_jira_plus.jira_cloud import JiraCloud
+from python_jira_plus.jira_on_premise import JiraOnPremise
 
 load_dotenv()
 
@@ -27,4 +29,4 @@ BASIC_FIELDS = [
     "resolution",
     "parent",
 ]
-__all__ = ["JiraPlus", "ServerType", "BASIC_FIELDS"]
+__all__ = ["JiraBase", "JiraCloud", "JiraOnPremise", "UrlScheme", "BASIC_FIELDS"]

{python_jira_plus-2.0.7 → python_jira_plus-3.0.0}/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/jira_plus.py → python_jira_plus-3.0.0/python_jira_plus/jira_base.py

@@ -1,18 +1,16 @@
-# jira_plus.py
+# jira_base.py
 
 import json
 import logging
 import os
-import time
+from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Any
 
-import requests
 from custom_python_logger import get_logger
 from jira import JIRA, Issue, JIRAError
 from jira.client import ResultList
-from retrying import retry
-from packaging.version import Version
+
 from python_jira_plus.describe_allowed_value import describe_allowed_value
 
 
@@ -21,21 +19,16 @@ class UrlScheme(Enum):
     HTTPS = "https"
 
 
-class ServerType(Enum):
-    CLOUD = "cloud"
-    ON_PREMISE = "on_premise"
-
+class JiraBase(ABC):
+    use_createmeta: bool
 
-class JiraPlus:
     def __init__(
         self,
         base_url: str | None = None,
-        server_type: ServerType = ServerType.CLOUD,
         urllib3_log_level: int = logging.WARNING,
         jira_username: str | None = None,
-        jira_token: str | None = None,  # Use API token (not PAT)
+        jira_token: str | None = None,
         verify_ssl: bool = True,
-        sso: bool = False,
         url_scheme: UrlScheme = UrlScheme.HTTPS,
     ) -> None:
         self.logger = get_logger(self.__class__.__name__)
@@ -45,33 +38,28 @@ class JiraPlus:
         self.jira_token = jira_token or os.getenv("JIRA_TOKEN")
         self.base_url = base_url or os.getenv("JIRA_BASE_URL")
         self.url_scheme = url_scheme.value
-
-        self.server_type = server_type
         self.server = f"{self.url_scheme}://{self.base_url}"
         self.verify_ssl = verify_ssl
-        self.sso = sso
 
         self.jira_client = self.create_connection()
         self.check_client_connection()
+        self.server_version = self.get_server_version()
 
-    @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:
-            jira_client = JIRA(
-                token_auth=self.jira_token, options={"server": self.server, "verify": self.verify_ssl}, timeout=timeout
-            )
-        else:
-            jira_client = JIRA(
-                basic_auth=(self.jira_username, self.jira_token),
-                options={"server": self.server, "verify": self.verify_ssl},
-                timeout=timeout,
-            )
+    @abstractmethod
+    def create_connection(self, timeout: int = 580) -> JIRA: ...
+
+    @abstractmethod
+    def _paginate(
+        self,
+        query: str,
+        max_results: int,
+        specific_fields: str | list[str],
+        jira_err_limit: int,
+        json_result: bool,
+    ) -> ResultList[Issue] | list: ...
 
-        if jira_client.projects():
-            self.logger.info("Jira Connection Successful")
-            return jira_client
-        self.logger.error("Jira Connection Failed")
-        raise JIRAError("Jira Connection Failed")
+    @abstractmethod
+    def _format_assignee(self, assignee: str) -> dict: ...
 
     def close_connection(self) -> None:
         try:
@@ -80,7 +68,6 @@ class JiraPlus:
             self.logger.exception(f"JIRAError \n{err}")
         except Exception as err:
             self.logger.exception(f"Exception \n{err}")
-
         self.check_client_connection()
 
     def check_client_connection(self) -> bool:
@@ -96,6 +83,9 @@ class JiraPlus:
             self.logger.exception(f"Exception \n{err}")
             return False
 
+    def get_server_version(self) -> tuple[int, ...]:
+        return tuple(self.jira_client.server_info()["versionNumbers"])
+
     def get_issue_by_key(
         self, key: str, specific_fields: str | list[str] = "*all", json_result: bool = True
     ) -> None | Issue | dict[str, Any]:
@@ -118,12 +108,8 @@ class JiraPlus:
         specific_fields: str | list[str] = "*all",
         jira_err_count: int = 3,
         json_result: bool = True,
-    ) -> ResultList[Issue] | dict | None:
-        if self.server_type == ServerType.ON_PREMISE:
-            _paginate_query_func = self._paginate_query
-        else:
-            _paginate_query_func = self._paginate_query_new
-        return _paginate_query_func(
+    ) -> ResultList[Issue] | list:
+        return self._paginate(
             query=query,
             max_results=max_results,
             specific_fields=specific_fields,
@@ -131,102 +117,26 @@ class JiraPlus:
             json_result=json_result,
         )
 
-    def _paginate_query_new(
-        self,
-        query: str,
-        max_results: int,
-        specific_fields: str | list[str],
-        jira_err_limit: int,
-        json_result: bool,
-    ) -> ResultList[Issue] | list:
-        all_issues = []
-        retries = 0
-        page = None
-        while True:  # pylint: disable=W0149
-            try:
-                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,
-                    maxResults=max_results,
-                    fields=specific_fields,
-                    json_result=json_result,
-                )
-                if not page:
-                    break
-
-                all_issues += page["issues"] if json_result else page
-                if page['isLast']:
-                    break
-                retries = 0  # reset on success
-            except JIRAError as err:
-                if err.status_code == 400:
-                    self.logger.error(f"Bad Request: {err.text}")
-                    raise JIRAError(f"Bad Request: {err.text}") from err
-                retries += 1
-                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
-                if retries >= jira_err_limit:
-                    self.logger.exception("Max retries exceeded.")
-                    return []
-                time.sleep(300 if retries == jira_err_limit - 1 else 90)
-        return all_issues
-
-    def _paginate_query(
-        self,
-        query: str,
-        max_results: int,
-        specific_fields: str | list[str],
-        jira_err_limit: int,
-        json_result: bool,
-    ) -> ResultList[Issue] | list:
-        start_at = 0
-        all_issues = []
-        retries = 0
-        while True:  # pylint: disable=W0149
-            try:
-                self.logger.debug(f"Fetching issues from startAt={start_at}")
-                page = self.jira_client.search_issues(
-                    jql_str=query,
-                    startAt=start_at,
-                    maxResults=max_results,
-                    fields=specific_fields,
-                    json_result=json_result,
-                )
-                if not page:
-                    break
-
-                all_issues += page["issues"] if json_result else page
-                if json_result:
-                    start_at += page["maxResults"]
-                else:
-                    start_at += page.maxResults
-                if start_at >= max_results:
-                    break
-                retries = 0  # reset on success
-            except JIRAError as err:
-                if err.status_code == 400:
-                    self.logger.error(f"Bad Request: {err.text}")
-                    raise JIRAError(f"Bad Request: {err.text}") from err
-                retries += 1
-                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
-                if retries >= jira_err_limit:
-                    self.logger.exception("Max retries exceeded.")
-                    return []
-                time.sleep(300 if retries == jira_err_limit - 1 else 90)
-        return all_issues
-
-    def _fetch_metadata(self, project_key: str, issue_type: str) -> tuple[dict, dict]:
+    def _fetch_via_createmeta(self, project_key: str, issue_type: str) -> dict:
         meta = self.jira_client.createmeta(
             projectKeys=project_key, issuetypeNames=issue_type, expand="projects.issuetypes.fields"
         )
-
         if not (project_meta := next((p for p in meta["projects"] if p["key"] == project_key), None)):
             raise ValueError(f"Project {project_key} not found in metadata")
-
         issue_meta = next((it for it in project_meta["issuetypes"] if it["name"].lower() == issue_type.lower()), None)
         if not issue_meta:
             raise ValueError(f"Issue type '{issue_type}' not found in project '{project_key}'")
-        return meta, issue_meta
+        return issue_meta["fields"]
+
+    def _fetch_via_issue_types_api(self, project_key: str, issue_type: str) -> dict:
+        issue_types = {t.name: t for t in self.jira_client.project_issue_types(project_key)}
+        field_list = self.jira_client.project_issue_fields(project_key, issue_types[issue_type].id)
+        return {f.fieldId: f.raw for f in field_list}
+
+    def get_project_fields_metadata(self, project_key: str, issue_type: str) -> dict:
+        if self.use_createmeta:
+            return self._fetch_via_createmeta(project_key=project_key, issue_type=issue_type)
+        return self._fetch_via_issue_types_api(project_key=project_key, issue_type=issue_type)
 
     def get_allowed_values(
         self,
@@ -234,28 +144,20 @@ class JiraPlus:
         issue_type: str,
         field_id_or_name: str,
     ) -> list | None:
-        """
-        Returns the allowed values for a specific field in a project + issue type context.
-        """
+        """Returns the allowed values for a specific field in a project + issue type context."""
         fields_metadata = self.get_project_fields_metadata(project_key=project_key, issue_type=issue_type)
-
-        # Try to find by ID or fallback to case-insensitive name
         if not (field := fields_metadata.get(field_id_or_name)):
-            # Try matching by name (case-insensitive)
             for _, fmeta in fields_metadata.items():
                 if fmeta["name"].lower() == field_id_or_name.lower():
                     field = fmeta
                     break
-
         if not field:
             raise ValueError(
                 f"Field '{field_id_or_name}' not found in project '{project_key}' with issue type '{issue_type}'"
             )
-
         if not (allowed := field.get("allowedValues")):
             self.logger.info(f"No allowed values found for field '{field_id_or_name}'")
             return None
-
         return allowed
 
     @staticmethod
@@ -265,41 +167,13 @@ class JiraPlus:
         allowed_values = allowed_names | allowed_keys
         return describe_allowed_value(value, allowed_values=allowed_values)
 
-    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
-        return True
-
-    def get_project_fields_metadata(self, project_key: str, issue_type: str) -> dict:
-        if self.check_server_createmeta_compatibility():
-            _, 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)
-        _issue_types = {t.name: t for t in _project_issue_types}
-        field_list = self.jira_client.project_issue_fields(project_key, _issue_types[issue_type].id)
-        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
-    ) -> None:
+    def validate_fields(self, project_key: str, issue_type: str, fields: dict) -> None:  # pylint: disable=R1260
         fields_metadata = self.get_project_fields_metadata(project_key=project_key, issue_type=issue_type)
         for custom_field, value in fields.items():
             if custom_field not in fields_metadata:
                 raise ValueError(
                     f'Invalid field(s) for project "{project_key}", issue type "{issue_type}": "{custom_field}"'
                 )
-
             if allowed_value := fields_metadata[custom_field].get("allowedValues"):
                 if not self._is_value_allowed(value=value, allowed_values=allowed_value):
                     raise ValueError(
@@ -307,7 +181,6 @@ class JiraPlus:
                         f"with issue type '{issue_type}'."
                         f"The allowed values are: {json.dumps(allowed_value, indent=4, sort_keys=True)}"
                     )
-
             field_type = fields_metadata[custom_field]["schema"]["type"]
             if field_type == "string" and not isinstance(value, str):
                 raise ValueError(f"Field '{custom_field}' must be a string")
@@ -321,7 +194,6 @@ class JiraPlus:
                 raise ValueError(f"Field '{custom_field}' must be an object")
             if field_type == "issuetype" and not isinstance(value, dict):
                 raise ValueError(f"Field '{custom_field}' must be an issue type")
-            # Add more field type checks as needed
 
     def create_issue(
         self,
@@ -332,21 +204,17 @@ class JiraPlus:
         assignee: str | None = None,
         custom_fields: dict | None = None,
     ) -> Issue | None:
-        issue_fields = {
+        issue_fields: dict[str, Any] = {
             "project": {"key": project_key},
             "issuetype": {"name": issue_type},
             "summary": summary,
             "description": description,
         }
         if assignee:
-            issue_fields["assignee"] = (
-                {"accountId": assignee} if self.server_type == ServerType.CLOUD else {"name": assignee}
-            )
-
+            issue_fields["assignee"] = self._format_assignee(assignee)
         if custom_fields:
             issue_fields = issue_fields | custom_fields
         self.validate_fields(project_key=project_key, issue_type=issue_type, fields=issue_fields)
-
         issue = self.jira_client.create_issue(fields=issue_fields)
         self.logger.info(f"Issue {issue.key} created successfully.")
         return issue
@@ -357,7 +225,6 @@ class JiraPlus:
             self.validate_fields(
                 project_key=issue.fields.project.key, issue_type=issue.fields.issuetype.name, fields=fields_to_update
             )
-
             issue.update(fields=fields_to_update)
             self.logger.info(f"Issue {issue.key} updated successfully.")
             return issue
@@ -370,7 +237,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
@@ -396,7 +263,6 @@ class JiraPlus:
         available_link_types = self._get_available_link_types()
         if link_type not in available_link_types:
             raise ValueError(f"Invalid link type '{link_type}'. Available link types: {available_link_types}")
-
         try:
             self.jira_client.create_issue_link(
                 type=link_type,
@@ -436,12 +302,10 @@ class JiraPlus:
                     f"\nAvailable transitions: {transition_names}"
                 )
                 return False
-
             transition_id = next((t["id"] for t in transitions if t["name"].lower() == transition_name.lower()), None)
             if not transition_id:
                 self.logger.error(f"Transition '{transition_name}' not found for issue {issue_key}")
                 return False
-
             self.jira_client.transition_issue(
                 issue=issue_key, transition=transition_id, fields=fields or {}, comment=comment or None
             )
@@ -453,18 +317,3 @@ class JiraPlus:
         except Exception as err:
             self.logger.exception(f"Unexpected error during transition of {issue_key}: {err}")
             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(jira_rst_url)
-        return response.json()
-
-    def get_account_id(self, user_mail: str) -> str:
-        data = self.get_account_data(user_mail=user_mail)
-        return data[0]["accountId"]
-
-    def get_account_display_name(self, user_display_name: str) -> str:
-        data = self.get_account_data(user_mail=user_display_name)
-        return data[0]["displayName"]

python_jira_plus-3.0.0/python_jira_plus/jira_cloud.py

@@ -0,0 +1,111 @@
+# jira_cloud.py
+
+import logging
+import time
+
+import requests
+from jira import JIRA, Issue, JIRAError
+from jira.client import ResultList
+from retrying import retry
+
+from python_jira_plus.jira_base import JiraBase, UrlScheme
+
+
+class JiraCloud(JiraBase):
+    use_createmeta = True
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        urllib3_log_level: int = logging.WARNING,
+        jira_username: str | None = None,
+        jira_token: str | None = None,
+        verify_ssl: bool = True,
+        url_scheme: UrlScheme = UrlScheme.HTTPS,
+    ) -> None:
+        super().__init__(
+            base_url=base_url,
+            urllib3_log_level=urllib3_log_level,
+            jira_username=jira_username,
+            jira_token=jira_token,
+            verify_ssl=verify_ssl,
+            url_scheme=url_scheme,
+        )
+
+    @retry(stop_max_attempt_number=3, wait_fixed=180000)
+    def create_connection(self, timeout: int = 580) -> JIRA:
+        jira_client = JIRA(
+            basic_auth=(self.jira_username, self.jira_token),
+            options={"server": self.server, "verify": self.verify_ssl},
+            timeout=timeout,
+        )
+        if jira_client.projects():
+            self.logger.info("Jira Connection Successful")
+            return jira_client
+        self.logger.error("Jira Connection Failed")
+        raise JIRAError("Jira Connection Failed")
+
+    def _format_assignee(self, assignee: str) -> dict:
+        return {"accountId": assignee}
+
+    def _paginate(
+        self,
+        query: str,
+        max_results: int,
+        specific_fields: str | list[str],
+        jira_err_limit: int,
+        json_result: bool,
+    ) -> ResultList[Issue] | list:
+        all_issues = []
+        retries = 0
+        page = None
+        while True:  # pylint: disable=while-used
+            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=next_token,
+                    maxResults=max_results,
+                    fields=specific_fields,
+                    json_result=json_result,
+                )
+                if not page:
+                    break
+
+                all_issues += page["issues"] if json_result else page
+                if page["isLast"] if json_result else page.isLast:
+                    break
+                retries = 0
+            except JIRAError as err:
+                if err.status_code == 400:
+                    self.logger.error(f"Bad Request: {err.text}")
+                    raise JIRAError(f"Bad Request: {err.text}") from err
+                retries += 1
+                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
+                if retries >= jira_err_limit:
+                    self.logger.exception("Max retries exceeded.")
+                    return []
+                time.sleep(300 if retries == jira_err_limit - 1 else 90)
+        return all_issues
+
+    def get_account_data(self, user_mail: str) -> list[dict]:
+        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.raise_for_status()
+        return response.json()
+
+    def get_account_id(self, user_mail: str) -> str:
+        data = self.get_account_data(user_mail=user_mail)
+        return data[0]["accountId"]
+
+    def get_account_display_name(self, user_display_name: str) -> str:
+        data = self.get_account_data(user_mail=user_display_name)
+        return data[0]["displayName"]

python_jira_plus-3.0.0/python_jira_plus/jira_on_premise.py

@@ -0,0 +1,98 @@
+# jira_on_premise.py
+
+import logging
+import time
+
+from jira import JIRA, Issue, JIRAError
+from jira.client import ResultList
+from packaging.version import Version
+from retrying import retry
+
+from python_jira_plus.jira_base import JiraBase, UrlScheme
+
+
+class JiraOnPremise(JiraBase):
+    def __init__(
+        self,
+        base_url: str | None = None,
+        urllib3_log_level: int = logging.WARNING,
+        jira_username: str | None = None,
+        jira_token: str | None = None,
+        verify_ssl: bool = True,
+        sso: bool = False,
+        url_scheme: UrlScheme = UrlScheme.HTTPS,
+    ) -> None:
+        self.sso = sso  # must be set before super().__init__ — create_connection reads it
+        super().__init__(
+            base_url=base_url,
+            urllib3_log_level=urllib3_log_level,
+            jira_username=jira_username,
+            jira_token=jira_token,
+            verify_ssl=verify_ssl,
+            url_scheme=url_scheme,
+        )
+        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 "
+            f"(ON_PREMISE {self.server_version})"
+        )
+        self.use_createmeta = use_legacy
+
+    @retry(stop_max_attempt_number=3, wait_fixed=180000)
+    def create_connection(self, timeout: int = 580) -> JIRA:
+        auth = (
+            {"token_auth": self.jira_token} if not self.sso else {"basic_auth": (self.jira_username, self.jira_token)}
+        )
+        jira_client = JIRA(**auth, options={"server": self.server, "verify": self.verify_ssl}, timeout=timeout)
+        if jira_client.projects():
+            self.logger.info("Jira Connection Successful")
+            return jira_client
+        self.logger.error("Jira Connection Failed")
+        raise JIRAError("Jira Connection Failed")
+
+    def _format_assignee(self, assignee: str) -> dict:
+        return {"name": assignee}
+
+    def _paginate(
+        self,
+        query: str,
+        max_results: int,
+        specific_fields: str | list[str],
+        jira_err_limit: int,
+        json_result: bool,
+    ) -> ResultList[Issue] | list:
+        start_at = 0
+        all_issues = []
+        retries = 0
+        while True:  # pylint: disable=while-used
+            try:
+                self.logger.debug(f"Fetching issues from startAt={start_at}")
+                page = self.jira_client.search_issues(
+                    jql_str=query,
+                    startAt=start_at,
+                    maxResults=max_results,
+                    fields=specific_fields,
+                    json_result=json_result,
+                )
+                if not page:
+                    break
+
+                all_issues += page["issues"] if json_result else page
+                if json_result:
+                    start_at += page["maxResults"]
+                else:
+                    start_at += page.maxResults
+                if start_at >= max_results:
+                    break
+                retries = 0
+            except JIRAError as err:
+                if err.status_code == 400:
+                    self.logger.error(f"Bad Request: {err.text}")
+                    raise JIRAError(f"Bad Request: {err.text}") from err
+                retries += 1
+                self.logger.warning(f"Retry {retries}/{jira_err_limit} after JIRAError: {err}")
+                if retries >= jira_err_limit:
+                    self.logger.exception("Max retries exceeded.")
+                    return []
+                time.sleep(300 if retries == jira_err_limit - 1 else 90)
+        return all_issues

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jira-plus
-Version: 2.0.7
+Version: 3.0.0
 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-3.0.0}/python_jira_plus.egg-info/SOURCES.txt

@@ -4,9 +4,14 @@ README.md
 pyproject.toml
 python_jira_plus/__init__.py
 python_jira_plus/describe_allowed_value.py
-python_jira_plus/jira_plus.py
+python_jira_plus/jira_base.py
+python_jira_plus/jira_cloud.py
+python_jira_plus/jira_on_premise.py
 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-3.0.0}/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-3.0.0/tests/test_describe_allowed_value.py

@@ -0,0 +1,84 @@
+# pylint: disable=no-self-use
+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-3.0.0/tests/test_jira_cloud_integration.py

@@ -0,0 +1,146 @@
+"""
+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
+"""
+
+# pylint: disable=no-self-use,redefined-outer-name,consider-using-assignment-expr
+import os
+
+import pytest
+from jira import Issue, JIRAError
+
+from python_jira_plus import BASIC_FIELDS
+from python_jira_plus.jira_cloud import JiraCloud
+
+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() -> JiraCloud:
+    if missing := _missing_env():
+        pytest.skip(f"Missing required env vars: {', '.join(missing)}")
+    return JiraCloud()
+
+
+@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: JiraCloud) -> None:
+        result = jira.check_client_connection()
+        assert result is True, "Expected active connection to Jira Cloud"
+
+    def test_server_version_is_tuple(self, jira: JiraCloud) -> 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_createmeta(self, jira: JiraCloud) -> None:
+        assert (
+            jira.use_createmeta is True
+        ), "Cloud always uses createmeta — project_issue_types is not supported for Cloud by the jira library"
+
+
+class TestGetObjectsByQuery:
+    def test_returns_list_of_issues(self, jira: JiraCloud, 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: JiraCloud, 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: JiraCloud) -> None:
+        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: JiraCloud, 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, "Expected 'key' in result"
+
+    def test_json_result_false_returns_issue_object(self, jira: JiraCloud, issue_key: str) -> None:
+        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: JiraCloud) -> 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: JiraCloud, 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: JiraCloud, 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-3.0.0/tests/test_jira_plus.py

@@ -0,0 +1,244 @@
+# pylint: disable=no-self-use,protected-access
+from unittest.mock import MagicMock, patch
+
+import pytest
+from jira import JIRAError
+
+from python_jira_plus.jira_cloud import JiraCloud
+from python_jira_plus.jira_on_premise import JiraOnPremise
+
+
+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: JiraCloud) -> None:
+        assert (
+            jira_plus_cloud.use_createmeta is True
+        ), "Cloud always uses createmeta — 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: JiraOnPremise) -> None:
+        assert jira_plus_on_premise_legacy.use_createmeta is True, "ON_PREMISE < 9.0 should use createmeta API"
+
+    def test_on_premise_9_and_above_uses_new_api(self, jira_plus_on_premise_new: JiraOnPremise) -> None:
+        assert (
+            jira_plus_on_premise_new.use_createmeta is False
+        ), "ON_PREMISE >= 9.0 should use project_issue_types / project_issue_fields API"
+
+
+class TestGetIssueByKey:
+    def test_json_result_true_returns_raw_dict(self, jira_plus_cloud: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud, 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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: JiraCloud) -> 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="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: JiraCloud) -> 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="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: JiraCloud) -> None:
+        jira_plus_cloud.jira_client.enhanced_search_issues.return_value = {}
+
+        result = jira_plus_cloud._paginate(
+            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: JiraCloud) -> 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="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: JiraCloud) -> None:
+        mock_response = MagicMock()
+        mock_response.json.return_value = [{"accountId": "abc123", "displayName": "Test User"}]
+
+        with patch("python_jira_plus.jira_cloud.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: JiraCloud) -> None:
+        mock_response = MagicMock()
+        mock_response.raise_for_status.side_effect = Exception("401 Unauthorized")
+
+        with patch("python_jira_plus.jira_cloud.requests.get", return_value=mock_response):
+            with pytest.raises(Exception, match="401"):
+                jira_plus_cloud.get_account_data("bad@test.com")