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

{python_jira_plus-2.0.8/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.8
+Version: 3.0.0
 Summary: Enhanced Python client for JIRA with better error handling, pagination, and metadata validation.
 Author: Avi Zaguri
 License: MIT

{python_jira_plus-2.0.8 → 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.8"
+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"

{python_jira_plus-2.0.8 → 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, UrlScheme
+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", "UrlScheme", "BASIC_FIELDS"]
+__all__ = ["JiraBase", "JiraCloud", "JiraOnPremise", "UrlScheme", "BASIC_FIELDS"]

python_jira_plus-2.0.8/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,35 +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()
-        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:
-        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
-            )
-        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:
@@ -82,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:
@@ -98,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]:
@@ -120,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,
@@ -133,107 +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:
-            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
-                is_last = page['isLast'] if json_result else page.isLast
-                if is_last:
-                    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,
@@ -241,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
@@ -272,36 +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 _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.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)
-        _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:
+    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(
@@ -309,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")
@@ -323,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,
@@ -334,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
@@ -359,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
@@ -398,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,
@@ -438,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
             )
@@ -455,21 +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]:
-        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_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.8 → 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.8
+Version: 3.0.0
 Summary: Enhanced Python client for JIRA with better error handling, pagination, and metadata validation.
 Author: Avi Zaguri
 License: MIT

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

@@ -4,7 +4,9 @@ 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-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-2.0.8 → python_jira_plus-3.0.0}/tests/test_jira_cloud_integration.py

@@ -16,12 +16,14 @@ 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_plus import JiraPlus
+from python_jira_plus.jira_cloud import JiraCloud
 
 pytestmark = pytest.mark.integration
 
@@ -33,11 +35,10 @@ def _missing_env() -> list[str]:
 
 
 @pytest.fixture(scope="module")
-def jira() -> JiraPlus:
-    missing = _missing_env()
-    if missing:
+def jira() -> JiraCloud:
+    if missing := _missing_env():
         pytest.skip(f"Missing required env vars: {', '.join(missing)}")
-    return JiraPlus()
+    return JiraCloud()
 
 
 @pytest.fixture(scope="module")
@@ -61,22 +62,22 @@ def test_field() -> str:
 
 
 class TestConnection:
-    def test_client_is_connected(self, jira: JiraPlus) -> None:
+    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: JiraPlus) -> None:
-        assert isinstance(jira.server_version, tuple), \
-            f"Expected tuple, got {type(jira.server_version)}"
+    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_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"
+    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: JiraPlus, project_key: str, issue_type: str) -> None:
+    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,
@@ -86,7 +87,7 @@ class TestGetObjectsByQuery:
         )
         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:
+    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,
@@ -101,47 +102,42 @@ class TestGetObjectsByQuery:
         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
+    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: JiraPlus, issue_key: str) -> None:
+    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, f"Expected 'key' in result"
+        assert "key" in result, "Expected 'key' in result"
 
-    def test_json_result_false_returns_issue_object(self, jira: JiraPlus, issue_key: str) -> None:
-        from jira import Issue
+    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: JiraPlus) -> None:
+    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: JiraPlus, project_key: str, issue_type: str, test_field: str
+        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)}"
+        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:
+    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,

{python_jira_plus-2.0.8 → python_jira_plus-3.0.0}/tests/test_jira_plus.py

@@ -1,9 +1,11 @@
+# pylint: disable=no-self-use,protected-access
 from unittest.mock import MagicMock, patch
 
 import pytest
 from jira import JIRAError
 
-from python_jira_plus.jira_plus import JiraPlus
+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:
@@ -21,21 +23,22 @@ def _make_field_mock(field_id: str, raw: dict) -> MagicMock:
 
 
 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_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: 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_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: JiraPlus) -> None:
-        assert jira_plus_on_premise_new.use_legacy_api is False, \
-            "ON_PREMISE >= 9.0 should use project_issue_types 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: JiraPlus) -> None:
+    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
@@ -44,7 +47,7 @@ class TestGetIssueByKey:
 
         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:
+    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
 
@@ -52,14 +55,14 @@ class TestGetIssueByKey:
 
         assert result is mock_issue, "Expected Issue object, not raw dict"
 
-    def test_jira_error_returns_none(self, jira_plus_cloud: JiraPlus) -> None:
+    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: JiraPlus) -> None:
+    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")
@@ -68,7 +71,7 @@ class TestGetIssueByKey:
 
 
 class TestDeleteIssue:
-    def test_success_returns_true_and_calls_delete(self, jira_plus_cloud: JiraPlus) -> None:
+    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
 
@@ -77,14 +80,14 @@ class TestDeleteIssue:
         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:
+    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: JiraPlus) -> None:
+    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")
@@ -93,67 +96,84 @@ class TestDeleteIssue:
 
 
 class TestValidateFields:
-    def _setup_createmeta(self, jira_plus: JiraPlus, fields: dict) -> None:
+    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}],
-            }]
+            "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"},
-        })
+    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: JiraPlus) -> None:
-        self._setup_createmeta(jira_plus_cloud, {
-            "summary": {"schema": {"type": "string"}, "name": "Summary"},
-        })
+    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: JiraPlus) -> None:
-        self._setup_createmeta(jira_plus_cloud, {
-            "summary": {"schema": {"type": "string"}, "name": "Summary"},
-        })
+    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: JiraPlus) -> None:
-        self._setup_createmeta(jira_plus_cloud, {
-            "story_points": {"schema": {"type": "number"}, "name": "Story Points"},
-        })
+    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: JiraPlus) -> None:
-        self._setup_createmeta(jira_plus_cloud, {
-            "priority": {
-                "schema": {"type": "string"},
-                "name": "Priority",
-                "allowedValues": [{"name": "High"}, {"name": "Low"}],
+    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: JiraPlus) -> None:
+    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_new(
+        result = jira_plus_cloud._paginate(
             query="project = PROJ",
             max_results=50,
             specific_fields="*all",
@@ -163,12 +183,12 @@ class TestPaginateQueryNew:
 
         assert result == issues, f"Expected {issues}, got {result}"
 
-    def test_multiple_pages_accumulates_all_issues(self, jira_plus_cloud: JiraPlus) -> None:
+    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_new(
+        result = jira_plus_cloud._paginate(
             query="project = PROJ",
             max_results=50,
             specific_fields="*all",
@@ -176,13 +196,12 @@ class TestPaginateQueryNew:
             json_result=True,
         )
 
-        assert result == [{"key": "PROJ-1"}, {"key": "PROJ-2"}], \
-            f"Expected both pages merged, got {result}"
+        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:
+    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_new(
+        result = jira_plus_cloud._paginate(
             query="project = PROJ",
             max_results=50,
             specific_fields="*all",
@@ -192,13 +211,11 @@ class TestPaginateQueryNew:
 
         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
-        )
+    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_new(
+            jira_plus_cloud._paginate(
                 query="invalid JQL !!!",
                 max_results=50,
                 specific_fields="*all",
@@ -208,20 +225,20 @@ class TestPaginateQueryNew:
 
 
 class TestGetAccountData:
-    def test_success_returns_user_list(self, jira_plus_cloud: JiraPlus) -> None:
+    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_plus.requests.get", return_value=mock_response):
+        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: JiraPlus) -> None:
+    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_plus.requests.get", return_value=mock_response):
+        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")

python_jira_plus-2.0.8/tests/test_describe_allowed_value.py

@@ -1,77 +0,0 @@
-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"})