tcw-cli 2.1.2__tar.gz → 2.1.3__tar.gz

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tcw-cli
-Version: 2.1.2
+Version: 2.1.3
 Summary: Taxonomy · Capabilities · Work — a storage-abstracted framework for describing and evolving a software project.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -603,6 +603,32 @@ work:
 environment variables; TCW reads them at the moment it makes a request, so a token
 cannot be committed by accident.
 
+**Write the shared settings once.** In a workspace of connected nodes, a node's
+`tracker` block takes any setting it leaves out from its parent nodes, all the way
+up. So the site, credentials and claim transition can live in the workspace root,
+and each package writes only the tickets it wants to see:
+
+```yaml
+# packages/api/tcw-config.yaml
+work:
+    tracker:
+        candidate-query: project = EX AND component = api AND status = "To Do"
+```
+
+The nearest file wins each setting, and `credentials` and `transitions` merge
+setting by setting too. A node with no `tracker` block of its own has no tracker,
+whatever its parents say. Two rules keep this safe:
+
+- **`credentials` must sit beside `base-url`.** A node that sets its own `base-url`
+  must also set both of its own `credentials` keys, even if the address is the same
+  as its parent's, so a token is never sent to a site chosen in a different file.
+- **A node with its own board is checked like any tracking node.** If it holds the
+  shared settings, it needs a `candidate-query` of its own. Keeping shared settings
+  in a node without a board avoids that.
+
+A mistake in a parent's settings is reported by `tcw validate` in every node that
+inherits it, naming the parent's file.
+
 `tracker show` reports two different things, and the distinction matters:
 
 - **claimable** — whether this ticket currently offers the transition you
@@ -625,15 +651,17 @@ ticket's text goes into the item as its raw input, with a link back, and the ite
 request still gets written the usual way. A ticket assigned to someone else is
 refused, and so is one that is already closed.
 
-Running `import` again for the same ticket gives you the same item rather than a
-second one, and if the first run took the ticket but stopped before creating the
+Running `import` again for the same ticket in the same node gives you the same item
+rather than a second one, and if the first run took the ticket but stopped before creating the
 item, the second run finishes the job. One ticket can deliberately become several
 items with `--part api`, `--part web`, and so on. `unlink` removes a wrong binding
 and keeps a record of it with your reason; it never changes the ticket in Jira.
 
-Two limits to know. On a workflow that lets anyone start a ticket from any status,
-two people can both take the same ticket, and TCW does not stop that. And two runs
-by the same Jira account at the same moment can both create an item.
+Three limits to know. On a workflow that lets anyone start a ticket from any status,
+two people can both take the same ticket, and TCW does not stop that. Two runs by the
+same Jira account at the same moment can both create an item. And each node keeps its
+own bindings: importing one ticket in two nodes of a workspace, even nodes sharing
+inherited settings, gives two items, one in each.
 
 Two guarantees worth stating plainly. A project with no `tracker` block behaves
 exactly as before, with no new required setting and no network access. And

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/README.md

@@ -387,6 +387,32 @@ work:
 environment variables; TCW reads them at the moment it makes a request, so a token
 cannot be committed by accident.
 
+**Write the shared settings once.** In a workspace of connected nodes, a node's
+`tracker` block takes any setting it leaves out from its parent nodes, all the way
+up. So the site, credentials and claim transition can live in the workspace root,
+and each package writes only the tickets it wants to see:
+
+```yaml
+# packages/api/tcw-config.yaml
+work:
+    tracker:
+        candidate-query: project = EX AND component = api AND status = "To Do"
+```
+
+The nearest file wins each setting, and `credentials` and `transitions` merge
+setting by setting too. A node with no `tracker` block of its own has no tracker,
+whatever its parents say. Two rules keep this safe:
+
+- **`credentials` must sit beside `base-url`.** A node that sets its own `base-url`
+  must also set both of its own `credentials` keys, even if the address is the same
+  as its parent's, so a token is never sent to a site chosen in a different file.
+- **A node with its own board is checked like any tracking node.** If it holds the
+  shared settings, it needs a `candidate-query` of its own. Keeping shared settings
+  in a node without a board avoids that.
+
+A mistake in a parent's settings is reported by `tcw validate` in every node that
+inherits it, naming the parent's file.
+
 `tracker show` reports two different things, and the distinction matters:
 
 - **claimable** — whether this ticket currently offers the transition you
@@ -409,15 +435,17 @@ ticket's text goes into the item as its raw input, with a link back, and the ite
 request still gets written the usual way. A ticket assigned to someone else is
 refused, and so is one that is already closed.
 
-Running `import` again for the same ticket gives you the same item rather than a
-second one, and if the first run took the ticket but stopped before creating the
+Running `import` again for the same ticket in the same node gives you the same item
+rather than a second one, and if the first run took the ticket but stopped before creating the
 item, the second run finishes the job. One ticket can deliberately become several
 items with `--part api`, `--part web`, and so on. `unlink` removes a wrong binding
 and keeps a record of it with your reason; it never changes the ticket in Jira.
 
-Two limits to know. On a workflow that lets anyone start a ticket from any status,
-two people can both take the same ticket, and TCW does not stop that. And two runs
-by the same Jira account at the same moment can both create an item.
+Three limits to know. On a workflow that lets anyone start a ticket from any status,
+two people can both take the same ticket, and TCW does not stop that. Two runs by the
+same Jira account at the same moment can both create an item. And each node keeps its
+own bindings: importing one ticket in two nodes of a workspace, even nodes sharing
+inherited settings, gives two items, one in each.
 
 Two guarantees worth stating plainly. A project with no `tracker` block behaves
 exactly as before, with no new required setting and no network access. And

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tcw-cli"
-version = "2.1.2"
+version = "2.1.3"
 description = "Taxonomy · Capabilities · Work — a storage-abstracted framework for describing and evolving a software project."
 readme = "README.md"
 requires-python = ">=3.11"

tcw_cli-2.1.3/tcw/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.1.3"

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tcw/store/base.py

@@ -14,6 +14,7 @@ extracted in Phase 4 — not pre-abstracted here.
 # time. Python 3.14 defers natively (PEP 649); this keeps <3.14 working too.
 from __future__ import annotations
 
+import copy
 import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
@@ -943,7 +944,7 @@ def parse_tracker_config(raw: Any) -> tuple["TrackerConfig | None", list[str]]:
 
     problems: list[str] = []
 
-    for key in sorted(set(raw) - TRACKER_KEYS):
+    for key in sorted(set(raw) - TRACKER_KEYS, key=str):
         problems.append(f"work.tracker.{key}: unknown key")
 
     def required_str(key: str) -> str:
@@ -974,7 +975,7 @@ def parse_tracker_config(raw: Any) -> tuple["TrackerConfig | None", list[str]]:
             problems.append(f"work.tracker.{key}: expected a mapping, "
                             f"got {type(value).__name__}")
             return {}
-        for sub in sorted(set(value) - allowed):
+        for sub in sorted(set(value) - allowed, key=str):
             problems.append(f"work.tracker.{key}.{sub}: unknown key")
         return value
 
@@ -1021,6 +1022,135 @@ def parse_tracker_config(raw: Any) -> tuple["TrackerConfig | None", list[str]]:
     ), []
 
 
+TrackerKeyPath = tuple[Any, ...]
+
+
+def merge_tracker_blocks(
+    blocks: list[tuple[str, Any]],
+) -> tuple[Any, dict[TrackerKeyPath, str], str | None]:
+    """Lay `work.tracker` blocks over each other, nearest first, key by key.
+
+    Pure, like `parse_tracker_config`: the caller gathers the blocks from its own
+    project graph, so a store that is not a filesystem merges the same way. Each
+    block is `(label, raw)`, and labels must be distinct — the node itself first,
+    then its ancestors, direct parent first. Whether a node takes part at all
+    (opt-in) is the caller's decision; this only merges what it is given.
+
+    Returns `(merged, record, whole_block_label)`:
+
+    - `merged` goes to `parse_tracker_config` unchanged.
+    - `record` maps each key path in `merged` to the label that supplied its
+      value. A nearer null that let a farther value show through does not move
+      it: the credentials rule reads it, and naming the null's file there would
+      let a token follow a changed `base-url`.
+    - `whole_block_label` is set when an ancestor's block is not a mapping. The
+      merge stops there and returns that block, so the parser's "expected a
+      mapping" is reported against the ancestor and every node beneath it fails
+      closed.
+    """
+    if not blocks:
+        return None, {}, None
+    own = blocks[0][1]
+    if not isinstance(own, dict):
+        return own, {}, None
+    layers = [blocks[0]]
+    for label, raw in blocks[1:]:
+        if raw is None or raw == {}:
+            continue
+        if not isinstance(raw, dict):
+            return raw, {}, label
+        layers.append((label, raw))
+
+    merged: dict = {}
+    record: dict[TrackerKeyPath, str] = {}
+    for label, raw in reversed(layers):
+        _lay_tracker_block(merged, copy.deepcopy(raw), label, (), record)
+    return merged, record, None
+
+
+def _lay_tracker_block(target: dict, source: dict, label: str,
+                       path: TrackerKeyPath, record: dict[TrackerKeyPath, str]) -> None:
+    for key, value in source.items():
+        key_path = (*path, key)
+        if value is None:
+            if key not in target:          # nothing farther: kept, for the parser
+                target[key] = None
+                record[key_path] = label
+            continue                       # otherwise the farther value shows through
+        if isinstance(value, dict) and isinstance(target.get(key), dict):
+            record[key_path] = label
+            _lay_tracker_block(target[key], value, label, key_path, record)
+            continue
+        for stale in [p for p in record if p[:len(key_path)] == key_path]:
+            del record[stale]
+        target[key] = value
+        record[key_path] = label
+        if isinstance(value, dict):
+            _record_tracker_paths(value, label, key_path, record)
+
+
+def _record_tracker_paths(block: dict, label: str, path: TrackerKeyPath,
+                          record: dict[TrackerKeyPath, str]) -> None:
+    for key, value in block.items():
+        key_path = (*path, key)
+        record[key_path] = label
+        if isinstance(value, dict):
+            _record_tracker_paths(value, label, key_path, record)
+
+
+def tracker_credentials_problem(record: dict[TrackerKeyPath, str],
+                                labels: list[str]) -> str | None:
+    """A problem when `credentials` came from farther up than `base-url`.
+
+    `JiraClient` sends a token built from the named variables to whatever
+    `base-url` names. Before inheritance both sat in one block, so whoever chose
+    the site chose the token. This keeps that true: a node that sets `base-url`
+    also sets `credentials`, even when the URL repeats its parent's. Credentials
+    partly inherited count by their farthest key. Run on a config that parsed.
+    """
+    position = {label: index for index, label in enumerate(labels)}
+    base_url = record.get(("base-url",))
+    credentials = [label for key_path, label in record.items()
+                   if len(key_path) > 1 and key_path[0] == "credentials"]
+    if base_url is None or not credentials:
+        return None
+    if max(position[label] for label in credentials) <= position[base_url]:
+        return None
+    return (f"work.tracker.credentials: inherited from a parent node, but base-url "
+            f"is set nearer, in {base_url}; set credentials in the same file as "
+            f"base-url")
+
+
+def attribute_tracker_problems(problems: list[str], record: dict[TrackerKeyPath, str],
+                               own_label: str, whole_block_label: str | None) -> list[str]:
+    """Prefix each parser problem with the label of the file that caused it.
+
+    Matched on the problem's exact key path, never the nearest enclosing
+    mapping: `transitions.claim: required` under a `transitions` an ancestor
+    supplied is about a key nobody set, and goes to `own_label`. The parser
+    writes a path as its keys joined with `.` followed by `: `, so the longest
+    recorded path whose spelling prefixes the problem that way is the one it is
+    about — which also holds for a key whose own name contains `.` or `: `.
+
+    Two recorded paths can share a spelling (an integer key `5` and a string key
+    `"5"`, or a key named `credentials.x` beside a nested one). Such a block is
+    already invalid and every problem is still reported; only the file named for
+    it may be the other one's.
+    """
+    spelled = sorted(((".".join(map(str, key_path)), label)
+                      for key_path, label in record.items()),
+                     key=lambda entry: len(entry[0]), reverse=True)
+    attributed = []
+    for problem in problems:
+        if problem.startswith("work.tracker: "):
+            label = whole_block_label or own_label
+        else:
+            label = next((label for spelling, label in spelled
+                          if problem.startswith(f"work.tracker.{spelling}: ")), own_label)
+        attributed.append(f"{label}: {problem}")
+    return attributed
+
+
 @dataclass(frozen=True)
 class RepositoryDeclaration:
     """Where a component store comes from, as the project records it.
@@ -2285,6 +2415,11 @@ class WorkStore(ABC):
     def tracker_config(self) -> "TrackerConfig | None":
         """The node's external-tracker settings, or `None` when none is configured.
 
+        A node whose own `work.tracker` is a non-empty mapping inherits the keys it
+        does not set from its ancestors: an adapter gathers their blocks from its
+        project graph, lays them with `merge_tracker_blocks`, parses the result,
+        and refuses a config `tracker_credentials_problem` objects to.
+
         Problems discarded, so a malformed key can never break a board read. Fails
         *closed*: the parser returns `None` on any problem, so a half-read config
         is one nobody declared. `tracker_problems` is where a user learns why.

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tcw/store/fs.py

@@ -47,7 +47,8 @@ from tcw.store.base import (
     Binding, DocEntry, body_title, frontmatter_end,
     parse_documentation_entries, parse_lifecycle_policy,
     parse_connected_entry, parse_repository_declaration, parse_retention,
-    parse_tracker_config, TrackerConfig,
+    parse_tracker_config, TrackerConfig, attribute_tracker_problems,
+    merge_tracker_blocks, tracker_credentials_problem,
     ProvisionResult,
     RepositoryDeclaration,
     PublicationError, StoreDeclarationError, StoreLocationUnusable,
@@ -5358,15 +5359,64 @@ class FsWorkStore(FsTreeStore, WorkStore):
     def tracker_config(self) -> "TrackerConfig | None":
         """Configured tracker settings, problems discarded — same contract as
         `documentation`: a malformed key must not break `tcw work list`."""
-        config, _problems = parse_tracker_config(self._work_config().get("tracker"))
-        return config
+        return self._resolved_tracker()[0]
 
     def tracker_problems(self) -> list[str]:
-        """Tracker-configuration problems, prefixed with the file they came from.
-        Shares the parser with `tracker_config`, so the two surfaces can never
-        disagree about what is legal."""
-        _config, problems = parse_tracker_config(self._work_config().get("tracker"))
-        return [f"{SENTINEL}: {p}" for p in problems]
+        """Tracker-configuration problems, each prefixed with the file it came from.
+        Shares `_resolved_tracker` with `tracker_config`, so the two surfaces can
+        never disagree about what is legal."""
+        return self._resolved_tracker()[1]
+
+    def _resolved_tracker(self) -> "tuple[TrackerConfig | None, list[str]]":
+        """This node's `work.tracker`, merged over its ancestors' when it opts in.
+
+        Opt-in: only a node whose own block is a non-empty mapping consults its
+        ancestors. A node that writes nothing has no tracker whatever they hold, so
+        a node that never asked for one neither gains one nor fails `tcw validate`
+        because a parent keeps shared settings.
+
+        Ancestors are read through the project registry, not by walking
+        directories, and a graph with problems falls back to the node's own block:
+        both commands that read this refuse on graph problems first, so only a
+        direct caller reaches the fallback, and it must still not raise.
+        """
+        own = self._work_config().get("tracker")
+        if own is None or own == {}:
+            return None, []
+        blocks: list[tuple[str, object]] = [(SENTINEL, own)]
+        unreachable: str | None = None
+        if isinstance(own, dict):
+            try:
+                registry = FsProjectRegistry.open(self.node_root).require_valid()
+            except ValueError:
+                registry = None
+            if registry is not None:
+                ancestors = registry.ancestors()
+                for ancestor in ancestors:
+                    work = registry.config(ancestor.id).get("work")
+                    if isinstance(work, dict):
+                        blocks.append((f"{Path(ancestor.locator) / SENTINEL} "
+                                       f"(project '{ancestor.id}')", work.get("tracker")))
+                # `ancestors()` stops at the first parent this checkout lacks, at
+                # any depth, so ask who the last one reached declares.
+                parent_id = registry.declared_parent_id(
+                    ancestors[-1].id if ancestors else None)
+                if parent_id is not None and registry.get(parent_id) is None:
+                    unreachable = parent_id
+
+        merged, record, whole_block_label = merge_tracker_blocks(blocks)
+        config, parsed = parse_tracker_config(merged)
+        problems = attribute_tracker_problems(parsed, record, SENTINEL, whole_block_label)
+        if config is not None:
+            credentials = tracker_credentials_problem(record, [label for label, _ in blocks])
+            if credentials is not None:
+                config, problems = None, [f"{SENTINEL}: {credentials}"]
+        if problems and unreachable is not None:
+            problems.append(
+                f"{SENTINEL}: work.tracker: declared parent '{unreachable}' is not "
+                f"available in this checkout, so any tracker settings it holds were "
+                f"not read (run tcw provision)")
+        return config, problems
 
     def documentation_problems(self) -> list[str]:
         """Documentation-entry problems, prefixed with the file they came from —

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tcw/store/project.py

@@ -445,7 +445,7 @@ class FsProjectRegistry(ProjectRegistry):
             connected = {}
         unknown = set(connected) - {"parent", "children"}
         if unknown:
-            self._problem(path, f"unknown connected-projects keys: {', '.join(sorted(unknown))}")
+            self._problem(path, f"unknown connected-projects keys: {', '.join(sorted(map(str, unknown)))}")
         children = self._relation(path, connected.get("children"), "children")
         parent = self._relation(path, connected.get("parent"), "parent")
         if len(parent) > 1:

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tcw/work/cli.py

@@ -1711,10 +1711,15 @@ def _intake_text(outcome, description: str, today: str) -> str:
             f"{body}\n")
 
 
-def _binding_for(st, outcome, part: str, today: str, unlinked: list) -> str:
+def _binding_for(provider: str, project: str, outcome, part: str, today: str,
+                 unlinked: list) -> str:
+    """The binding document. `provider` and `project` are the values the claim was
+    looked up and made with, passed in rather than read again: tracker settings can
+    come from parent nodes' files, and one changed or broken mid-run would otherwise
+    fail here, after the ticket is already claimed."""
     from tcw.tracker.intake import binding_document
     return binding_document(
-        provider=st.tracker_config().provider, project=_project_id(st), part=part,
+        provider=provider, project=project, part=part,
         ticket_id=outcome.issue_id, ticket_key=outcome.key, ticket_url=outcome.url,
         account_id=outcome.account_id, account_name=outcome.account_name,
         bound=today, unlinked=unlinked)
@@ -1761,7 +1766,8 @@ def _tracker_import(args: argparse.Namespace) -> int:
     today = date.today().isoformat()
     try:
         ticket = read_ticket(client, args.ticket)
-        existing = find_binding(st, project=_project_id(st),
+        project = _project_id(st)
+        existing = find_binding(st, project=project,
                                 provider=client.config.provider,
                                 ticket_id=ticket.issue_id, part=part)
         if existing is not None:
@@ -1799,7 +1805,8 @@ def _tracker_import(args: argparse.Namespace) -> int:
         return 1
     try:
         st.write_sidecar(slug, BINDING_SIDECAR,
-                         _binding_for(st, outcome, part, today, []), revision="")
+                         _binding_for(client.config.provider, project, outcome, part,
+                                      today, []), revision="")
     except _LOCAL_WRITE_ERRORS as e:
         try:
             st.drop(slug)
@@ -1869,7 +1876,8 @@ def _tracker_link(args: argparse.Namespace) -> int:
         return 1
     try:
         ticket = read_ticket(client, args.ticket)
-        holder = find_binding(st, project=_project_id(st),
+        project = _project_id(st)
+        holder = find_binding(st, project=project,
                               provider=client.config.provider,
                               ticket_id=ticket.issue_id, part=part)
         if holder is not None:
@@ -1885,7 +1893,7 @@ def _tracker_link(args: argparse.Namespace) -> int:
         return 1
     existing = st.read_sidecar(args.slug, BINDING_SIDECAR)
     today = date.today().isoformat()
-    document = _binding_for(st, outcome, part, today,
+    document = _binding_for(client.config.provider, project, outcome, part, today,
                             unlinked_history(existing.content if existing else None))
     try:
         st.write_sidecar(args.slug, BINDING_SIDECAR, document, revision=revision or "")

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tcw_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tcw-cli
-Version: 2.1.2
+Version: 2.1.3
 Summary: Taxonomy · Capabilities · Work — a storage-abstracted framework for describing and evolving a software project.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -603,6 +603,32 @@ work:
 environment variables; TCW reads them at the moment it makes a request, so a token
 cannot be committed by accident.
 
+**Write the shared settings once.** In a workspace of connected nodes, a node's
+`tracker` block takes any setting it leaves out from its parent nodes, all the way
+up. So the site, credentials and claim transition can live in the workspace root,
+and each package writes only the tickets it wants to see:
+
+```yaml
+# packages/api/tcw-config.yaml
+work:
+    tracker:
+        candidate-query: project = EX AND component = api AND status = "To Do"
+```
+
+The nearest file wins each setting, and `credentials` and `transitions` merge
+setting by setting too. A node with no `tracker` block of its own has no tracker,
+whatever its parents say. Two rules keep this safe:
+
+- **`credentials` must sit beside `base-url`.** A node that sets its own `base-url`
+  must also set both of its own `credentials` keys, even if the address is the same
+  as its parent's, so a token is never sent to a site chosen in a different file.
+- **A node with its own board is checked like any tracking node.** If it holds the
+  shared settings, it needs a `candidate-query` of its own. Keeping shared settings
+  in a node without a board avoids that.
+
+A mistake in a parent's settings is reported by `tcw validate` in every node that
+inherits it, naming the parent's file.
+
 `tracker show` reports two different things, and the distinction matters:
 
 - **claimable** — whether this ticket currently offers the transition you
@@ -625,15 +651,17 @@ ticket's text goes into the item as its raw input, with a link back, and the ite
 request still gets written the usual way. A ticket assigned to someone else is
 refused, and so is one that is already closed.
 
-Running `import` again for the same ticket gives you the same item rather than a
-second one, and if the first run took the ticket but stopped before creating the
+Running `import` again for the same ticket in the same node gives you the same item
+rather than a second one, and if the first run took the ticket but stopped before creating the
 item, the second run finishes the job. One ticket can deliberately become several
 items with `--part api`, `--part web`, and so on. `unlink` removes a wrong binding
 and keeps a record of it with your reason; it never changes the ticket in Jira.
 
-Two limits to know. On a workflow that lets anyone start a ticket from any status,
-two people can both take the same ticket, and TCW does not stop that. And two runs
-by the same Jira account at the same moment can both create an item.
+Three limits to know. On a workflow that lets anyone start a ticket from any status,
+two people can both take the same ticket, and TCW does not stop that. Two runs by the
+same Jira account at the same moment can both create an item. And each node keeps its
+own bindings: importing one ticket in two nodes of a workspace, even nodes sharing
+inherited settings, gives two items, one in each.
 
 Two guarantees worth stating plainly. A project with no `tracker` block behaves
 exactly as before, with no new required setting and no network access. And

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tcw_cli.egg-info/SOURCES.txt

@@ -123,6 +123,7 @@ tests/test_tracker_cli.py
 tests/test_tracker_client.py
 tests/test_tracker_config.py
 tests/test_tracker_import.py
+tests/test_tracker_inheritance.py
 tests/test_tracker_link.py
 tests/test_tracker_replay.py
 tests/test_tracker_validate.py

{tcw_cli-2.1.2 → tcw_cli-2.1.3}/tests/test_tracker_import.py

@@ -352,3 +352,64 @@ def test_a_description_that_cannot_be_read_says_the_ticket_is_claimed(node, fake
     assert code == 1 and f"claimed {TICKET}" in err
     assert_no_item(node)
     _re_run_finishes(node, fake)
+
+
+# ── with tracker settings inherited from a parent node ──────────────────────
+
+
+def _inheriting_child(tmp_path: Path) -> tuple[Path, Path]:
+    """A root holding the whole tracker block, and a child holding only its query."""
+    root = make_node(tmp_path, "root", email_env="TCW_A_EMAIL")
+    child = make_node(tmp_path, "child", email_env=None)
+    root_cfg = yaml.safe_load((root / "tcw-config.yaml").read_text())
+    root_cfg["connected-projects"] = {"children": {"child": str(child)}}
+    (root / "tcw-config.yaml").write_text(yaml.safe_dump(root_cfg, sort_keys=False))
+    child_cfg = yaml.safe_load((child / "tcw-config.yaml").read_text())
+    child_cfg["connected-projects"] = {"parent": {"root": str(root)}}
+    child_cfg.setdefault("work", {})["tracker"] = {"candidate-query": "project = EX"}
+    (child / "tcw-config.yaml").write_text(yaml.safe_dump(child_cfg, sort_keys=False))
+    from tcw.store.project import FsProjectRegistry
+    assert FsProjectRegistry.open(child).check() == []
+    assert FsWorkStore.open(child).tracker_config() is not None
+    return root, child
+
+
+def _break_tracker_settings(root: Path):
+    def run():
+        cfg = yaml.safe_load((root / "tcw-config.yaml").read_text())
+        cfg["work"]["tracker"]["base-url"] = 42
+        (root / "tcw-config.yaml").write_text(yaml.safe_dump(cfg, sort_keys=False))
+    return run
+
+
+def test_import_from_an_inheriting_child_binds_with_the_childs_project(tmp_path, fake):
+    root, child = _inheriting_child(tmp_path)
+    code, out, err = run(child, "import", TICKET)
+    assert code == 0, err
+    (item,) = items(child)
+    assert binding(child, item.slug)["project"] == "child"
+    assert items(root) == []
+
+
+def test_import_binds_with_the_settings_it_claimed_with_if_a_parent_changes_meanwhile(
+        tmp_path, fake):
+    """The binding's provider comes from the client that made the claim. Re-reading
+    the settings after the claim returned None once a parent's file broke, and
+    `None.provider` escaped as a traceback, leaving an unbound item behind."""
+    root, child = _inheriting_child(tmp_path)
+    fake.before("POST", "/transitions", _break_tracker_settings(root))
+    code, out, err = run(child, "import", TICKET)
+    assert code == 0, err
+    assert "Traceback" not in err and "AttributeError" not in err
+    (item,) = items(child)
+    assert binding(child, item.slug)["provider"] == "jira-cloud"
+
+
+def test_link_binds_with_the_settings_it_claimed_with_if_a_parent_changes_meanwhile(
+        tmp_path, fake):
+    root, child = _inheriting_child(tmp_path)
+    slug = FsWorkStore.open(child).create("An existing item").slug
+    fake.before("POST", "/transitions", _break_tracker_settings(root))
+    code, out, err = run(child, "link", slug, TICKET)
+    assert code == 0, err
+    assert binding(child, slug)["provider"] == "jira-cloud"