imbi-plugin-github 1.5.0__tar.gz → 2.8.0__tar.gz

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imbi-plugin-github
-Version: 1.5.0
+Version: 2.8.0
 Summary: GitHub identity plugin for Imbi (github.com / GHEC / GHES)
 Author-email: "Gavin M. Roy" <gavinr@aweber.com>
 License: BSD-3-Clause
@@ -13,7 +13,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>=2.7.0
+Requires-Dist: imbi-common==2.8.0
 Requires-Dist: pydantic>=2
 Description-Content-Type: text/markdown
 

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "imbi-plugin-github"
-version = "1.5.0"
+version = "2.8.0"
 description = "GitHub identity plugin for Imbi (github.com / GHEC / GHES)"
 readme = "README.md"
 requires-python = ">=3.14"
@@ -16,7 +16,7 @@ classifiers = [
 ]
 dependencies = [
   "httpx>=0.27",
-  "imbi-common>=2.7.0",
+  "imbi-common==2.8.0",
   "pydantic>=2",
 ]
 
@@ -35,7 +35,7 @@ github-lifecycle-es = "imbi_plugin_github.lifecycle:GitHubEnterpriseServerLifecy
 dev = [
   "basedpyright",
   "coverage[toml]",
-  "imbi-common[server,databases]",
+  "imbi-common[server,databases]==2.8.0",
   "pre-commit",
   "pytest",
   "pytest-asyncio",

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/src/imbi_plugin_github/_repos.py

@@ -91,7 +91,11 @@ def derive_owner_repo_from_links(
 
 
 def resolve_owner_repo(
-    ctx: PluginContext, host: str, plugin_label: str
+    ctx: PluginContext,
+    host: str,
+    plugin_label: str,
+    *,
+    prefer_previous_slug: bool = False,
 ) -> tuple[str, str]:
     """Resolve the repo for a plugin call from ``ctx``.
 
@@ -100,12 +104,21 @@ def resolve_owner_repo(
     :class:`ValueError` when neither path produces a candidate so the
     caller can surface a clear "set the GitHub Repository link"
     message to the operator.
+
+    ``prefer_previous_slug`` makes the slug fallback prefer
+    ``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.
     """
     derived = derive_owner_repo_from_links(ctx.project_links, host)
     if derived is not None:
         return derived
-    if ctx.project_type_slugs and ctx.project_slug:
-        return ctx.project_type_slugs[0], ctx.project_slug
+    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
     raise ValueError(
         f'{plugin_label} could not determine the target repository: '
         "set the project's GitHub Repository link or tag the project "

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/src/imbi_plugin_github/deployment.py

@@ -42,6 +42,7 @@ from imbi_common.plugins.base import (
     DeploymentEventStatus,
     DeploymentPlugin,
     DeploymentRun,
+    LinkWriteback,
     OpsLogTemplate,
     PluginContext,
     PluginEdgeLabel,
@@ -51,7 +52,6 @@ from imbi_common.plugins.base import (
     RefInfo,
     ReleaseInfo,
     RemoteDeployment,
-    RepositoryRelocation,
     WorkflowFile,
 )
 from imbi_common.plugins.errors import PluginAuthenticationFailed
@@ -356,8 +356,8 @@ class _DeploymentBase(DeploymentPlugin):
         ``raise_for_status``.  A response hook records that redirect; once
         the caller's request succeeds we resolve the repo's new
         ``full_name``/``html_url`` and stash a
-        :class:`~imbi_common.plugins.base.RepositoryRelocation` on ``ctx``
-        so the host can self-heal the project's stored link.  This is the
+        :class:`~imbi_common.plugins.base.LinkWriteback` on ``ctx`` so the
+        host can persist the project's updated stored link.  This is the
         single chokepoint for every deployment call.
         """
         captured: list[str] = []
@@ -380,7 +380,7 @@ class _DeploymentBase(DeploymentPlugin):
             # Only after the caller's request succeeded: a captured
             # redirect means the repo was renamed out from under the
             # stored link.  Resolve the new name once and report it.
-            if captured and ctx.repository_relocation is None:
+            if captured and ctx.link_writeback is None:
                 await self._record_relocation(client, ctx, captured[-1])
 
     async def _record_relocation(
@@ -392,7 +392,7 @@ class _DeploymentBase(DeploymentPlugin):
         """Resolve a renamed repo's canonical name and stash it on ``ctx``.
 
         Best-effort: any failure to resolve the repo root leaves
-        ``ctx.repository_relocation`` unset so the user-facing call (which
+        ``ctx.link_writeback`` unset so the user-facing call (which
         already succeeded via the followed redirect) is never disturbed.
         """
         repo_root = _repo_root_from_redirect(redirect_location)
@@ -419,7 +419,7 @@ class _DeploymentBase(DeploymentPlugin):
         old_owner_repo = f'{old_owner}/{old_repo}'
         if full_name.lower() == old_owner_repo.lower():
             return
-        ctx.repository_relocation = RepositoryRelocation(
+        ctx.link_writeback = LinkWriteback(
             link_key='github-repository',
             new_url=html_url,
             old_owner_repo=old_owner_repo,

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/src/imbi_plugin_github/lifecycle.py

@@ -54,15 +54,20 @@ from imbi_common.plugins.base import (
     CredentialField,
     LifecyclePlugin,
     LifecycleResult,
+    LinkWriteback,
     PluginContext,
     PluginManifest,
     PluginOption,
-    RepositoryRelocation,
+    RelocationTarget,
 )
 from imbi_common.plugins.errors import PluginAuthenticationFailed
+from imbi_common.plugins.templates import expand_template
 
 from imbi_plugin_github._hosts import normalize_host, require_ghec_tenant_host
-from imbi_plugin_github._repos import resolve_owner_repo
+from imbi_plugin_github._repos import (
+    derive_owner_repo_from_links,
+    resolve_owner_repo,
+)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -150,6 +155,249 @@ class _LifecycleBase(LifecyclePlugin):
             return raw.strip()
         return None
 
+    @staticmethod
+    def _resolve_create_org(ctx: PluginContext) -> str | None:
+        """Resolve the GitHub org for create / relocate from plugin options.
+
+        Checks ``org_mapping`` (project-type-slug → org) first so per-type
+        overrides win, then falls back to the ``create_org`` template.
+        Returns ``None`` when neither is configured so the caller can
+        emit a clean ``status='skipped'``.
+        """
+        options = ctx.assignment_options
+        mapping_raw = options.get('org_mapping')
+        if isinstance(mapping_raw, dict):
+            mapping = typing.cast(dict[str, typing.Any], mapping_raw)
+            for pt_slug in ctx.project_type_slugs:
+                if pt_slug in mapping:
+                    value = mapping[pt_slug]
+                    if isinstance(value, str) and value.strip():
+                        return value.strip()
+        template = options.get('create_org')
+        if isinstance(template, str) and template.strip():
+            first_type_slug = (
+                ctx.project_type_slugs[0] if ctx.project_type_slugs else None
+            )
+            expanded = expand_template(
+                template,
+                {
+                    'project_slug': ctx.project_slug,
+                    'org_slug': ctx.org_slug,
+                    'team_slug': ctx.team_slug,
+                    'project_type_slug': first_type_slug,
+                    'project_id': ctx.project_id,
+                },
+            ).strip()
+            return expanded or None
+        return None
+
+    async def on_project_created(
+        self,
+        ctx: PluginContext,
+        credentials: dict[str, str],
+    ) -> 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"
+                ),
+            )
+        host = self._resolve_host(ctx.assignment_options)
+        async with self._client(ctx, credentials) as client:
+            existing = await self._get_repo_or_none(
+                client, target_org, ctx.project_slug
+            )
+            if existing is not None:
+                # Already provisioned (e.g. retry after a partial failure):
+                # adopt the existing repo's URL via a link writeback so the
+                # operator can wire it up without a second attempt.
+                html_url = str(
+                    existing.get('html_url')
+                    or self._repo_html_url(host, target_org, ctx.project_slug)
+                )
+                ctx.link_writeback = LinkWriteback(
+                    link_key='github-repository',
+                    new_url=html_url,
+                )
+                return LifecycleResult(
+                    status='skipped',
+                    message=(
+                        f'Repository {target_org}/{ctx.project_slug} '
+                        'already exists'
+                    ),
+                    artifacts={'repo_url': html_url},
+                )
+            created = await self._create_repo(client, target_org, ctx)
+            html_url = str(
+                created.get('html_url')
+                or self._repo_html_url(host, target_org, ctx.project_slug)
+            )
+            ctx.link_writeback = LinkWriteback(
+                link_key='github-repository',
+                new_url=html_url,
+            )
+        return LifecycleResult(
+            status='ok',
+            message=f'Created {target_org}/{ctx.project_slug}',
+            artifacts={'repo_url': html_url},
+        )
+
+    async def on_project_updated(
+        self,
+        ctx: PluginContext,
+        credentials: dict[str, str],
+    ) -> LifecycleResult:
+        host = self._resolve_host(ctx.assignment_options)
+        # ``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,
+        )
+        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
+            )
+            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 '',
+            )
+            new_repo = str(patched.get('name') or current_repo)
+            new_url = str(
+                patched.get('html_url')
+                or self._repo_html_url(host, current_owner, new_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:
+                ctx.link_writeback = LinkWriteback(
+                    link_key='github-repository',
+                    new_url=new_url,
+                    old_owner_repo=f'{current_owner}/{current_repo}',
+                    new_owner_repo=f'{current_owner}/{new_repo}',
+                )
+        return LifecycleResult(
+            status='ok',
+            message=f'Updated {current_owner}/{new_repo}',
+            artifacts={'repo_url': new_url},
+        )
+
+    async def on_project_deleted(
+        self,
+        ctx: PluginContext,
+        credentials: dict[str, str],
+    ) -> LifecycleResult:
+        host = self._resolve_host(ctx.assignment_options)
+        try:
+            owner, repo = resolve_owner_repo(
+                ctx, host, 'GitHub lifecycle plugin'
+            )
+        except ValueError as exc:
+            return LifecycleResult(status='skipped', message=str(exc))
+        async with self._client(ctx, credentials) as client:
+            resp = await client.delete(f'/repos/{owner}/{repo}')
+            if resp.status_code == 404:
+                return LifecycleResult(
+                    status='skipped',
+                    message=f'Repository {owner}/{repo} already gone',
+                )
+            resp.raise_for_status()
+        return LifecycleResult(
+            status='ok',
+            message=f'Deleted {owner}/{repo}',
+        )
+
+    async def on_project_relocated(
+        self,
+        ctx: PluginContext,
+        credentials: dict[str, str],
+    ) -> LifecycleResult:
+        host = self._resolve_host(ctx.assignment_options)
+        target = await self.resolve_relocation_target(ctx, credentials)
+        if target is None:
+            return LifecycleResult(
+                status='skipped',
+                message='No relocation target resolved',
+            )
+        try:
+            new_owner, _new_repo_hint = target.identifier.split('/', 1)
+        except ValueError:
+            return LifecycleResult(
+                status='failed',
+                message=(
+                    f'Malformed relocation identifier {target.identifier!r};'
+                    ' expected ``<owner>/<repo>``'
+                ),
+            )
+        try:
+            owner, repo = resolve_owner_repo(
+                ctx, host, 'GitHub lifecycle plugin'
+            )
+        except ValueError as exc:
+            return LifecycleResult(status='skipped', message=str(exc))
+        if owner.lower() == new_owner.lower():
+            return LifecycleResult(
+                status='skipped',
+                message=(
+                    f'Repository {owner}/{repo} is already at the '
+                    f'target org {new_owner}'
+                ),
+            )
+        async with self._client(ctx, credentials) as client:
+            transferred = await self._transfer(client, owner, repo, new_owner)
+            final_repo = str(transferred.get('name') or repo)
+            html_url = str(
+                transferred.get('html_url')
+                or self._repo_html_url(host, new_owner, final_repo)
+            )
+            ctx.link_writeback = LinkWriteback(
+                link_key='github-repository',
+                new_url=html_url,
+                old_owner_repo=f'{owner}/{repo}',
+                new_owner_repo=f'{new_owner}/{final_repo}',
+            )
+        return LifecycleResult(
+            status='ok',
+            message=f'Transferred to {new_owner}/{final_repo}',
+            artifacts={'repo_url': html_url},
+        )
+
+    async def resolve_relocation_target(
+        self,
+        ctx: PluginContext,
+        credentials: dict[str, str],
+    ) -> RelocationTarget | None:
+        del credentials  # resolution is local; never hits the remote.
+        target_org = self._resolve_create_org(ctx)
+        if not target_org:
+            return None
+        host = self._resolve_host(ctx.assignment_options)
+        # Prefer the canonical repo name from a stored link; fall back to
+        # project_slug so a preview before any link exists still resolves.
+        derived = derive_owner_repo_from_links(ctx.project_links, host)
+        repo_name = derived[1] if derived is not None else ctx.project_slug
+        identifier = f'{target_org}/{repo_name}'
+        return RelocationTarget(
+            link_key='github-repository',
+            identifier=identifier,
+            display=identifier,
+        )
+
     async def on_project_archived(
         self,
         ctx: PluginContext,
@@ -288,13 +536,13 @@ class _LifecycleBase(LifecyclePlugin):
         current_owner: str,
         current_repo: str,
     ) -> None:
-        """Record a relocation when the repo moved out from under the link.
+        """Record a link writeback when the repo moved out from under the link.
 
         Compares the link-derived ``<owner>/<repo>`` against the repo's
         canonical name from ``payload``.  When they differ the repo was
         renamed (or its owner renamed) outside Imbi, so stash a
-        :class:`RepositoryRelocation` on ``ctx`` for the host to self-heal
-        the stored link.  No-op when they match.
+        :class:`LinkWriteback` on ``ctx`` for the host to persist the
+        new link.  No-op when they match.
         """
         old_owner_repo = f'{link_owner}/{link_repo}'
         new_owner_repo = f'{current_owner}/{current_repo}'
@@ -306,7 +554,7 @@ class _LifecycleBase(LifecyclePlugin):
             if isinstance(html_url, str) and html_url
             else self._repo_html_url(host, current_owner, current_repo)
         )
-        ctx.repository_relocation = RepositoryRelocation(
+        ctx.link_writeback = LinkWriteback(
             link_key='github-repository',
             new_url=new_url,
             old_owner_repo=old_owner_repo,
@@ -324,6 +572,64 @@ class _LifecycleBase(LifecyclePlugin):
         resp.raise_for_status()
         return typing.cast(dict[str, typing.Any], resp.json())
 
+    async def _get_repo_or_none(
+        self, client: httpx.AsyncClient, owner: str, repo: str
+    ) -> 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.
+        """
+        resp = await client.get(f'/repos/{owner}/{repo}')
+        if resp.status_code == 404:
+            return None
+        resp.raise_for_status()
+        return typing.cast(dict[str, typing.Any], resp.json())
+
+    async def _create_repo(
+        self,
+        client: httpx.AsyncClient,
+        org: str,
+        ctx: PluginContext,
+    ) -> dict[str, typing.Any]:
+        resp = await client.post(
+            f'/orgs/{org}/repos',
+            json={
+                'name': ctx.project_slug,
+                'description': ctx.project_description or '',
+                'homepage': ctx.project_ui_url or '',
+            },
+        )
+        resp.raise_for_status()
+        return typing.cast(dict[str, typing.Any], resp.json())
+
+    async def _patch_repo_attrs(
+        self,
+        client: httpx.AsyncClient,
+        owner: str,
+        repo: str,
+        *,
+        name: str,
+        description: str,
+        homepage: str,
+    ) -> 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.
+        """
+        resp = await client.patch(
+            f'/repos/{owner}/{repo}',
+            json={
+                'name': name,
+                'description': description,
+                'homepage': homepage,
+            },
+        )
+        resp.raise_for_status()
+        return typing.cast(dict[str, typing.Any], resp.json())
+
     async def _set_archived(
         self,
         client: httpx.AsyncClient,
@@ -397,8 +703,49 @@ _COMMON_OPTIONS: list[PluginOption] = [
         type='string',
         required=False,
     ),
+    PluginOption(
+        name='create_org',
+        label='Default org for repo creation',
+        description=(
+            'Org used by ``on_project_created`` (and the relocate-target '
+            'preview) when no per-project-type override matches in '
+            '``org_mapping``.  Supports the template variables '
+            '``${project_slug}``, ``${org_slug}``, ``${team_slug}``, '
+            '``${project_type_slug}``, ``${project_id}``.  Leave blank '
+            'to skip create / relocate when no mapping matches.'
+        ),
+        type='string',
+        required=False,
+    ),
+    PluginOption(
+        name='org_mapping',
+        label='Project-type to org overrides',
+        description=(
+            'Per-project-type-slug overrides for the target GitHub org.  '
+            'The first ``project_type_slug`` that has a mapping wins '
+            'over ``create_org``.  Use this when different project types '
+            'live in different orgs (e.g. ``api`` → ``aweber-services``, '
+            '``library`` → ``aweber-libs``).'
+        ),
+        type='mapping',
+        required=False,
+    ),
 ]
 
+# Lifecycle events every GitHub lifecycle variant supports.  Shared
+# across the three host flavors -- they inherit the same ``_LifecycleBase``
+# implementation, so their capability lists are identical.
+_COMMON_LIFECYCLE_EVENTS: list[
+    typing.Literal[
+        'created',
+        'updated',
+        'archived',
+        'unarchived',
+        'deleted',
+        'relocated',
+    ]
+] = ['created', 'updated', 'archived', 'unarchived', 'deleted', 'relocated']
+
 _COMMON_CREDENTIALS: list[CredentialField] = [
     CredentialField(
         name='access_token',
@@ -418,15 +765,15 @@ class GitHubLifecyclePlugin(_LifecycleBase):
         slug='github-lifecycle',
         name='GitHub Lifecycle',
         description=(
-            'React to project archive / unarchive on github.com by '
-            'archiving (or unarchiving) the matching repository.  '
-            'Optionally transfers the repo to a sunset organization '
-            'before archiving so retired projects do not crowd primary '
-            'org searches.'
+            'React to the project lifecycle on github.com by creating, '
+            'renaming, archiving, transferring, or deleting the matching '
+            'repository.  Org selection on create / relocate is driven '
+            'by per-project-type overrides plus a template fallback.'
         ),
         plugin_type='lifecycle',
         options=_COMMON_OPTIONS,
         credentials=_COMMON_CREDENTIALS,
+        lifecycle_events=_COMMON_LIFECYCLE_EVENTS,
     )
 
     @classmethod
@@ -440,9 +787,9 @@ class GitHubEnterpriseCloudLifecyclePlugin(_LifecycleBase):
         slug='github-lifecycle-ec',
         name='GitHub Enterprise Cloud Lifecycle',
         description=(
-            'React to project archive / unarchive on a GHEC tenant '
-            '(``*.ghe.com``) by archiving (or unarchiving) the matching '
-            'repository; optional transfer to a sunset org first.'
+            'React to the project lifecycle on a GHEC tenant '
+            '(``*.ghe.com``) by creating, renaming, archiving, '
+            'transferring, or deleting the matching repository.'
         ),
         plugin_type='lifecycle',
         options=[
@@ -456,6 +803,7 @@ class GitHubEnterpriseCloudLifecyclePlugin(_LifecycleBase):
             *_COMMON_OPTIONS,
         ],
         credentials=_COMMON_CREDENTIALS,
+        lifecycle_events=_COMMON_LIFECYCLE_EVENTS,
     )
 
     @classmethod
@@ -471,9 +819,9 @@ class GitHubEnterpriseServerLifecyclePlugin(_LifecycleBase):
         slug='github-lifecycle-es',
         name='GitHub Enterprise Server Lifecycle',
         description=(
-            'React to project archive / unarchive on a GHES install by '
-            'archiving (or unarchiving) the matching repository; '
-            'optional transfer to a sunset org first.'
+            'React to the project lifecycle on a GHES install by '
+            'creating, renaming, archiving, transferring, or deleting '
+            'the matching repository.'
         ),
         plugin_type='lifecycle',
         options=[
@@ -486,6 +834,7 @@ class GitHubEnterpriseServerLifecyclePlugin(_LifecycleBase):
             *_COMMON_OPTIONS,
         ],
         credentials=_COMMON_CREDENTIALS,
+        lifecycle_events=_COMMON_LIFECYCLE_EVENTS,
     )
 
     @classmethod

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/tests/test_deployment.py

@@ -1403,7 +1403,7 @@ class RepoRenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(len(commits), 1)
         self.assertEqual(commits[0].sha, 'abc')
         # ...and the rename is reported for the host to self-heal.
-        reloc = ctx.repository_relocation
+        reloc = ctx.link_writeback
         assert reloc is not None
         self.assertEqual(reloc.link_key, 'github-repository')
         self.assertEqual(reloc.new_url, 'https://github.com/octo/renamed')
@@ -1432,7 +1432,7 @@ class RepoRenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         ctx = _ctx()
         plugin = GitHubDeploymentPlugin()
         await plugin.list_commits(ctx, _CREDS, ref='main')
-        self.assertIsNone(ctx.repository_relocation)
+        self.assertIsNone(ctx.link_writeback)
 
     @respx.mock
     async def test_no_relocation_when_repo_root_unresolvable(self) -> None:
@@ -1445,7 +1445,7 @@ class RepoRenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         plugin = GitHubDeploymentPlugin()
         commits = await plugin.list_commits(ctx, _CREDS, ref='main')
         self.assertEqual(len(commits), 1)
-        self.assertIsNone(ctx.repository_relocation)
+        self.assertIsNone(ctx.link_writeback)
 
     @respx.mock
     async def test_no_relocation_when_name_unchanged(self) -> None:
@@ -1464,4 +1464,4 @@ class RepoRenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         ctx = _ctx()
         plugin = GitHubDeploymentPlugin()
         await plugin.list_commits(ctx, _CREDS, ref='main')
-        self.assertIsNone(ctx.repository_relocation)
+        self.assertIsNone(ctx.link_writeback)

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/tests/test_lifecycle.py

@@ -29,10 +29,16 @@ def _ctx(
     options: dict[str, object] | None = None,
     project_links: dict[str, str] | None = None,
     project_type_slugs: list[str] | None = None,
+    *,
+    project_slug: str = 'demo',
+    previous_project_slug: str | None = None,
+    project_name: str | None = None,
+    project_description: str | None = None,
+    project_ui_url: str | None = None,
 ) -> PluginContext:
     return PluginContext(
         project_id='p',
-        project_slug='demo',
+        project_slug=project_slug,
         org_slug='octo',
         assignment_options=options or {},
         actor_user_id='u-1',
@@ -42,6 +48,10 @@ def _ctx(
             else {'github-repository': 'https://github.com/octo/demo'}
         ),
         project_type_slugs=project_type_slugs or [],
+        previous_project_slug=previous_project_slug,
+        project_name=project_name,
+        project_description=project_description,
+        project_ui_url=project_ui_url,
     )
 
 
@@ -82,6 +92,39 @@ class ManifestTestCase(unittest.TestCase):
             names = {opt.name for opt in cls.manifest.options}
             self.assertIn('archive_target_org', names)
 
+    def test_create_org_and_org_mapping_options(self) -> None:
+        # Every flavor advertises the new ``create_org`` + ``org_mapping``
+        # options so the admin UI can render them without per-host casing.
+        for cls in (
+            GitHubLifecyclePlugin,
+            GitHubEnterpriseCloudLifecyclePlugin,
+            GitHubEnterpriseServerLifecyclePlugin,
+        ):
+            opts = {opt.name: opt for opt in cls.manifest.options}
+            self.assertIn('create_org', opts)
+            self.assertEqual(opts['create_org'].type, 'string')
+            self.assertIn('org_mapping', opts)
+            self.assertEqual(opts['org_mapping'].type, 'mapping')
+
+    def test_lifecycle_events_includes_all_supported(self) -> None:
+        # ``lifecycle_events`` drives UI affordance gating (e.g. the
+        # "Also delete the repository" checkbox); every flavor must
+        # advertise the full set the plugin implements.
+        expected = {
+            'created',
+            'updated',
+            'archived',
+            'unarchived',
+            'deleted',
+            'relocated',
+        }
+        for cls in (
+            GitHubLifecyclePlugin,
+            GitHubEnterpriseCloudLifecyclePlugin,
+            GitHubEnterpriseServerLifecyclePlugin,
+        ):
+            self.assertEqual(set(cls.manifest.lifecycle_events), expected)
+
 
 class ArchiveTestCase(unittest.IsolatedAsyncioTestCase):
     @respx.mock
@@ -604,7 +647,7 @@ class RenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(
             result.artifacts['repo_url'], 'https://github.com/octo/renamed'
         )
-        reloc = ctx.repository_relocation
+        reloc = ctx.link_writeback
         assert reloc is not None
         self.assertEqual(reloc.link_key, 'github-repository')
         self.assertEqual(reloc.new_url, 'https://github.com/octo/renamed')
@@ -644,7 +687,7 @@ class RenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(result.status, 'ok')
         self.assertEqual(patch_route.calls.call_count, 1)
-        reloc = ctx.repository_relocation
+        reloc = ctx.link_writeback
         assert reloc is not None
         self.assertEqual(reloc.new_owner_repo, 'octo/renamed')
 
@@ -703,7 +746,7 @@ class RenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         ctx = _ctx()
         plugin = GitHubLifecyclePlugin()
         await plugin.on_project_archived(ctx, _CREDS)
-        self.assertIsNone(ctx.repository_relocation)
+        self.assertIsNone(ctx.link_writeback)
 
     @respx.mock
     async def test_intentional_transfer_is_not_reported_as_relocation(
@@ -732,4 +775,385 @@ class RenameRelocationTestCase(unittest.IsolatedAsyncioTestCase):
         plugin = GitHubLifecyclePlugin()
         result = await plugin.on_project_archived(ctx, _CREDS)
         self.assertEqual(result.status, 'ok')
-        self.assertIsNone(ctx.repository_relocation)
+        self.assertIsNone(ctx.link_writeback)
+
+
+class CreateTestCase(unittest.IsolatedAsyncioTestCase):
+    """``on_project_created`` provisions the repo and writes the link."""
+
+    @respx.mock
+    async def test_create_happy_path_uses_org_mapping(self) -> None:
+        # Project-type mapping wins over ``create_org``; the repo is
+        # created at the mapped org and the link writeback carries the
+        # canonical ``html_url`` GitHub returned.
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            return_value=httpx.Response(404, json={'message': 'Not Found'})
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(
+            return_value=httpx.Response(
+                201,
+                json={
+                    'name': 'demo',
+                    'html_url': 'https://github.com/aweber-apis/demo',
+                    'owner': {'login': 'aweber-apis'},
+                },
+            )
+        )
+
+        ctx = _ctx(
+            options={
+                'create_org': 'fallback',
+                'org_mapping': {'api-service': 'aweber-apis'},
+            },
+            project_links={},
+            project_type_slugs=['api-service'],
+            project_description='An example API',
+            project_ui_url='https://imbi.example.com/projects/p',
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_created(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(create_route.calls.call_count, 1)
+        self.assertEqual(
+            create_route.calls.last.request.read(),
+            b'{"name":"demo","description":"An example API",'
+            b'"homepage":"https://imbi.example.com/projects/p"}',
+        )
+        self.assertIsNotNone(ctx.link_writeback)
+        assert ctx.link_writeback is not None
+        self.assertEqual(ctx.link_writeback.link_key, 'github-repository')
+        self.assertEqual(
+            ctx.link_writeback.new_url,
+            'https://github.com/aweber-apis/demo',
+        )
+
+    @respx.mock
+    async def test_create_falls_back_to_template(self) -> None:
+        # No mapping match → expand the ``create_org`` template.
+        respx.get('https://api.github.com/repos/aweber-api-service/demo').mock(
+            return_value=httpx.Response(404, json={'message': 'Not Found'})
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-api-service/repos'
+        ).mock(
+            return_value=httpx.Response(
+                201,
+                json={
+                    'name': 'demo',
+                    'html_url': ('https://github.com/aweber-api-service/demo'),
+                },
+            )
+        )
+
+        ctx = _ctx(
+            options={'create_org': 'aweber-${project_type_slug}'},
+            project_links={},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_created(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(create_route.calls.call_count, 1)
+
+    async def test_create_skips_when_no_target_org_configured(self) -> None:
+        # Neither mapping nor template -> clean skip rather than HTTP.
+        ctx = _ctx(
+            options={},
+            project_links={},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_created(ctx, _CREDS)
+        self.assertEqual(result.status, 'skipped')
+        self.assertIn('No target org', result.message or '')
+        self.assertIsNone(ctx.link_writeback)
+
+    @respx.mock
+    async def test_create_idempotent_when_repo_exists(self) -> None:
+        # Re-running a create for a repo that already exists adopts the
+        # existing URL via a link writeback and reports ``skipped``.
+        respx.get('https://api.github.com/repos/aweber-apis/demo').mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo',
+                    'html_url': 'https://github.com/aweber-apis/demo',
+                    'owner': {'login': 'aweber-apis'},
+                },
+            )
+        )
+        create_route = respx.post(
+            'https://api.github.com/orgs/aweber-apis/repos'
+        ).mock(return_value=httpx.Response(201, json={}))
+
+        ctx = _ctx(
+            options={'org_mapping': {'api-service': 'aweber-apis'}},
+            project_links={},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_created(ctx, _CREDS)
+        self.assertEqual(result.status, 'skipped')
+        self.assertIn('already exists', result.message or '')
+        self.assertEqual(create_route.calls.call_count, 0)
+        self.assertIsNotNone(ctx.link_writeback)
+
+
+class UpdateTestCase(unittest.IsolatedAsyncioTestCase):
+    """``on_project_updated`` syncs slug/description/homepage to the repo."""
+
+    @respx.mock
+    async def test_update_syncs_all_three_fields_in_one_patch(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='New description',
+            project_ui_url='https://imbi.example.com/projects/p',
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(patch_route.calls.call_count, 1)
+        body = patch_route.calls.last.request.read()
+        self.assertIn(b'"name":"demo"', body)
+        self.assertIn(b'"description":"New description"', body)
+        self.assertIn(
+            b'"homepage":"https://imbi.example.com/projects/p"', body
+        )
+        self.assertIsNone(ctx.link_writeback)
+
+    @respx.mock
+    async def test_update_records_writeback_when_slug_changes(self) -> None:
+        # A slug rename PATCHes ``name`` to the new value; the response
+        # carries the new ``html_url`` and the plugin stashes the
+        # writeback for the host to persist.
+        respx.get('https://api.github.com/repos/octo/demo-old').mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo-old',
+                    'owner': {'login': 'octo'},
+                },
+            )
+        )
+        respx.patch('https://api.github.com/repos/octo/demo-old').mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo-new',
+                    'html_url': 'https://github.com/octo/demo-new',
+                    'owner': {'login': 'octo'},
+                },
+            )
+        )
+
+        ctx = _ctx(
+            project_slug='demo-new',
+            previous_project_slug='demo-old',
+            project_links={
+                'github-repository': 'https://github.com/octo/demo-old',
+            },
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertIsNotNone(ctx.link_writeback)
+        assert ctx.link_writeback is not None
+        self.assertEqual(
+            ctx.link_writeback.new_url,
+            'https://github.com/octo/demo-new',
+        )
+        self.assertEqual(ctx.link_writeback.old_owner_repo, 'octo/demo-old')
+        self.assertEqual(ctx.link_writeback.new_owner_repo, 'octo/demo-new')
+
+    @respx.mock
+    async def test_update_falls_back_to_previous_slug_without_link(
+        self,
+    ) -> None:
+        # No stored link → resolve from ``<project_type_slug>/<previous_slug>``
+        # so a slug-rename still finds the pre-rename repo on GitHub.
+        respx.get('https://api.github.com/repos/api-service/demo-old').mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo-old',
+                    'owner': {'login': 'api-service'},
+                },
+            )
+        )
+        respx.patch('https://api.github.com/repos/api-service/demo-old').mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    'name': 'demo-new',
+                    'html_url': ('https://github.com/api-service/demo-new'),
+                },
+            )
+        )
+
+        ctx = _ctx(
+            project_slug='demo-new',
+            previous_project_slug='demo-old',
+            project_links={},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_updated(ctx, _CREDS)
+        self.assertEqual(result.status, 'ok')
+
+
+class DeleteTestCase(unittest.IsolatedAsyncioTestCase):
+    """``on_project_deleted`` removes the backing repository."""
+
+    @respx.mock
+    async def test_delete_happy_path(self) -> None:
+        delete_route = respx.delete(
+            'https://api.github.com/repos/octo/demo'
+        ).mock(return_value=httpx.Response(204))
+
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_deleted(_ctx(), _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(delete_route.calls.call_count, 1)
+
+    @respx.mock
+    async def test_delete_already_gone_is_skipped(self) -> None:
+        respx.delete('https://api.github.com/repos/octo/demo').mock(
+            return_value=httpx.Response(404, json={'message': 'Not Found'})
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_deleted(_ctx(), _CREDS)
+        self.assertEqual(result.status, 'skipped')
+        self.assertIn('already gone', result.message or '')
+
+    async def test_delete_without_resolvable_repo_is_skipped(self) -> None:
+        # No link, no project type → clean skip (rather than a hard
+        # failure) since there's nothing to act on.
+        ctx = _ctx(project_links={}, project_type_slugs=[])
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_deleted(ctx, _CREDS)
+        self.assertEqual(result.status, 'skipped')
+
+
+class RelocateTestCase(unittest.IsolatedAsyncioTestCase):
+    """``on_project_relocated`` transfers the repo to the resolved org."""
+
+    @respx.mock
+    async def test_relocate_transfers_repo_and_records_writeback(
+        self,
+    ) -> None:
+        transfer_route = respx.post(
+            'https://api.github.com/repos/octo/demo/transfer'
+        ).mock(
+            return_value=httpx.Response(
+                202,
+                json={
+                    'name': 'demo',
+                    'html_url': 'https://github.com/aweber-apis/demo',
+                    'owner': {'login': 'aweber-apis'},
+                },
+            )
+        )
+
+        ctx = _ctx(
+            options={'org_mapping': {'api-service': 'aweber-apis'}},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_relocated(ctx, _CREDS)
+
+        self.assertEqual(result.status, 'ok')
+        self.assertEqual(transfer_route.calls.call_count, 1)
+        self.assertEqual(
+            transfer_route.calls.last.request.read(),
+            b'{"new_owner":"aweber-apis"}',
+        )
+        self.assertIsNotNone(ctx.link_writeback)
+        assert ctx.link_writeback is not None
+        self.assertEqual(
+            ctx.link_writeback.new_url,
+            'https://github.com/aweber-apis/demo',
+        )
+        self.assertEqual(ctx.link_writeback.old_owner_repo, 'octo/demo')
+        self.assertEqual(ctx.link_writeback.new_owner_repo, 'aweber-apis/demo')
+
+    async def test_relocate_skips_when_no_target_resolved(self) -> None:
+        ctx = _ctx(options={}, project_type_slugs=['api-service'])
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_relocated(ctx, _CREDS)
+        self.assertEqual(result.status, 'skipped')
+        self.assertIn('No relocation target', result.message or '')
+
+    async def test_relocate_skips_when_already_at_target(self) -> None:
+        # Current owner == target org → no transfer, clean skip.
+        ctx = _ctx(
+            options={'org_mapping': {'api-service': 'octo'}},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        result = await plugin.on_project_relocated(ctx, _CREDS)
+        self.assertEqual(result.status, 'skipped')
+        self.assertIn('already at the target', result.message or '')
+
+
+class ResolveRelocationTargetTestCase(unittest.IsolatedAsyncioTestCase):
+    """``resolve_relocation_target`` derives the target locally."""
+
+    async def test_returns_target_from_mapping(self) -> None:
+        ctx = _ctx(
+            options={'org_mapping': {'api-service': 'aweber-apis'}},
+            project_type_slugs=['api-service'],
+        )
+        plugin = GitHubLifecyclePlugin()
+        target = await plugin.resolve_relocation_target(ctx, _CREDS)
+        self.assertIsNotNone(target)
+        assert target is not None
+        self.assertEqual(target.link_key, 'github-repository')
+        self.assertEqual(target.identifier, 'aweber-apis/demo')
+
+    async def test_returns_target_from_template_when_mapping_misses(
+        self,
+    ) -> None:
+        ctx = _ctx(
+            options={'create_org': 'aweber-${project_type_slug}'},
+            project_type_slugs=['api-service'],
+            project_links={},
+        )
+        plugin = GitHubLifecyclePlugin()
+        target = await plugin.resolve_relocation_target(ctx, _CREDS)
+        self.assertIsNotNone(target)
+        assert target is not None
+        self.assertEqual(target.identifier, 'aweber-api-service/demo')
+
+    async def test_returns_none_when_no_org_configured(self) -> None:
+        ctx = _ctx(options={}, project_type_slugs=['api-service'])
+        plugin = GitHubLifecyclePlugin()
+        target = await plugin.resolve_relocation_target(ctx, _CREDS)
+        self.assertIsNone(target)

{imbi_plugin_github-1.5.0 → imbi_plugin_github-2.8.0}/uv.lock

@@ -667,7 +667,7 @@ wheels = [
 
 [[package]]
 name = "imbi-common"
-version = "2.7.0"
+version = "2.8.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
   { name = "cryptography" },
@@ -683,9 +683,9 @@ dependencies = [
   { name = "python-slugify" },
   { name = "typer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/4b/b0/5f28ac0670d239c885822e5a7c9a94b2bb9c1ea205dccba82ac2ae36f329/imbi_common-2.7.0.tar.gz", hash = "sha256:723d2a7ecffef3f0cf86828173586a9721931b95068718c7b0c7cff768c7f764", size = 303583, upload-time = "2026-05-28T12:56:17.525Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/97/bc/d530fb11a6cc77b6fb9205824f90ffd61a9e177e5521547e8f56d625cb67/imbi_common-2.8.0.tar.gz", hash = "sha256:064407290a832f73e6ae2830f6802268f41a4ce65a68fb5f51c18cc45e966c70", size = 329556, upload-time = "2026-05-29T23:58:54.186Z" }
 wheels = [
-  { url = "https://files.pythonhosted.org/packages/ce/33/e801c0e9d7ecfef434ca1f178291584f4dce1e55f34590c9425c2086c4f6/imbi_common-2.7.0-py3-none-any.whl", hash = "sha256:c475153119376753d5f09b18de686eb872464625fdaf073aa893fec38b3956ab", size = 98903, upload-time = "2026-05-28T12:56:16.147Z" },
+  { url = "https://files.pythonhosted.org/packages/7f/3f/eb691a100829dff13f58c56a38bcd8c48ec83dd4a8270aca97da63b5a604/imbi_common-2.8.0-py3-none-any.whl", hash = "sha256:30cdb1aa1666f39a36eee9cc2285891650eb2340fcf184c26ed34c115695608d", size = 105139, upload-time = "2026-05-29T23:58:52.578Z" },
 ]
 
 [package.optional-dependencies]
@@ -703,7 +703,7 @@ server = [
 
 [[package]]
 name = "imbi-plugin-github"
-version = "1.5.0"
+version = "2.8.0"
 source = { editable = "." }
 dependencies = [
   { name = "httpx" },
@@ -731,7 +731,7 @@ dist = [
 [package.metadata]
 requires-dist = [
   { name = "httpx", specifier = ">=0.27" },
-  { name = "imbi-common", specifier = ">=2.7.0" },
+  { name = "imbi-common", specifier = "==2.8.0" },
   { name = "pydantic", specifier = ">=2" },
 ]
 
@@ -739,7 +739,7 @@ requires-dist = [
 dev = [
   { name = "basedpyright" },
   { name = "coverage", extras = ["toml"] },
-  { name = "imbi-common", extras = ["server", "databases"] },
+  { name = "imbi-common", extras = ["server", "databases"], specifier = "==2.8.0" },
   { name = "pre-commit" },
   { name = "pytest" },
   { name = "pytest-asyncio" },