Answer stability round 1: 0 🔴, 1 🟡 (0 misread); check every field a read takes, ask for a parent by its key, and sort labels
This commit is contained in:
@@ -1,4 +1,4 @@
|
||||
"""What every backend of an epic's plan must hold, as tests. A backend's test case inherits EpicStoreContract and unittest.TestCase, builds an epic with no issues in new_store, and changes an issue as a person would in the tracker in assign and close."""
|
||||
"""What every backend of an epic's plan must hold, as tests. A backend's test case inherits EpicStoreContract and unittest.TestCase, and builds an epic with no issues in new_store. Its assign and close change an issue as a person would in the tracker."""
|
||||
import re
|
||||
import typing
|
||||
|
||||
@@ -8,6 +8,7 @@ from failure import Failure
|
||||
|
||||
class EpicStoreContract:
|
||||
assertEqual: typing.Callable[..., None]
|
||||
assertIsInstance: typing.Callable[..., None]
|
||||
subTest: typing.Callable[..., typing.ContextManager[None]]
|
||||
|
||||
def new_store(self) -> EpicStore:
|
||||
@@ -36,47 +37,52 @@ class EpicStoreContract:
|
||||
|
||||
def test_reads_back_a_child_issue_it_filed(self) -> None:
|
||||
store = self.new_store()
|
||||
key = self.filed(store, store.epic, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("api", "security"))
|
||||
self.assertEqual(self.issues(store), [EpicIssue(key, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("api", "security"), None, "To Do", False, store.epic)])
|
||||
key = self.filed(store, store.epic_key, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("security", "api"))
|
||||
self.assertEqual(self.issues(store), [EpicIssue(key, "Count the runs.", "Why it counts.\n\nA second paragraph.", ("api", "security"), None, "To Do", False, store.epic_key)])
|
||||
|
||||
def test_reads_back_a_sub_task_it_filed_after_its_parent(self) -> None:
|
||||
store = self.new_store()
|
||||
first = self.filed(store, store.epic, "Count the runs.")
|
||||
second = self.filed(store, store.epic, "Ship the later thing.")
|
||||
first = self.filed(store, store.epic_key, "Count the runs.")
|
||||
second = self.filed(store, store.epic_key, "Ship the later thing.")
|
||||
task = self.filed(store, first, "Count them in the api.", labels=("api",))
|
||||
read = self.issues(store)
|
||||
self.assertEqual([(issue.key, issue.parent) for issue in read], [(first, store.epic), (task, first), (second, store.epic)])
|
||||
self.assertEqual([(issue.key, issue.parent) for issue in read], [(first, store.epic_key), (task, first), (second, store.epic_key)])
|
||||
self.assertEqual((read[1].summary, read[1].labels, read[1].detail), ("Count them in the api.", ("api",), ""))
|
||||
|
||||
def test_files_each_issue_under_its_own_key_in_the_epics_project(self) -> None:
|
||||
store = self.new_store()
|
||||
child = self.filed(store, store.epic, "Count the runs.")
|
||||
keys = [child, self.filed(store, store.epic, "Count the runs."), self.filed(store, child, "Count them in the api.")]
|
||||
child = self.filed(store, store.epic_key, "Count the runs.")
|
||||
keys = [child, self.filed(store, store.epic_key, "Count the runs."), self.filed(store, child, "Count them in the api.")]
|
||||
self.assertEqual(len(set(keys)), 3)
|
||||
project = store.epic.rpartition("-")[0]
|
||||
project = store.epic_key.rpartition("-")[0]
|
||||
self.assertEqual([re.fullmatch(f"{project}-[1-9][0-9]*", key) is not None for key in keys], [True] * 3)
|
||||
|
||||
def test_reads_the_assignee_and_a_done_status(self) -> None:
|
||||
store = self.new_store()
|
||||
first = self.filed(store, store.epic, "Count the runs.")
|
||||
second = self.filed(store, store.epic, "Ship the later thing.")
|
||||
first = self.filed(store, store.epic_key, "Count the runs.")
|
||||
second = self.filed(store, store.epic_key, "Ship the later thing.")
|
||||
self.assign(store, first, "Ada Lovelace")
|
||||
self.close(store, second, "Done")
|
||||
read = {issue.key: issue for issue in self.issues(store)}
|
||||
self.assertEqual((read[first].assignee, read[first].status, read[first].done), ("Ada Lovelace", "To Do", False))
|
||||
self.assertEqual((read[second].assignee, read[second].status, read[second].done), (None, "Done", True))
|
||||
|
||||
def test_refuses_to_file_under_an_issue_outside_the_epic_or_under_a_sub_task(self) -> None:
|
||||
def test_refuses_to_file_under_a_sub_task(self) -> None:
|
||||
store = self.new_store()
|
||||
child = self.filed(store, store.epic, "Count the runs.")
|
||||
child = self.filed(store, store.epic_key, "Count the runs.")
|
||||
task = self.filed(store, child, "Count them in the api.")
|
||||
for parent in (task, "ZZZ-1"):
|
||||
with self.subTest(parent=parent):
|
||||
self.assertEqual(store.file(parent, "Count more.", "", ()), Failure(f"{parent} is neither the epic {store.epic} nor one of its child issues, so nothing can be filed under it"))
|
||||
self.assertEqual(store.file(task, "Count more.", "", ()), Failure(f"{task} is neither the epic {store.epic_key} nor one of its child issues, so nothing can be filed under it"))
|
||||
self.assertEqual(len(self.issues(store)), 2)
|
||||
|
||||
def test_refuses_to_file_under_an_issue_outside_the_epic(self) -> None:
|
||||
store = self.new_store()
|
||||
for parent in ("ZZZ-1", "not a key"):
|
||||
with self.subTest(parent=parent):
|
||||
self.assertIsInstance(store.file(parent, "Count more.", "", ()), Failure)
|
||||
self.assertEqual(self.issues(store), [])
|
||||
|
||||
def test_refuses_a_label_with_white_space_and_a_summary_of_two_lines(self) -> None:
|
||||
store = self.new_store()
|
||||
self.assertEqual(store.file(store.epic, "Count the runs.", "", ("two words",)), Failure("the label 'two words' is empty or holds white space"))
|
||||
self.assertEqual(store.file(store.epic, "Count\nthe runs.", "", ()), Failure("the summary must be one line of text"))
|
||||
self.assertEqual(store.file(store.epic_key, "Count the runs.", "", ("two words",)), Failure("the label 'two words' is empty or holds white space"))
|
||||
self.assertEqual(store.file(store.epic_key, "Count\nthe runs.", "", ()), Failure("the summary must be one line of text"))
|
||||
self.assertEqual(self.issues(store), [])
|
||||
|
||||
@@ -1,29 +1,31 @@
|
||||
"""An epic held in memory, for do-epic's tests, held to contract.py like every backend."""
|
||||
import dataclasses
|
||||
|
||||
from do_epic.backend.protocol import EpicIssue, unfit
|
||||
from do_epic.backend.protocol import EpicIssue, no_parent, unfit
|
||||
from failure import Failure
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class MemoryEpic:
|
||||
"""An epic whose issues rank in the order filed. Where fails is set, every read and filing fails with it as the reason."""
|
||||
epic: str
|
||||
epic_key: str
|
||||
issues: list[EpicIssue] = dataclasses.field(default_factory=list)
|
||||
fails: str | None = None
|
||||
|
||||
def read(self) -> list[EpicIssue] | Failure:
|
||||
if self.fails:
|
||||
return Failure(self.fails)
|
||||
return [issue for child in self.issues if child.parent == self.epic for issue in (child, *(task for task in self.issues if task.parent == child.key))]
|
||||
return [issue for child in self.issues if child.parent == self.epic_key for issue in (child, *(task for task in self.issues if task.parent == child.key))]
|
||||
|
||||
def file(self, parent: str, summary: str, detail: str, labels: tuple[str, ...]) -> str | Failure:
|
||||
if self.fails:
|
||||
return Failure(self.fails)
|
||||
if refused := unfit(self.epic, {issue.key for issue in self.issues if issue.parent == self.epic}, parent, summary, labels):
|
||||
if refused := unfit(summary, labels):
|
||||
return refused
|
||||
key = f"{self.epic.rpartition('-')[0]}-{len(self.issues) + 100}"
|
||||
self.issues.append(EpicIssue(key, summary, detail.strip(), labels, None, "To Do", False, parent))
|
||||
if parent != self.epic_key and parent not in {issue.key for issue in self.issues if issue.parent == self.epic_key}:
|
||||
return no_parent(self.epic_key, parent)
|
||||
key = f"{self.epic_key.rpartition('-')[0]}-{len(self.issues) + 100}"
|
||||
self.issues.append(EpicIssue(key, summary, detail.strip(), tuple(sorted(labels)), None, "To Do", False, parent))
|
||||
return key
|
||||
|
||||
def change(self, key: str, **fields: object) -> None:
|
||||
|
||||
+40
-26
@@ -6,7 +6,7 @@ import typing
|
||||
from adf_codec.convert import adfs_to_markdown, markdown_to_adf, Refused
|
||||
from atlassian.client import basic_auth, Http, jira_json, ToAdf, ToMarkdown
|
||||
from project_config.settings import Epic
|
||||
from do_epic.backend.protocol import EpicIssue, unfit
|
||||
from do_epic.backend.protocol import EpicIssue, no_parent, unfit
|
||||
from failure import Failure
|
||||
from plan_store.jira_epic import ISSUE_KEY, ISSUE_TYPE, project_of, searched
|
||||
|
||||
@@ -25,16 +25,16 @@ class Found:
|
||||
|
||||
@dataclasses.dataclass(frozen=True)
|
||||
class JiraEpic:
|
||||
"""The issues of the epic on, read and filed with the credentials env_file holds."""
|
||||
on: Epic
|
||||
"""The issues of a Jira epic, read and filed with the credentials env_file holds."""
|
||||
epic: Epic
|
||||
env_file: pathlib.Path
|
||||
http: Http = jira_json
|
||||
to_markdown: ToMarkdown = adfs_to_markdown
|
||||
to_adf: ToAdf = markdown_to_adf
|
||||
|
||||
@property
|
||||
def epic(self) -> str:
|
||||
return self.on.key
|
||||
def epic_key(self) -> str:
|
||||
return self.epic.key
|
||||
|
||||
def read(self) -> list[EpicIssue] | Failure:
|
||||
authorization = basic_auth(self.env_file)
|
||||
@@ -43,13 +43,13 @@ class JiraEpic:
|
||||
found = self.found(authorization)
|
||||
if isinstance(found, Failure):
|
||||
return found
|
||||
# The descriptions convert in one container run, after every other check, which a read that fails doesn't need.
|
||||
# A container run converts every description at once. It comes after every other check, since a read that fails doesn't need it.
|
||||
described = [each for each in found if each.description is not None]
|
||||
texts = self.to_markdown([each.description for each in described if each.description is not None])
|
||||
if isinstance(texts, Refused):
|
||||
return Failure(f"{described[texts.index].issue.key}'s description: {texts.failure.reason}")
|
||||
if isinstance(texts, Failure):
|
||||
return Failure(f"cannot convert the descriptions of {self.epic}'s issues to markdown: {texts.reason}")
|
||||
return Failure(f"cannot convert the descriptions of {self.epic_key}'s issues to markdown: {texts.reason}")
|
||||
details = {each.issue.key: text.strip() for each, text in zip(described, texts)}
|
||||
return [dataclasses.replace(each.issue, detail=details.get(each.issue.key, "")) for each in found]
|
||||
|
||||
@@ -57,13 +57,10 @@ class JiraEpic:
|
||||
authorization = basic_auth(self.env_file)
|
||||
if isinstance(authorization, Failure):
|
||||
return authorization
|
||||
children = self.searched(f"{self.epic}'s child issues", (self.epic,), authorization)
|
||||
if isinstance(children, Failure):
|
||||
return children
|
||||
if refused := unfit(self.epic, {each.issue.key for each in children}, parent, summary, labels):
|
||||
if refused := unfit(summary, labels) or self.not_a_parent(parent, authorization):
|
||||
return refused
|
||||
fields: dict[str, typing.Any] = {"project": {"key": project_of(parent)}, "parent": {"key": parent}, "summary": summary, "labels": list(labels)}
|
||||
kind = {"name": ISSUE_TYPE} if parent == self.epic else self.sub_task_type(project_of(parent), authorization)
|
||||
kind = {"name": ISSUE_TYPE} if parent == self.epic_key else self.sub_task_type(project_of(parent), authorization)
|
||||
if isinstance(kind, Failure):
|
||||
return kind
|
||||
if detail.strip():
|
||||
@@ -71,7 +68,7 @@ class JiraEpic:
|
||||
if isinstance(description, Failure):
|
||||
return Failure(f"cannot convert the detail to a Jira description: {description.reason}")
|
||||
fields["description"] = description
|
||||
created = self.http("POST", f"{self.on.site}/rest/api/3/issue", authorization, {"fields": fields | {"issuetype": kind}})
|
||||
created = self.http("POST", f"{self.epic.site}/rest/api/3/issue", authorization, {"fields": fields | {"issuetype": kind}})
|
||||
if isinstance(created, Failure):
|
||||
return Failure(f"cannot file the issue under {parent}: {created.reason}; {PERHAPS_FILED.format(parent=parent)}")
|
||||
key = created.get("key") if isinstance(created, dict) else None
|
||||
@@ -79,19 +76,33 @@ class JiraEpic:
|
||||
return Failure(f"Jira answered the new issue without an issue key; {PERHAPS_FILED.format(parent=parent)}")
|
||||
return key
|
||||
|
||||
def not_a_parent(self, parent: str, authorization: str) -> Failure | None:
|
||||
"""Why nothing can be filed under parent; None where it is the epic or one of its child issues."""
|
||||
if parent == self.epic_key:
|
||||
return None
|
||||
if not ISSUE_KEY.fullmatch(parent):
|
||||
return no_parent(self.epic_key, parent)
|
||||
# A search may not show an issue filed a moment ago, so the parent is asked for by its key.
|
||||
answered = self.http("GET", f"{self.epic.site}/rest/api/3/issue/{parent}?fields=parent", authorization, None)
|
||||
if isinstance(answered, Failure):
|
||||
return Failure(f"cannot read {parent} to file under it: {answered.reason}")
|
||||
fields = answered.get("fields") if isinstance(answered, dict) else None
|
||||
above = fields.get("parent") if isinstance(fields, dict) else None
|
||||
return None if isinstance(above, dict) and above.get("key") == self.epic_key else no_parent(self.epic_key, parent)
|
||||
|
||||
def found(self, authorization: str) -> list[Found] | Failure:
|
||||
"""Each child issue, each followed by its sub-tasks."""
|
||||
# The search answers no issues for an epic the account cannot see; asking for the epic itself tells that from an epic without children.
|
||||
seen = self.http("GET", f"{self.on.site}/rest/api/3/issue/{self.epic}?fields=summary", authorization, None)
|
||||
seen = self.http("GET", f"{self.epic.site}/rest/api/3/issue/{self.epic_key}?fields=summary", authorization, None)
|
||||
if isinstance(seen, Failure):
|
||||
return Failure(f"cannot read the epic {self.epic}: {seen.reason}")
|
||||
children = self.searched(f"{self.epic}'s child issues", (self.epic,), authorization)
|
||||
return Failure(f"cannot read the epic {self.epic_key}: {seen.reason}")
|
||||
children = self.searched(f"{self.epic_key}'s child issues", (self.epic_key,), authorization)
|
||||
if isinstance(children, Failure):
|
||||
return children
|
||||
keys = [each.issue.key for each in children]
|
||||
tasks: list[Found] = []
|
||||
for start in range(0, len(keys), PARENTS_PER_SEARCH):
|
||||
batch = self.searched(f"the sub-tasks of {self.epic}'s child issues", tuple(keys[start:start + PARENTS_PER_SEARCH]), authorization)
|
||||
batch = self.searched(f"the sub-tasks of {self.epic_key}'s child issues", tuple(keys[start:start + PARENTS_PER_SEARCH]), authorization)
|
||||
if isinstance(batch, Failure):
|
||||
return batch
|
||||
tasks += batch
|
||||
@@ -100,7 +111,7 @@ class JiraEpic:
|
||||
def searched(self, what: str, parents: tuple[str, ...], authorization: str) -> list[Found] | Failure:
|
||||
"""The issues whose parent is one of parents, in rank order."""
|
||||
named = ", ".join(f'"{key}"' for key in parents)
|
||||
answered = searched(self.on.site, what, f"parent in ({named}) ORDER BY Rank ASC", {"fields": FIELDS}, authorization, self.http)
|
||||
answered = searched(self.epic.site, what, f"parent in ({named}) ORDER BY Rank ASC", {"fields": FIELDS}, authorization, self.http)
|
||||
if isinstance(answered, Failure):
|
||||
return answered
|
||||
found = [found_of(raw) for raw in answered]
|
||||
@@ -108,11 +119,13 @@ class JiraEpic:
|
||||
|
||||
def sub_task_type(self, project: str, authorization: str) -> dict[str, str] | Failure:
|
||||
"""The project's sub-task issue type, by id, since sites name it differently, such as Subtask or Sub-task."""
|
||||
answered = self.http("GET", f"{self.on.site}/rest/api/3/issue/createmeta/{project}/issuetypes", authorization, None)
|
||||
answered = self.http("GET", f"{self.epic.site}/rest/api/3/issue/createmeta/{project}/issuetypes", authorization, None)
|
||||
if isinstance(answered, Failure):
|
||||
return Failure(f"cannot read {project}'s issue types: {answered.reason}")
|
||||
types = answered.get("issueTypes") if isinstance(answered, dict) else None
|
||||
found = next((kind["id"] for kind in types if isinstance(kind, dict) and kind.get("subtask") is True and isinstance(kind.get("id"), str)), None) if isinstance(types, list) else None
|
||||
if not isinstance(types, list):
|
||||
return Failure(f"Jira answered {project}'s issue types in a shape its REST API version 3 doesn't document")
|
||||
found = next((kind["id"] for kind in types if isinstance(kind, dict) and kind.get("subtask") is True and isinstance(kind.get("id"), str)), None)
|
||||
return Failure(f"{project} has no sub-task issue type; turn sub-tasks on in Jira") if found is None else {"id": found}
|
||||
|
||||
|
||||
@@ -124,11 +137,12 @@ def found_of(raw: object) -> Found | Failure:
|
||||
# The answer's nested fields are read as Jira documents them; one missing or of another type ends the read here.
|
||||
try:
|
||||
fields = raw["fields"]
|
||||
assignee = fields["assignee"]["displayName"] if fields["assignee"] is not None else None
|
||||
issue = EpicIssue(key, fields["summary"].strip(), "", tuple(fields["labels"]), assignee, fields["status"]["name"], fields["status"]["statusCategory"]["key"] == "done", fields["parent"]["key"])
|
||||
description = fields["description"]
|
||||
summary, labels, assignee, status, parent, description = fields["summary"], fields["labels"], fields["assignee"], fields["status"], fields["parent"]["key"], fields["description"]
|
||||
name = assignee["displayName"] if assignee is not None else None
|
||||
state, done = status["name"], status["statusCategory"]["key"] == "done"
|
||||
except (AttributeError, KeyError, TypeError) as failure:
|
||||
return Failure(f"{key} is not in the shape Jira Cloud's REST API version 3 documents: {failure!r}")
|
||||
if not all(isinstance(text, str) for text in (*issue.labels, issue.assignee or "", issue.status, issue.parent)) or not isinstance(description, dict | None):
|
||||
return Failure(f"{key} is not in the shape Jira Cloud's REST API version 3 documents: a label, its assignee, status, parent or description holds another kind of value")
|
||||
return Found(issue, description)
|
||||
texts = (summary, *labels, state, parent) if isinstance(labels, list) else ()
|
||||
if not texts or not all(isinstance(text, str) for text in texts) or not isinstance(name, str | None) or not ISSUE_KEY.fullmatch(parent) or not isinstance(description, dict | None):
|
||||
return Failure(f"{key} is not in the shape Jira Cloud's REST API version 3 documents: its summary, labels, assignee, status, parent or description holds another kind of value")
|
||||
return Found(EpicIssue(key, summary.strip(), "", tuple(sorted(labels)), name, state, done, parent), description)
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
"""What every backend of an epic's plan reads and files: an EpicIssue, and the EpicStore protocol they all meet. do-epic reads an epic only through EpicStore, so another tracker can stand behind it; contract.py holds the tests every backend passes.
|
||||
|
||||
It stands apart from plan_store's PlanStore, whose every item names a release, since an epic item has none (`docs/decisions.md` → `do-epic: drives one Jira epic …`) and may be a sub-task."""
|
||||
EpicStore is not plan_store's PlanStore. A PlanStore item names a release, but an epic item has none (`docs/decisions.md` → `do-epic: drives one Jira epic …`), and it may be a sub-task."""
|
||||
import dataclasses
|
||||
import re
|
||||
import typing
|
||||
@@ -18,6 +18,7 @@ class EpicIssue:
|
||||
summary: str
|
||||
# The description, as markdown; empty where the issue has none.
|
||||
detail: str
|
||||
# Sorted by name.
|
||||
labels: tuple[str, ...]
|
||||
# The assignee's display name; None where nobody is assigned.
|
||||
assignee: str | None
|
||||
@@ -30,11 +31,11 @@ class EpicIssue:
|
||||
|
||||
|
||||
class EpicStore(typing.Protocol):
|
||||
"""The issues of one epic. A write that fails files nothing, except where its Failure says the tracker may have taken it all the same."""
|
||||
"""The issues of one epic. A write that fails doesn't file anything, except where its Failure says the tracker may have taken it all the same."""
|
||||
|
||||
@property
|
||||
def epic(self) -> str:
|
||||
"""The epic's key, the parent of each child issue."""
|
||||
def epic_key(self) -> str:
|
||||
"""The parent of each child issue."""
|
||||
|
||||
def read(self) -> list[EpicIssue] | Failure:
|
||||
"""Each child issue, open or done, in the tracker's rank order, each followed by its sub-tasks in theirs."""
|
||||
@@ -43,12 +44,15 @@ class EpicStore(typing.Protocol):
|
||||
"""Files an open issue under parent and answers its key: a child issue where parent is the epic, a sub-task where parent is one of its child issues. detail is markdown, and may be empty."""
|
||||
|
||||
|
||||
def unfit(epic: str, children: set[str], parent: str, summary: str, labels: tuple[str, ...]) -> Failure | None:
|
||||
"""Why an issue with this summary and these labels cannot be filed under parent, where children are the keys of the child issues of the epic named epic; None where it can. Every backend refuses the same filings."""
|
||||
def unfit(summary: str, labels: tuple[str, ...]) -> Failure | None:
|
||||
"""Why no tracker can file an issue with this summary and these labels; None where one can."""
|
||||
if not summary.strip() or "\n" in summary:
|
||||
return Failure("the summary must be one line of text")
|
||||
if bad := next((label for label in labels if not LABEL.fullmatch(label)), None):
|
||||
return Failure(f"the label {bad!r} is empty or holds white space")
|
||||
if parent != epic and parent not in children:
|
||||
return Failure(f"{parent} is neither the epic {epic} nor one of its child issues, so nothing can be filed under it")
|
||||
return None
|
||||
|
||||
|
||||
def no_parent(epic_key: str, parent: str) -> Failure:
|
||||
"""What every backend says when asked to file under parent, which is neither the epic nor one of its child issues."""
|
||||
return Failure(f"{parent} is neither the epic {epic_key} nor one of its child issues, so nothing can be filed under it")
|
||||
|
||||
@@ -38,7 +38,7 @@ def to_markdown(documents: list[dict[str, object]]) -> list[str]:
|
||||
|
||||
@dataclasses.dataclass
|
||||
class FakeJira:
|
||||
"""Jira Cloud's REST API as JiraEpic calls it, holding issues as Jira answers them, in rank order, and answering a search two issues a page, with only the fields it asks for. Where answers holds a method and URL, that call answers what it holds."""
|
||||
"""Jira Cloud's REST API as JiraEpic calls it. It holds issues as Jira answers them, in rank order. A search answers two issues a page, with only the fields it asks for. A call whose method and URL are in answers gets the answer held there instead."""
|
||||
issues: list[dict[str, object]] = dataclasses.field(default_factory=list)
|
||||
answers: dict[tuple[str, str], object] = dataclasses.field(default_factory=dict)
|
||||
calls: list[tuple[str, str]] = dataclasses.field(default_factory=list)
|
||||
@@ -55,6 +55,8 @@ class FakeJira:
|
||||
return TYPES
|
||||
if method == "POST" and url == SEARCH:
|
||||
return self.page(body)
|
||||
if method == "GET" and (held := next((issue for issue in self.issues if url == f"{ISSUES}/{issue['key']}?fields=parent"), None)):
|
||||
return {"key": held["key"], "fields": {"parent": held["fields"]["parent"]}} # type: ignore[index]
|
||||
if method == "POST" and url == ISSUES:
|
||||
return self.created(body)
|
||||
return Failure(f"Jira answered 404 for {method} {url}")
|
||||
@@ -118,13 +120,13 @@ class Jira(Case):
|
||||
self.new_store().file("ABC-12", "Count the runs.", "", ())
|
||||
self.assertNotIn(("GET", ISSUE_TYPES), self.jira.calls)
|
||||
|
||||
def test_a_refused_filing_or_one_answered_without_a_key_says_the_issue_may_exist(self) -> None:
|
||||
def test_a_filing_jira_fails_or_answers_without_a_key_says_the_issue_may_exist(self) -> None:
|
||||
for answer, reason in ((Failure("Jira answered 503"), "cannot file the issue under ABC-12: Jira answered 503"), ({"id": "1"}, "Jira answered the new issue without an issue key"), (["ABC-100"], "Jira answered the new issue without an issue key")):
|
||||
with self.subTest(answer=answer):
|
||||
self.jira.answers[("POST", ISSUES)] = answer
|
||||
self.assertEqual(self.new_store().file("ABC-12", "Count the runs.", "", ()), Failure(f"{reason}; unless Jira refused the request, the issue may exist: look under ABC-12 before filing it again"))
|
||||
|
||||
def test_a_detail_the_codec_refuses_files_nothing(self) -> None:
|
||||
def test_a_detail_the_codec_refuses_leaves_the_epic_as_it_was(self) -> None:
|
||||
store = JiraEpic(EPIC, self.env_file, self.jira, to_markdown, lambda markdown: Failure("adf-codec refused it"))
|
||||
self.assertEqual(store.file("ABC-12", "Count the runs.", "Why.", ()), Failure("cannot convert the detail to a Jira description: adf-codec refused it"))
|
||||
self.assertEqual(self.jira.issues, [])
|
||||
@@ -132,7 +134,7 @@ class Jira(Case):
|
||||
def test_files_no_sub_task_where_the_project_has_no_sub_task_type_or_its_types_cannot_be_read(self) -> None:
|
||||
store = self.new_store()
|
||||
child = store.file("ABC-12", "Count the runs.", "", ())
|
||||
for answer, reason in ((Failure("Jira answered 403"), "cannot read ABC's issue types: Jira answered 403"), ({"issueTypes": [{"id": "10001", "subtask": False}]}, "ABC has no sub-task issue type; turn sub-tasks on in Jira"), ({}, "ABC has no sub-task issue type; turn sub-tasks on in Jira"), ([], "ABC has no sub-task issue type; turn sub-tasks on in Jira")):
|
||||
for answer, reason in ((Failure("Jira answered 403"), "cannot read ABC's issue types: Jira answered 403"), ({"issueTypes": [{"id": "10001", "subtask": False}]}, "ABC has no sub-task issue type; turn sub-tasks on in Jira"), ({}, "Jira answered ABC's issue types in a shape its REST API version 3 doesn't document"), ([], "Jira answered ABC's issue types in a shape its REST API version 3 doesn't document")):
|
||||
with self.subTest(answer=answer):
|
||||
self.jira.answers[("GET", ISSUE_TYPES)] = answer
|
||||
self.assertEqual(store.file(str(child), "A task.", "", ()), Failure(reason))
|
||||
@@ -145,9 +147,10 @@ class Jira(Case):
|
||||
("ABC-34", "the search answered an issue without an issue key"),
|
||||
({"fields": valid}, "the search answered an issue without an issue key"),
|
||||
({"key": "abc-34", "fields": valid}, "the search answered an issue without an issue key"),
|
||||
({"key": "ABC-34", "fields": {"summary": "Count the runs.", "parent": {"key": "ABC-12"}}}, shape + ": KeyError('assignee')"),
|
||||
({"key": "ABC-34", "fields": valid | {"labels": [3]}}, shape + ": a label, its assignee, status, parent or description holds another kind of value"),
|
||||
({"key": "ABC-34", "fields": valid | {"description": "text"}}, shape + ": a label, its assignee, status, parent or description holds another kind of value"),
|
||||
({"key": "ABC-34", "fields": {"summary": "Count the runs.", "parent": {"key": "ABC-12"}}}, shape + ": KeyError('labels')"),
|
||||
*((({"key": "ABC-34", "fields": valid | changed}, shape + ": its summary, labels, assignee, status, parent or description holds another kind of value") for changed in (
|
||||
{"summary": 3}, {"labels": "api"}, {"labels": [3]}, {"assignee": {"displayName": 0}}, {"status": {"name": 0, "statusCategory": {"key": "new"}}}, {"parent": {"key": "ABC"}}, {"parent": {"key": 12}}, {"description": "text"},
|
||||
))),
|
||||
):
|
||||
with self.subTest(raw=raw):
|
||||
self.jira.answers[("POST", SEARCH)] = {"issues": [raw]}
|
||||
@@ -168,7 +171,15 @@ class Jira(Case):
|
||||
self.assertEqual(store.read(), Failure("the search for the sub-tasks of ABC-12's child issues did not end within 1 pages"))
|
||||
store.file("ABC-12", "Count the runs.", "", ())
|
||||
self.assertEqual(store.read(), Failure("the search for ABC-12's child issues did not end within 1 pages"))
|
||||
self.assertEqual(store.file("ABC-12", "Count the runs.", "", ()), Failure("the search for ABC-12's child issues did not end within 1 pages"))
|
||||
|
||||
def test_refuses_to_file_under_another_epics_child_or_an_issue_it_cannot_read(self) -> None:
|
||||
self.jira.issues.append({"key": "ABC-5", "fields": {"parent": {"key": "ABC-1"}}})
|
||||
store = self.new_store()
|
||||
self.assertEqual(store.file("ABC-5", "Count more.", "", ()), Failure("ABC-5 is neither the epic ABC-12 nor one of its child issues, so nothing can be filed under it"))
|
||||
self.assertEqual(store.file("ABC-77", "Count more.", "", ()), Failure(f"cannot read ABC-77 to file under it: Jira answered 404 for GET {ISSUES}/ABC-77?fields=parent"))
|
||||
self.jira.answers[("GET", f"{ISSUES}/ABC-78?fields=parent")] = ["ABC-12"]
|
||||
self.assertEqual(store.file("ABC-78", "Count more.", "", ()), Failure("ABC-78 is neither the epic ABC-12 nor one of its child issues, so nothing can be filed under it"))
|
||||
self.assertEqual([call for call in self.jira.calls if call[0] == "POST" and call[1] == ISSUES], [])
|
||||
|
||||
def test_an_epic_the_account_cannot_see_fails_the_read(self) -> None:
|
||||
store = JiraEpic(Epic(SITE, "ABC-99"), self.env_file, self.jira, to_markdown, to_adf)
|
||||
|
||||
Reference in New Issue
Block a user