imbi-plugin-github 2.26.0__tar.gz → 2.26.2__tar.gz

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: imbi-plugin-github
-Version: 2.26.0
+Version: 2.26.2
 Summary: GitHub identity plugin for Imbi (github.com / GHEC / GHES)
 Author-email: "Gavin M. Roy" <gavinr@aweber.com>
 License-Expression: BSD-3-Clause
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.14
 Requires-Dist: httpx>=0.27
-Requires-Dist: imbi-common[databases]==2.26.0
+Requires-Dist: imbi-common[databases]==2.26.2
 Requires-Dist: pydantic>=2
 Requires-Dist: pyjwt[crypto]>=2.8
 Description-Content-Type: text/markdown

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "imbi-plugin-github"
-version = "2.26.0"
+version = "2.26.2"
 description = "GitHub identity plugin for Imbi (github.com / GHEC / GHES)"
 readme = "README.md"
 requires-python = ">=3.14"
@@ -18,7 +18,7 @@ classifiers = [
 ]
 dependencies = [
   "httpx>=0.27",
-  "imbi-common[databases]==2.26.0",
+  "imbi-common[databases]==2.26.2",
   "pydantic>=2",
   "pyjwt[crypto]>=2.8",
 ]

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/src/imbi/plugins/github/_repos.py

@@ -10,10 +10,15 @@ plugin agrees on what counts as a "real" repo URL.
 
 from __future__ import annotations
 
+import dataclasses
+import logging
+import typing
 import urllib.parse
 
 from imbi.common.plugins.base import PluginContext
 
+LOGGER = logging.getLogger(__name__)
+
 # Reserved GitHub URL prefixes that share the host with repository URLs
 # but never point at a real ``<owner>/<repo>`` pair.  Any link whose
 # first path segment matches one of these is skipped during owner/repo
@@ -99,14 +104,31 @@ def derive_owner_repo_from_links(
     return None
 
 
-def resolve_owner_repo(
+@dataclasses.dataclass(frozen=True, slots=True)
+class RepositoryTarget:
+    """A resolved ``<owner>/<repo>`` plus where it came from.
+
+    Provenance matters wherever the answer is used to decide something
+    other than "which repo do I read".  A ``'link'`` owner is what Imbi
+    believes about this project and carries authority; a
+    ``'type_slug_fallback'`` owner is a naming convention that happens
+    to resolve, and carries none -- it is a project *type* slug being
+    read as a GitHub org, which is very often not one.
+    """
+
+    owner: str
+    repo: str
+    source: typing.Literal['link', 'type_slug_fallback']
+
+
+def resolve_repository_target(
     ctx: PluginContext,
     host: str,
     plugin_label: str,
     *,
     prefer_previous_slug: bool = False,
-) -> tuple[str, str]:
-    """Resolve the repo for a plugin call from ``ctx``.
+) -> RepositoryTarget:
+    """Resolve the repo for a plugin call from ``ctx``, with provenance.
 
     First tries the project links; falls back to
     ``<project_type_slug>/<project_slug>`` as a convention.  Raises
@@ -118,6 +140,12 @@ def resolve_owner_repo(
     ``ctx.previous_project_slug`` (when set) over ``ctx.project_slug``
     so callers reacting to a slug rename (e.g. ``on_project_updated``)
     can still locate the pre-rename repo on GitHub.
+
+    Every fallback resolution is logged.  The fallback is load-bearing
+    today -- commit sync, PR sync and deployments all lean on it for
+    projects that never had their repo link recorded (issue #254,
+    defect 3) -- so it cannot be removed until that population is known
+    to be empty, and the log is how that gets measured.
     """
     derived = derive_owner_repo_from_links(
         ctx.project_links,
@@ -125,15 +153,43 @@ def resolve_owner_repo(
         preferred_key=ctx.integration_slug,
     )
     if derived is not None:
-        return derived
+        return RepositoryTarget(derived[0], derived[1], 'link')
     if ctx.project_type_slugs:
         slug = ctx.project_slug
         if prefer_previous_slug and ctx.previous_project_slug:
             slug = ctx.previous_project_slug
         if slug:
-            return ctx.project_type_slugs[0], slug
+            owner = ctx.project_type_slugs[0]
+            LOGGER.info(
+                'Repo target for project %s resolved by project-type '
+                'fallback to %s/%s (caller=%s); the project has no '
+                'usable GitHub link',
+                ctx.project_id,
+                owner,
+                slug,
+                plugin_label,
+            )
+            return RepositoryTarget(owner, slug, 'type_slug_fallback')
     raise ValueError(
         f'{plugin_label} could not determine the target repository: '
         "set the project's GitHub Repository link or tag the project "
         'with a ProjectType'
     )
+
+
+def resolve_owner_repo(
+    ctx: PluginContext,
+    host: str,
+    plugin_label: str,
+    *,
+    prefer_previous_slug: bool = False,
+) -> tuple[str, str]:
+    """Resolve ``(owner, repo)`` for a plugin call from ``ctx``.
+
+    Provenance-free shorthand for :func:`resolve_repository_target`, for
+    the read paths that only need to know which repo to talk to.
+    """
+    target = resolve_repository_target(
+        ctx, host, plugin_label, prefer_previous_slug=prefer_previous_slug
+    )
+    return target.owner, target.repo

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/src/imbi/plugins/github/deployment.py

@@ -54,6 +54,7 @@ from imbi.common.plugins.base import (
     DeploymentEventStatus,
     DeploymentRun,
     LinkWriteback,
+    NotesListing,
     PluginContext,
     Ref,
     RefInfo,
@@ -906,6 +907,29 @@ class GitHubDeployment(DeploymentCapability):
                 return None
             return await self._blob_text(client, blob_sha)
 
+    async def list_commit_notes(
+        self,
+        ctx: PluginContext,
+        credentials: dict[str, str],
+        namespace: str,
+    ) -> NotesListing:
+        """Every note on ``refs/notes/<namespace>`` at its current tip.
+
+        Two Git Data calls to reach the tree, then one blob read per
+        note.  A missing ref answers an empty, complete listing.
+
+        ``complete`` compares what the tree holds against what came
+        back: :meth:`_all_notes` drops a note whose blob it cannot read
+        (logging why), and a truncated tree listing hides notes before
+        that.  Either way the caller must not treat the result as the
+        whole ref.
+        """
+        async with self._client(ctx, credentials) as client:
+            tip = await self._notes_ref_tip(client, namespace)
+            if tip is None:
+                return NotesListing({}, True)
+            return await self._all_notes(client, tip)
+
     async def diff_commit_notes(
         self,
         ctx: PluginContext,
@@ -934,14 +958,14 @@ class GitHubDeployment(DeploymentCapability):
         """
         async with self._client(ctx, credentials) as client:
             if before == _ZERO_SHA:
-                return await self._all_notes(client, after)
+                return (await self._all_notes(client, after)).notes
             quoted = urllib.parse.quote(f'{before}...{after}', safe='.')
             resp = await client.get(f'/compare/{quoted}')
             if resp.status_code == 404:
                 # ``before`` was garbage-collected or the ref history
                 # was rewritten; fall back to the full tree at ``after``
                 # so the push still lands rather than being dropped.
-                return await self._all_notes(client, after)
+                return (await self._all_notes(client, after)).notes
             resp.raise_for_status()
             payload = typing.cast('dict[str, typing.Any]', resp.json())
             files: list[dict[str, typing.Any]] = payload.get('files') or []
@@ -959,7 +983,7 @@ class GitHubDeployment(DeploymentCapability):
                     after,
                     _COMPARE_FILES_CAP,
                 )
-                return await self._all_notes(client, after)
+                return (await self._all_notes(client, after)).notes
             out: dict[str, str | None] = {}
             for item in files:
                 status = str(item.get('status') or '')
@@ -997,30 +1021,50 @@ class GitHubDeployment(DeploymentCapability):
                 out[annotated] = body
             return out
 
-    async def _notes_tree(
-        self, client: httpx.AsyncClient, namespace: str
-    ) -> dict[str, str] | None:
-        """Map annotated full SHA -> note blob SHA, or ``None`` sans ref."""
+    @staticmethod
+    async def _notes_ref_tip(
+        client: httpx.AsyncClient, namespace: str
+    ) -> str | None:
+        """The commit ``refs/notes/<namespace>`` points at, or ``None``."""
         ref = await client.get(
             f'/git/ref/{urllib.parse.quote(f"notes/{namespace}", safe="/")}'
         )
         if ref.status_code == 404:
             return None
         ref.raise_for_status()
-        tip = str(ref.json()['object']['sha'])
-        return await self._tree_notes(client, tip)
+        return str(ref.json()['object']['sha'])
+
+    async def _notes_tree(
+        self, client: httpx.AsyncClient, namespace: str
+    ) -> dict[str, str] | None:
+        """Map annotated full SHA -> note blob SHA, or ``None`` sans ref."""
+        tip = await self._notes_ref_tip(client, namespace)
+        if tip is None:
+            return None
+        # A truncated tree can only cost this caller a note it then
+        # reports as absent, which is already its answer for "no note".
+        notes, _complete = await self._tree_notes(client, tip)
+        return notes
 
     async def _tree_notes(
         self, client: httpx.AsyncClient, commit_sha: str
-    ) -> dict[str, str]:
-        """Flatten one notes-ref commit's tree to annotated SHA -> blob."""
+    ) -> tuple[dict[str, str], bool]:
+        """Flatten one notes-ref commit's tree to annotated SHA -> blob.
+
+        Also answers whether the tree listing was whole.  GitHub
+        truncates a large recursive tree, and the truncated map is
+        indistinguishable from a small complete one, so the flag has to
+        travel with it -- a caller that persists "backfill finished"
+        would otherwise do so over notes it never saw.
+        """
         commit = await client.get(f'/git/commits/{commit_sha}')
         commit.raise_for_status()
         tree_sha = str(commit.json()['tree']['sha'])
         tree = await client.get(f'/git/trees/{tree_sha}?recursive=1')
         tree.raise_for_status()
         payload = typing.cast('dict[str, typing.Any]', tree.json())
-        if payload.get('truncated'):
+        truncated = bool(payload.get('truncated'))
+        if truncated:
             LOGGER.warning(
                 'Notes tree %s is truncated; some notes will be missed',
                 tree_sha,
@@ -1033,18 +1077,22 @@ class GitHubDeployment(DeploymentCapability):
             annotated = _note_sha(entry.get('path'))
             if annotated is not None:
                 out[annotated] = str(entry['sha'])
-        return out
+        return out, not truncated
 
     async def _all_notes(
         self, client: httpx.AsyncClient, commit_sha: str
-    ) -> dict[str, str | None]:
+    ) -> NotesListing:
         """Every note at one notes-ref commit, bodies included.
 
         Blob reads run a few at a time (one request per note) and an
         unreadable note is skipped rather than failing the batch or
         recording a false "removed".
+
+        ``complete`` combines the two ways this can fall short: a
+        truncated tree listing, and a blob that would not read.  Either
+        means the map is not the whole ref.
         """
-        notes = await self._tree_notes(client, commit_sha)
+        notes, tree_complete = await self._tree_notes(client, commit_sha)
         gate = asyncio.Semaphore(_NOTE_BLOB_CONCURRENCY)
 
         async def _read(blob_sha: str) -> str | BaseException | None:
@@ -1072,7 +1120,7 @@ class GitHubDeployment(DeploymentCapability):
                 # a ``None`` here would read as "note removed".
                 continue
             out[annotated] = body
-        return out
+        return NotesListing(out, tree_complete and len(out) == len(notes))
 
     @staticmethod
     async def _blob_text(

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/src/imbi/plugins/github/lifecycle.py

@@ -60,8 +60,10 @@ from imbi.common.plugins.errors import PluginAuthenticationFailed
 from imbi.common.plugins.templates import expand_template
 from imbi.plugins.github._hosts import flavor_host, host_to_api_base
 from imbi.plugins.github._repos import (
+    RepositoryTarget,
     derive_owner_repo_from_links,
     resolve_owner_repo,
+    resolve_repository_target,
 )
 
 LOGGER = logging.getLogger(__name__)
@@ -79,6 +81,41 @@ _TRANSFER_ARCHIVE_BACKOFFS: tuple[float, ...] = (0.5, 1.0, 2.0)
 # is only meaningful on a GHEC tenant or GHES appliance.
 _VISIBILITIES = frozenset({'private', 'internal', 'public'})
 
+# Emitted identically by create and by the update-path upsert, so the
+# same misconfiguration reads the same way whichever event hit it.
+_NO_CREATE_ORG = (
+    'No target org configured for project creation; set the '
+    "plugin's create_org or org_mapping option"
+)
+
+# GitHub's cap on a repo description.  Imbi's own project description
+# field has no limit, and GitHub rejects the *whole* request when the
+# value is longer -- so an over-long description cost the repo entirely
+# until this was clamped (issue #254).
+_MAX_DESCRIPTION_CHARS = 350
+_DESCRIPTION_ELLIPSIS = '\u2026'
+
+
+def _normalize_description(value: str | None) -> str | None:
+    """Clamp a project description to GitHub's repo-description limit.
+
+    Truncates on a word boundary where one exists in the last word of
+    the budget, and marks the cut with an ellipsis.  Losing the tail is
+    acceptable because the full text stays in Imbi and the repo's
+    ``homepage`` links back to it; losing the repo is not.
+
+    ``None`` passes through unchanged so the caller can still tell
+    "unknown" from "empty" -- see :meth:`_patch_repo_attrs`.
+    """
+    if value is None or len(value) <= _MAX_DESCRIPTION_CHARS:
+        return value
+    budget = _MAX_DESCRIPTION_CHARS - len(_DESCRIPTION_ELLIPSIS)
+    candidate = value[:budget]
+    head, separator, _ = candidate.rpartition(' ')
+    if separator and head.strip():
+        candidate = head
+    return candidate.rstrip() + _DESCRIPTION_ELLIPSIS
+
 
 def _error_detail(response: httpx.Response) -> str:
     """Flatten a GitHub error body into one operator-facing string.
@@ -249,13 +286,7 @@ class GitHubLifecycle(LifecycleCapability):
     ) -> LifecycleResult:
         target_org = self._resolve_create_org(ctx)
         if not target_org:
-            return LifecycleResult(
-                status='skipped',
-                message=(
-                    'No target org configured for project creation; set '
-                    "the plugin's ``create_org`` or ``org_mapping`` option"
-                ),
-            )
+            return LifecycleResult(status='skipped', message=_NO_CREATE_ORG)
         host = self._resolve_host(ctx)
         async with self._client(ctx, credentials) as client:
             existing = await self._get_repo_or_none(
@@ -294,54 +325,135 @@ class GitHubLifecycle(LifecycleCapability):
         host = self._resolve_host(ctx)
         # ``prefer_previous_slug`` so a slug rename still locates the
         # pre-rename repo on GitHub when the project has no stored link.
-        owner, repo = resolve_owner_repo(
-            ctx,
-            host,
-            'GitHub lifecycle plugin',
-            prefer_previous_slug=True,
-        )
+        try:
+            target = resolve_repository_target(
+                ctx,
+                host,
+                'GitHub lifecycle plugin',
+                prefer_previous_slug=True,
+            )
+        except ValueError:
+            # No link and no project type: there is nothing to look up,
+            # so provisioning from configuration is the only action left.
+            # This is the state a project whose first repository creation
+            # failed is left in when it carries no ProjectType either --
+            # the very case ``POST /lifecycle/sync`` has to repair
+            # (issue #254, defect 2).
+            target = None
         async with self._client(ctx, credentials) as client:
-            current = await self._get_repo(client, owner, repo)
-            current_owner = self._current_owner(current, owner)
-            current_repo = self._current_repo(current, repo)
-            # Surface an external rename even when there's nothing else
-            # to do, so the host can self-heal the link.
-            self._maybe_report_relocation(
-                ctx, host, current, owner, repo, current_owner, current_repo
+            if target is None:
+                return await self._provision_missing(ctx, client, host, None)
+            # ``_get_repo_or_none`` rather than ``_get_repo``: a genuine
+            # 404 means the remote is missing and this call provisions
+            # it, while every other status still raises so an auth or
+            # permission failure can't be mistaken for absence.
+            current = await self._get_repo_or_none(
+                client, target.owner, target.repo
             )
+            if current is None:
+                return await self._provision_missing(ctx, client, host, target)
+            current_owner = self._current_owner(current, target.owner)
+            current_repo = self._current_repo(current, target.repo)
             patched = await self._patch_repo_attrs(
                 client,
                 current_owner,
                 current_repo,
                 name=ctx.project_slug,
-                description=ctx.project_description or '',
-                homepage=ctx.project_ui_url or '',
+                description=ctx.project_description,
+                homepage=ctx.project_ui_url,
             )
             new_repo = str(patched.get('name') or current_repo)
-            # If the patch itself renamed the repo (we asked GitHub to
-            # set ``name`` to a new slug), record the writeback even when
-            # the external-rename check above didn't.
-            if new_repo != current_repo:
-                new_url = self._record_repo(
-                    ctx,
-                    host,
-                    current_owner,
-                    new_repo,
-                    patched,
-                    old_owner_repo=f'{current_owner}/{current_repo}',
-                    new_owner_repo=f'{current_owner}/{new_repo}',
-                )
-            else:
-                new_url = str(
-                    patched.get('html_url')
-                    or self._repo_html_url(host, current_owner, new_repo)
-                )
+            # Record on every success, not only on a rename.  Recording
+            # is idempotent, and skipping it on the ordinary path left
+            # the ``EXISTS_IN`` edge and the repo link permanently
+            # unwritten for any project not provisioned by
+            # ``on_project_created`` (issue #254, defect 3).
+            #
+            # One call, so the rename provenance can't be clobbered by a
+            # second: ``old`` is what Imbi believed, which covers both a
+            # rename we asked for and one that happened outside Imbi.
+            old_owner_repo = f'{target.owner}/{target.repo}'
+            new_owner_repo = f'{current_owner}/{new_repo}'
+            renamed = new_owner_repo.lower() != old_owner_repo.lower()
+            new_url = self._record_repo(
+                ctx,
+                host,
+                current_owner,
+                new_repo,
+                patched,
+                old_owner_repo=old_owner_repo if renamed else None,
+                new_owner_repo=new_owner_repo if renamed else None,
+            )
         return LifecycleResult(
             status='ok',
             message=f'Updated {current_owner}/{new_repo}',
             artifacts={'repo_url': new_url},
         )
 
+    async def _provision_missing(
+        self,
+        ctx: PluginContext,
+        client: httpx.AsyncClient,
+        host: str,
+        target: RepositoryTarget | None,
+    ) -> LifecycleResult:
+        """Create the repo an update found missing, or refuse to.
+
+        ``on_project_created`` is dispatched from exactly one place -- the
+        project-create endpoint -- so a project whose creation failed had
+        no API-driven way back: every later update 404'd and never
+        created (issue #254, defect 2).  An update is the only event that
+        can repair it, which is what ``POST /lifecycle/sync`` documents.
+
+        The creation org comes from ``create_org`` / ``org_mapping``, the
+        same resolver ``on_project_created`` uses, and from nowhere else.
+        In particular never from ``target.owner`` on the fallback path:
+        that owner is a project-type slug read as a GitHub org, so
+        provisioning there would invent a repo in an org nobody
+        configured.
+
+        A stored link that disagrees with the configured org is refused
+        rather than reconciled.  Creating at the new org while the link
+        still names the old one is an org migration, which needs to be
+        someone's decision -- and silently making it would leave a
+        duplicate repo behind with automation still pointed at the
+        original.  The comparison folds case, as every other org
+        comparison here does, because GitHub org names are
+        case-insensitive: ``Aweber-APIs`` and ``aweber-apis`` are one
+        org, not a migration.
+
+        ``target`` is ``None`` when nothing resolved at all -- no link
+        and no project type.  There is no stored belief to disagree
+        with, so the org check has nothing to check.
+        """
+        create_org = self._resolve_create_org(ctx)
+        if not create_org:
+            return LifecycleResult(status='skipped', message=_NO_CREATE_ORG)
+        if (
+            target is not None
+            and target.source == 'link'
+            and target.owner.lower() != create_org.lower()
+        ):
+            return LifecycleResult(
+                status='failed',
+                message=(
+                    f'Repository link points at {target.owner}/'
+                    f'{target.repo}, which does not exist, but '
+                    f'provisioning resolves to {create_org}. Refusing '
+                    'to create: changing orgs is a migration and needs '
+                    'to be done deliberately.'
+                ),
+            )
+        created = await self._create_repo(client, create_org, ctx)
+        html_url = self._record_repo(
+            ctx, host, create_org, ctx.project_slug, created
+        )
+        return LifecycleResult(
+            status='ok',
+            message=f'Created {create_org}/{ctx.project_slug}',
+            artifacts={'repo_url': html_url},
+        )
+
     async def on_project_deleted(
         self,
         ctx: PluginContext,
@@ -663,8 +775,13 @@ class GitHubLifecycle(LifecycleCapability):
     ) -> dict[str, typing.Any] | None:
         """Read a repo, returning ``None`` on 404 instead of raising.
 
-        Used by :meth:`on_project_created` for the idempotency check —
-        any other status is treated as a real failure and re-raised.
+        Only a genuine 404 answers ``None``; any other status is a real
+        failure and is re-raised, so "cannot see it" is never mistaken
+        for "it is not there".  Three callers depend on that:
+        :meth:`on_project_created` for its idempotency check,
+        :meth:`on_project_updated` to detect a remote it must
+        provision, and :meth:`_create_repo` to reconcile a 422 that
+        turns out to be a create race.
         """
         resp = await client.get(f'/repos/{owner}/{repo}')
         if resp.status_code == 404:
@@ -683,7 +800,8 @@ class GitHubLifecycle(LifecycleCapability):
             f'/orgs/{org}/repos',
             json={
                 'name': ctx.project_slug,
-                'description': ctx.project_description or '',
+                'description': _normalize_description(ctx.project_description)
+                or '',
                 'homepage': ctx.project_ui_url or '',
                 # ``visibility`` is authoritative where it's supported;
                 # ``private`` rides along so a host that only honors the
@@ -693,6 +811,18 @@ class GitHubLifecycle(LifecycleCapability):
                 'private': visibility != 'public',
             },
         )
+        if resp.status_code == 422:
+            # 422 covers every validation failure, "name already exists"
+            # among them -- so ask about this exact repo instead of
+            # pattern-matching the message.  A repo created between the
+            # caller's 404 and this POST is reconciled rather than
+            # reported as a failure; anything else falls through to the
+            # error below with GitHub's own reason intact.
+            existing = await self._get_repo_or_none(
+                client, org, ctx.project_slug
+            )
+            if existing is not None:
+                return existing
         try:
             resp.raise_for_status()
         except httpx.HTTPStatusError as exc:
@@ -712,23 +842,29 @@ class GitHubLifecycle(LifecycleCapability):
         repo: str,
         *,
         name: str,
-        description: str,
-        homepage: str,
+        description: str | None,
+        homepage: str | None,
     ) -> dict[str, typing.Any]:
         """Sync name / description / homepage via a single PATCH.
 
         One call covers all three sync fields so an update that touches
         several is still a single GitHub round trip.  ``raise_for_status``
         on any non-2xx so the dispatcher captures the failure.
+
+        ``None`` means "the caller doesn't know this value" and omits the
+        key, so a dispatch path that never populated
+        ``ctx.project_description`` leaves the repo's own description
+        alone instead of clearing it.  An empty string still rides
+        along, because that is a deliberate clear.  The description is
+        clamped here rather than at the call site so create and update
+        cannot disagree about the limit.
         """
-        resp = await client.patch(
-            f'/repos/{owner}/{repo}',
-            json={
-                'name': name,
-                'description': description,
-                'homepage': homepage,
-            },
-        )
+        payload: dict[str, typing.Any] = {'name': name}
+        if description is not None:
+            payload['description'] = _normalize_description(description)
+        if homepage is not None:
+            payload['homepage'] = homepage
+        resp = await client.patch(f'/repos/{owner}/{repo}', json=payload)
         resp.raise_for_status()
         return typing.cast(dict[str, typing.Any], resp.json())
 

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/tests/test_deployment.py

@@ -3015,6 +3015,96 @@ class GitNotesTestCase(unittest.IsolatedAsyncioTestCase):
             )
         self.assertEqual({other_sha: '{"drift_detected":false}'}, changed)
 
+    @respx.mock
+    async def test_list_commit_notes_reads_the_whole_ref(self) -> None:
+        fanout = f'{self.FULL_SHA[:2]}/{self.FULL_SHA[2:]}'
+        self._mock_tree(
+            [
+                {'type': 'blob', 'path': fanout, 'sha': 'b1'},
+                {'type': 'tree', 'path': 'ab', 'sha': 'sub'},
+            ]
+        )
+        self._blob('b1', '{"drift_detected":true}')
+        listing = await self.handler.list_commit_notes(
+            _ctx(), _CREDS, 'imbi-drift'
+        )
+        # Fan-out subtree flattened back to the annotated full SHA.
+        self.assertEqual(
+            {self.FULL_SHA: '{"drift_detected":true}'}, listing.notes
+        )
+        self.assertTrue(listing.complete)
+
+    @respx.mock
+    async def test_list_commit_notes_reports_an_unreadable_blob(self) -> None:
+        # The readable note still comes back, but the listing says it is
+        # not the whole ref, so a caller cannot record a finished
+        # backfill over a note it never saw.
+        other_sha = 'e' * 40
+        self._mock_tree(
+            [
+                {'type': 'blob', 'path': self.FULL_SHA, 'sha': 'bad'},
+                {'type': 'blob', 'path': other_sha, 'sha': 'b2'},
+            ]
+        )
+        respx.get(f'{self.REPO}/git/blobs/bad').mock(
+            return_value=httpx.Response(500)
+        )
+        self._blob('b2', '{"drift_detected":false}')
+        with self.assertLogs('imbi.plugins.github', level='WARNING'):
+            listing = await self.handler.list_commit_notes(
+                _ctx(), _CREDS, 'imbi-drift'
+            )
+        self.assertEqual(
+            {other_sha: '{"drift_detected":false}'}, listing.notes
+        )
+        self.assertFalse(listing.complete)
+
+    @respx.mock
+    async def test_list_commit_notes_reports_a_truncated_tree(self) -> None:
+        # Every note in the (partial) tree read fine, so blob-read
+        # completeness alone would call this whole. The tree itself says
+        # otherwise.
+        respx.get(f'{self.REPO}/git/ref/notes/imbi-drift').mock(
+            return_value=httpx.Response(
+                200, json={'object': {'sha': 'notes-tip'}}
+            )
+        )
+        respx.get(f'{self.REPO}/git/commits/notes-tip').mock(
+            return_value=httpx.Response(200, json={'tree': {'sha': 't1'}})
+        )
+        respx.get(f'{self.REPO}/git/trees/t1').mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'tree': [
+                        {'type': 'blob', 'path': self.FULL_SHA, 'sha': 'b1'}
+                    ],
+                    'truncated': True,
+                },
+            )
+        )
+        self._blob('b1', '{"drift_detected":true}')
+        with self.assertLogs('imbi.plugins.github', level='WARNING'):
+            listing = await self.handler.list_commit_notes(
+                _ctx(), _CREDS, 'imbi-drift'
+            )
+        self.assertEqual(
+            {self.FULL_SHA: '{"drift_detected":true}'}, listing.notes
+        )
+        self.assertFalse(listing.complete)
+
+    @respx.mock
+    async def test_list_commit_notes_without_the_ref_is_empty(self) -> None:
+        respx.get(f'{self.REPO}/git/ref/notes/imbi-drift').mock(
+            return_value=httpx.Response(404)
+        )
+        listing = await self.handler.list_commit_notes(
+            _ctx(), _CREDS, 'imbi-drift'
+        )
+        # Empty but complete: "no notes" is the whole truth here.
+        self.assertEqual({}, listing.notes)
+        self.assertTrue(listing.complete)
+
     @respx.mock
     async def test_diff_commit_notes_zero_before_lists_everything(
         self,

{imbi_plugin_github-2.26.0 → imbi_plugin_github-2.26.2}/tests/test_lifecycle.py

@@ -19,7 +19,11 @@ from imbi.common.plugins.base import (
     PluginContext,
 )
 from imbi.common.plugins.errors import PluginAuthenticationFailed
-from imbi.plugins.github.lifecycle import GitHubLifecycle
+from imbi.plugins.github.lifecycle import (
+    _MAX_DESCRIPTION_CHARS,
+    GitHubLifecycle,
+    _normalize_description,
+)
 from imbi.plugins.github.plugin import GitHubPlugin
 
 
@@ -1169,7 +1173,82 @@ class UpdateTestCase(unittest.IsolatedAsyncioTestCase):
         self.assertIn(
             b'"homepage":"https://imbi.example.com/projects/p"', body
         )
-        self.assertIsNone(ctx.link_writeback)
+        # Recorded even though nothing was renamed -- this assertion
+        # used to require the opposite, which is what left the repo link
+        # unwritten on the ordinary path (issue #254, defect 3).
+        assert ctx.link_writeback is not None
+        self.assertEqual(
+            ctx.link_writeback.new_url, 'https://github.com/octo/demo'
+        )
+        self.assertIsNone(ctx.link_writeback.old_owner_repo)
+
+    @respx.mock
+    async def test_update_omits_unknown_description_and_homepage(
+        self,
+    ) -> None:
+        # The ``/lifecycle/sync`` dispatch path leaves
+        # ``project_description`` / ``project_ui_url`` unpopulated.  An
+        # unknown value must be absent from the PATCH body -- sending
+        # ``""`` would wipe whatever the repo had (issue #254, defect 4).
+        respx.get('https://api.github.com/repos/octo/demo').mock(
+            return_value=httpx.Response(
+                200,
+                json={'name': 'demo', 'owner': {'login': 'octo'}},
+            )
+        )
+        patch_route = respx.patch(
+            'https://api.github.com/repos/octo/demo'
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo',
+                    'html_url': 'https://github.com/octo/demo',
+                    'owner': {'login': 'octo'},
+                },
+            )
+        )
+
+        ctx = _ctx(project_description=None, project_ui_url=None)
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        body = json.loads(patch_route.calls.last.request.read())
+        self.assertEqual(body, {'name': 'demo'})
+
+    @respx.mock
+    async def test_update_sends_empty_description_when_cleared(self) -> None:
+        # An explicit empty string is a deliberate clear and must still
+        # reach GitHub -- only ``None`` (unknown) is omitted.
+        respx.get('https://api.github.com/repos/octo/demo').mock(
+            return_value=httpx.Response(
+                200,
+                json={'name': 'demo', 'owner': {'login': 'octo'}},
+            )
+        )
+        patch_route = respx.patch(
+            'https://api.github.com/repos/octo/demo'
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo',
+                    'html_url': 'https://github.com/octo/demo',
+                    'owner': {'login': 'octo'},
+                },
+            )
+        )
+
+        ctx = _ctx(project_description='', project_ui_url='')
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        body = json.loads(patch_route.calls.last.request.read())
+        self.assertEqual(
+            body, {'name': 'demo', 'description': '', 'homepage': ''}
+        )
 
     @respx.mock
     async def test_update_records_writeback_when_slug_changes(self) -> None:
@@ -1381,3 +1460,390 @@ class ResolveRelocationTargetTestCase(unittest.IsolatedAsyncioTestCase):
         plugin = GitHubLifecycle()
         target = await plugin.resolve_relocation_target(ctx, _CREDS)
         self.assertIsNone(target)
+
+
+class NormalizeDescriptionTestCase(unittest.TestCase):
+    """``_normalize_description`` clamps to GitHub's 350-char cap."""
+
+    def test_none_passes_through(self) -> None:
+        # ``None`` is "unknown", not "empty" -- collapsing the two is
+        # what wiped repo descriptions in issue #254.
+        self.assertIsNone(_normalize_description(None))
+
+    def test_empty_string_passes_through(self) -> None:
+        self.assertEqual(_normalize_description(''), '')
+
+    def test_exactly_at_the_limit_is_untouched(self) -> None:
+        value = 'a' * _MAX_DESCRIPTION_CHARS
+        self.assertEqual(_normalize_description(value), value)
+
+    def test_one_over_the_limit_is_clamped(self) -> None:
+        value = 'a' * (_MAX_DESCRIPTION_CHARS + 1)
+        result = _normalize_description(value)
+        assert result is not None
+        self.assertEqual(len(result), _MAX_DESCRIPTION_CHARS)
+        self.assertTrue(result.endswith('\u2026'))
+
+    def test_clamps_on_a_word_boundary(self) -> None:
+        value = ('word ' * 100).strip()
+        result = _normalize_description(value)
+        assert result is not None
+        self.assertLessEqual(len(result), _MAX_DESCRIPTION_CHARS)
+        self.assertTrue(result.endswith('word\u2026'))
+        self.assertNotIn('wor\u2026', result)
+
+    def test_single_token_longer_than_the_limit_is_hard_cut(self) -> None:
+        # No space to break on, so the ellipsis lands mid-token rather
+        # than the function returning nothing.
+        value = 'x' * 500
+        result = _normalize_description(value)
+        self.assertEqual(result, 'x' * (_MAX_DESCRIPTION_CHARS - 1) + '\u2026')
+
+    def test_counts_characters_not_bytes(self) -> None:
+        # GitHub's limit is on characters; a multi-byte description at
+        # the limit must survive untouched.
+        value = '\u00e9' * _MAX_DESCRIPTION_CHARS
+        self.assertEqual(_normalize_description(value), value)
+
+    def test_strips_whitespace_before_the_ellipsis(self) -> None:
+        value = 'a' * 340 + '          ' + 'b' * 50
+        result = _normalize_description(value)
+        assert result is not None
+        self.assertEqual(result, 'a' * 340 + '\u2026')
+
+
+class DescriptionClampTestCase(unittest.IsolatedAsyncioTestCase):
+    """Both the create and the update path clamp the description."""
+
+    @respx.mock
+    async def test_create_clamps_an_over_long_description(self) -> None:
+        # An 817-char description used to fail the whole POST with
+        # "description cannot be more than 350 characters", costing the
+        # repo over a cosmetic field (issue #254, defect 1).
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(
+            return_value=httpx.Response(
+                201,
+                json={
+                    'id': 42,
+                    'name': 'demo',
+                    'html_url': 'https://github.com/aweber-apis/demo',
+                    'owner': {'login': 'aweber-apis'},
+                },
+            )
+        )
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            return_value=httpx.Response(404)
+        )
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={},
+            project_description='word ' * 200,
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_created(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        body = json.loads(create_route.calls.last.request.read())
+        self.assertLessEqual(len(body['description']), _MAX_DESCRIPTION_CHARS)
+        self.assertTrue(body['description'].endswith('\u2026'))
+
+    @respx.mock
+    async def test_update_clamps_an_over_long_description(self) -> None:
+        respx.get('https://api.github.com/repos/octo/demo').mock(
+            return_value=httpx.Response(
+                200,
+                json={'name': 'demo', 'owner': {'login': 'octo'}},
+            )
+        )
+        patch_route = respx.patch(
+            'https://api.github.com/repos/octo/demo'
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo',
+                    'html_url': 'https://github.com/octo/demo',
+                    'owner': {'login': 'octo'},
+                },
+            )
+        )
+
+        ctx = _ctx(project_description='word ' * 200)
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        body = json.loads(patch_route.calls.last.request.read())
+        self.assertLessEqual(len(body['description']), _MAX_DESCRIPTION_CHARS)
+
+
+class UpdateUpsertTestCase(unittest.IsolatedAsyncioTestCase):
+    """``on_project_updated`` provisions a repo it finds missing.
+
+    ``on_project_created`` is reachable only from the project-create
+    endpoint, so before this an update was the sole event that could
+    repair a failed creation -- and it 404'd instead (issue #254,
+    defect 2).
+    """
+
+    @staticmethod
+    def _created_response() -> httpx.Response:
+        return httpx.Response(
+            201,
+            json={
+                'id': 7,
+                'name': 'demo',
+                'html_url': 'https://github.com/aweber-apis/demo',
+                'owner': {'login': 'aweber-apis'},
+            },
+        )
+
+    @respx.mock
+    async def test_creates_when_the_repo_is_missing(self) -> None:
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            return_value=httpx.Response(404)
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(return_value=self._created_response())
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={
+                'github-repository': 'https://github.com/aweber-apis/demo'
+            },
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(create_route.calls.call_count, 1)
+        self.assertEqual(
+            result.artifacts['repo_url'],
+            'https://github.com/aweber-apis/demo',
+        )
+        self.assertIsNotNone(ctx.link_writeback)
+
+    @respx.mock
+    async def test_refuses_when_the_link_disagrees_with_the_org(
+        self,
+    ) -> None:
+        # Creating at the configured org while the link still names the
+        # old one is an org migration, not a sync.
+        respx.get('https://api.github.com/repos/old-org/demo').mock(
+            return_value=httpx.Response(404)
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/new-org/repos'
+        ).mock(return_value=self._created_response())
+
+        ctx = _ctx(
+            options={'create_org': 'new-org'},
+            project_links={
+                'github-repository': 'https://github.com/old-org/demo'
+            },
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'failed')
+        self.assertEqual(create_route.calls.call_count, 0)
+        assert result.message is not None
+        self.assertIn('old-org/demo', result.message)
+        self.assertIn('new-org', result.message)
+
+    @respx.mock
+    async def test_creates_at_the_configured_org_not_the_type_slug(
+        self,
+    ) -> None:
+        # With no link the lookup owner is a *project type* slug read as
+        # a GitHub org.  It has no authority, so it must not veto
+        # provisioning -- and must not be provisioned into either.
+        respx.get('https://api.github.com/repos/api-service/demo').mock(
+            return_value=httpx.Response(404)
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(return_value=self._created_response())
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(create_route.calls.call_count, 1)
+        # The type slug was read once, to look for the repo, and never
+        # used as a creation target.
+        self.assertEqual(
+            [
+                call.request.url.path
+                for call in respx.calls
+                if 'api-service' in call.request.url.path
+            ],
+            ['/repos/api-service/demo'],
+        )
+
+    @respx.mock
+    async def test_creates_when_nothing_resolves_at_all(self) -> None:
+        # No usable link and no project type, so there is no repo to
+        # look up at all.  This is where a failed first creation leaves
+        # an untyped project, and the sync has to repair it rather than
+        # report failed on an unresolvable target.
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(return_value=self._created_response())
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={},
+            project_type_slugs=[],
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(create_route.calls.call_count, 1)
+        # Nothing was looked up, because there was no candidate to look
+        # up -- not a 404 that happened to be tolerated.
+        self.assertEqual(
+            [
+                call.request.method
+                for call in respx.calls
+                if call.request.method == 'GET'
+            ],
+            [],
+        )
+        self.assertIsNotNone(ctx.link_writeback)
+
+    @respx.mock
+    async def test_org_comparison_folds_case(self) -> None:
+        # GitHub org names are case-insensitive, so a link recording
+        # ``Aweber-APIs`` against a ``aweber-apis`` config names one org,
+        # not a migration to refuse.
+        respx.get('https://api.github.com/repos/Aweber-APIs/demo').mock(
+            return_value=httpx.Response(404)
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(return_value=self._created_response())
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={
+                'github-repository': 'https://github.com/Aweber-APIs/demo'
+            },
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(create_route.calls.call_count, 1)
+
+    @respx.mock
+    async def test_skips_when_no_org_is_configured(self) -> None:
+        respx.get('https://api.github.com/repos/octo/demo').mock(
+            return_value=httpx.Response(404)
+        )
+
+        ctx = _ctx(options={})
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        # Same status and message ``on_project_created`` gives, so one
+        # misconfiguration cannot read two ways.
+        self.assertEqual(result.status, 'skipped')
+        created = await plugin.on_project_created(_ctx(options={}), _CREDS)
+        self.assertEqual(result.message, created.message)
+
+    @respx.mock
+    async def test_non_404_lookup_does_not_provision(self) -> None:
+        # A 403 means "cannot see it", not "it is not there".
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            return_value=httpx.Response(403, json={'message': 'nope'})
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(return_value=self._created_response())
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={
+                'github-repository': 'https://github.com/aweber-apis/demo'
+            },
+        )
+        plugin = GitHubLifecycle()
+        with self.assertRaises(httpx.HTTPStatusError):
+            await plugin.on_project_updated(ctx, _CREDS)
+        self.assertEqual(create_route.calls.call_count, 0)
+
+    @respx.mock
+    async def test_reconciles_a_create_race(self) -> None:
+        # Someone created the repo between the 404 and the POST.  GitHub
+        # answers 422; the repo is adopted rather than reported failed.
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            side_effect=[
+                httpx.Response(404),
+                httpx.Response(
+                    200,
+                    json={
+                        'id': 9,
+                        'name': 'demo',
+                        'html_url': 'https://github.com/aweber-apis/demo',
+                        'owner': {'login': 'aweber-apis'},
+                    },
+                ),
+            ]
+        )
+        respx.post('https://api.github.com/orgs/aweber-apis/repos').mock(
+            return_value=httpx.Response(
+                422, json={'message': 'Repository creation failed.'}
+            )
+        )
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={
+                'github-repository': 'https://github.com/aweber-apis/demo'
+            },
+        )
+        plugin = GitHubLifecycle()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(
+            result.artifacts['repo_url'],
+            'https://github.com/aweber-apis/demo',
+        )
+
+    @respx.mock
+    async def test_a_real_422_still_fails(self) -> None:
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            return_value=httpx.Response(404)
+        )
+        respx.post('https://api.github.com/orgs/aweber-apis/repos').mock(
+            return_value=httpx.Response(
+                422,
+                json={
+                    'message': 'Repository creation failed.',
+                    'errors': [{'message': 'name is invalid'}],
+                },
+            )
+        )
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-apis'},
+            project_links={
+                'github-repository': 'https://github.com/aweber-apis/demo'
+            },
+        )
+        plugin = GitHubLifecycle()
+        with self.assertRaises(RuntimeError) as caught:
+            await plugin.on_project_updated(ctx, _CREDS)
+        self.assertIn('name is invalid', str(caught.exception))