sqlmesh 0.199.1.dev1__tar.gz → 0.199.1.dev3__tar.gz

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.199.1.dev1
+Version: 0.199.1.dev3
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.199.1.dev1'
-__version_tuple__ = version_tuple = (0, 199, 1, 'dev1')
+__version__ = version = '0.199.1.dev3'
+__version_tuple__ = version_tuple = (0, 199, 1, 'dev3')

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/sqlmesh/core/console.py

@@ -3224,8 +3224,9 @@ class MarkdownConsole(CaptureTerminalConsole):
             )
         else:
             for snapshot_table_info in models:
+                category_str = SNAPSHOT_CHANGE_CATEGORY_STR[snapshot_table_info.change_category]
                 self._print(
-                    f"- `{snapshot_table_info.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}`"
+                    f"- `{snapshot_table_info.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}` ({category_str})"
                 )
 
     def _print_modified_models(
@@ -3237,7 +3238,7 @@ class MarkdownConsole(CaptureTerminalConsole):
         no_diff: bool = True,
     ) -> None:
         directly_modified = []
-        indirectly_modified = []
+        indirectly_modified: t.List[Snapshot] = []
         metadata_modified = []
         for snapshot in modified_snapshots:
             if context_diff.directly_modified(snapshot.name):
@@ -3249,11 +3250,40 @@ class MarkdownConsole(CaptureTerminalConsole):
         if directly_modified:
             self._print("\n**Directly Modified:**")
             for snapshot in sorted(directly_modified):
+                category_str = SNAPSHOT_CHANGE_CATEGORY_STR[snapshot.change_category]
                 self._print(
-                    f"- `{snapshot.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}`"
+                    f"* `{snapshot.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}` ({category_str})"
+                )
+
+                indirectly_modified_children = sorted(
+                    [s for s in indirectly_modified if snapshot.snapshot_id in s.parents]
                 )
+
                 if not no_diff:
-                    self._print(f"```diff\n{context_diff.text_diff(snapshot.name)}\n```")
+                    diff_text = context_diff.text_diff(snapshot.name)
+                    # sometimes there is no text_diff, like on a seed model where the data has been updated
+                    if diff_text:
+                        diff_text = f"\n```diff\n{diff_text}\n```"
+                        # these are part of a Markdown list, so indent them by 2 spaces to relate them to the current list item
+                        diff_text_indented = "\n".join(
+                            [f"  {line}" for line in diff_text.splitlines()]
+                        )
+                        self._print(diff_text_indented)
+                    else:
+                        if indirectly_modified_children:
+                            self._print("\n")
+
+                if indirectly_modified_children:
+                    self._print("  Indirectly Modified Children:")
+                    for child_snapshot in indirectly_modified_children:
+                        child_category_str = SNAPSHOT_CHANGE_CATEGORY_STR[
+                            child_snapshot.change_category
+                        ]
+                        self._print(
+                            f"    - `{child_snapshot.display_name(environment_naming_info, default_catalog if self.verbosity < Verbosity.VERY_VERBOSE else None, dialect=self.dialect)}` ({child_category_str})"
+                        )
+                    self._print("\n")
+
         if indirectly_modified:
             self._print("\n**Indirectly Modified:**")
             self._print_models_with_threshold(

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/sqlmesh/integrations/github/cicd/command.py

@@ -115,8 +115,12 @@ def _update_pr_environment(controller: GithubController) -> bool:
         conclusion = controller.update_pr_environment_check(status=GithubCheckStatus.COMPLETED)
         return conclusion is not None and conclusion.is_success
     except Exception as e:
+        logger.exception("Error occurred when updating PR environment")
         conclusion = controller.update_pr_environment_check(
-            status=GithubCheckStatus.COMPLETED, exception=e, plan=controller.pr_plan_or_none
+            status=GithubCheckStatus.COMPLETED,
+            exception=e,
+            plan=controller.pr_plan_or_none,
+            plan_flags=controller.pr_plan_flags,
         )
         return (
             conclusion is not None
@@ -147,6 +151,7 @@ def _gen_prod_plan(controller: GithubController) -> bool:
         )
         return bool(plan_summary)
     except Exception as e:
+        logger.exception("Error occurred generating prod plan")
         controller.update_prod_plan_preview_check(
             status=GithubCheckStatus.COMPLETED,
             conclusion=GithubCheckConclusion.FAILURE,
@@ -211,6 +216,8 @@ def deploy_production(ctx: click.Context) -> None:
 
 
 def _run_all(controller: GithubController) -> None:
+    click.echo(f"SQLMesh Version: {controller.version_info}")
+
     has_required_approval = False
     is_auto_deploying_prod = (
         controller.deploy_command_enabled or controller.do_required_approval_check

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/sqlmesh/integrations/github/cicd/controller.py

@@ -9,11 +9,11 @@ import re
 import traceback
 import typing as t
 from enum import Enum
-from typing import List
 from pathlib import Path
+from dataclasses import dataclass
+from functools import cached_property
 
 import requests
-from hyperscript import Element, h
 from sqlglot.helper import seq_get
 
 from sqlmesh.core import constants as c
@@ -21,13 +21,13 @@ from sqlmesh.core.console import SNAPSHOT_CHANGE_CATEGORY_STR, get_console, Mark
 from sqlmesh.core.context import Context
 from sqlmesh.core.test.result import ModelTextTestResult
 from sqlmesh.core.environment import Environment
-from sqlmesh.core.plan import Plan, PlanBuilder
+from sqlmesh.core.plan import Plan, PlanBuilder, SnapshotIntervals
+from sqlmesh.core.plan.definition import UserProvidedFlags
 from sqlmesh.core.snapshot.definition import (
     Snapshot,
     SnapshotChangeCategory,
     SnapshotId,
     SnapshotTableInfo,
-    format_intervals,
 )
 from sqlglot.errors import SqlglotError
 from sqlmesh.core.user import User
@@ -415,6 +415,14 @@ class GithubController:
         except:
             return None
 
+    @property
+    def pr_plan_flags(self) -> t.Optional[t.Dict[str, UserProvidedFlags]]:
+        if pr_plan := self.pr_plan_or_none:
+            return pr_plan.user_provided_flags
+        if pr_plan_builder := self._pr_plan_builder:
+            return pr_plan_builder._user_provided_flags
+        return None
+
     @property
     def prod_plan(self) -> Plan:
         if not self._prod_plan_builder:
@@ -434,7 +442,9 @@ class GithubController:
         if not self._prod_plan_with_gaps_builder:
             self._prod_plan_with_gaps_builder = self._context.plan_builder(
                 c.PROD,
+                # this is required to highlight any data gaps between this PR environment and prod (since PR environments may only contain a subset of data)
                 no_gaps=False,
+                # this works because the snapshots were already categorized when applying self.pr_plan so there are no uncategorized local snapshots to trigger a plan error
                 no_auto_categorization=True,
                 skip_tests=True,
                 skip_linter=True,
@@ -495,9 +505,17 @@ class GithubController:
             difference_summary = self._console.consume_captured_output()
             self._console._show_missing_dates(plan, self._context.default_catalog)
             missing_dates = self._console.consume_captured_output()
+
+            plan_flags_section = (
+                f"\n\n{self._generate_plan_flags_section(plan.user_provided_flags)}"
+                if plan.user_provided_flags
+                else ""
+            )
+
             if not difference_summary and not missing_dates:
-                return "No changes to apply."
-            return f"{difference_summary}\n{missing_dates}"
+                return f"No changes to apply.{plan_flags_section}"
+
+            return f"{difference_summary}\n{missing_dates}{plan_flags_section}"
         except PlanError as e:
             return f"Plan failed to generate. Check for pending or unresolved changes. Error: {e}"
 
@@ -831,6 +849,9 @@ class GithubController:
         status: GithubCheckStatus,
         exception: t.Optional[Exception] = None,
         plan: t.Optional[Plan] = None,
+        plan_flags: t.Optional[
+            t.Dict[str, UserProvidedFlags]
+        ] = None,  # note: the plan flags are passed separately in case the plan fails to build
     ) -> t.Optional[GithubCheckConclusion]:
         """
         Updates the status of the merge commit for the PR environment.
@@ -852,58 +873,16 @@ class GithubController:
             conclusion: GithubCheckConclusion, exception: t.Optional[Exception]
         ) -> t.Tuple[GithubCheckConclusion, str, t.Optional[str]]:
             if conclusion.is_success:
-                if not self.modified_snapshots:
+                prod_plan = self.prod_plan_with_gaps
+
+                if not prod_plan.has_changes:
                     summary = "No models were modified in this PR.\n"
                 else:
-                    header_rows = [
-                        h("th", {"colspan": "3"}, "PR Environment Summary"),
-                        [
-                            h("th", "Model"),
-                            h("th", "Change Type"),
-                            h("th", "Dates Loaded"),
-                        ],
-                    ]
-                    body_rows: List[Element | List[Element]] = []
-                    for modified_snapshot in self.modified_snapshots.values():
-                        # We don't want to display indirect non-breaking since to users these are effectively no-op changes
-                        if modified_snapshot.is_indirect_non_breaking:
-                            continue
-                        if modified_snapshot.snapshot_id in self.removed_snapshots:
-                            # This will be an FQN since we don't have access to node name from a snapshot table info
-                            # which is what a removed snapshot is
-                            model_name = modified_snapshot.name
-                            change_category = SNAPSHOT_CHANGE_CATEGORY_STR[
-                                SnapshotChangeCategory.BREAKING
-                            ]
-                            interval_output = "REMOVED"
-                        else:
-                            assert isinstance(modified_snapshot, Snapshot)
-                            model_name = modified_snapshot.node.name
-                            change_category = (
-                                "Uncategorized"
-                                if not modified_snapshot.change_category
-                                else SNAPSHOT_CHANGE_CATEGORY_STR[modified_snapshot.change_category]
-                            )
-                            intervals = (
-                                modified_snapshot.dev_intervals
-                                if modified_snapshot.is_forward_only
-                                else modified_snapshot.intervals
-                            )
-                            interval_output = (
-                                format_intervals(intervals, modified_snapshot.node.interval_unit)
-                                if intervals
-                                else "N/A"
-                            )
-                        body_rows.append(
-                            [
-                                h("td", model_name, autoescape=False),
-                                h("td", change_category),
-                                h("td", interval_output),
-                            ]
-                        )
-                    table_header = h("thead", [h("tr", row) for row in header_rows])
-                    table_body = h("tbody", [h("tr", row) for row in body_rows])
-                    summary = str(h("table", [table_header, table_body]))
+                    intro = self._generate_pr_environment_summary_intro()
+                    summary = intro + self._generate_pr_environment_summary_list(prod_plan)
+                    if prod_plan.user_provided_flags:
+                        summary += self._generate_plan_flags_section(prod_plan.user_provided_flags)
+
                 vde_title = (
                     "- :eyes: To **review** this PR's changes, use virtual data environment:"
                 )
@@ -943,7 +922,11 @@ class GithubController:
                         "If you would like the bot to automatically categorize changes, check the [documentation](https://sqlmesh.readthedocs.io/en/stable/integrations/github/) for more information."
                     )
                 elif isinstance(exception, PlanError):
-                    failure_msg = f"Plan application failed.\n\n{self._console.captured_output}"
+                    failure_msg = f"Plan application failed.\n"
+                    if exception.args and (msg := exception.args[0]) and isinstance(msg, str):
+                        failure_msg += f"\n{msg}\n"
+                    if self._console.captured_output:
+                        failure_msg += f"\n{self._console.captured_output}"
                 elif isinstance(exception, (SQLMeshError, SqlglotError, ValueError)):
                     # this logic is taken from the global error handler attached to the CLI, which uses `click.echo()` to output the message
                     # so cant be re-used here because it bypasses the Console
@@ -959,13 +942,17 @@ class GithubController:
 
                 conclusion_to_summary = {
                     GithubCheckConclusion.SKIPPED: f":next_track_button: Skipped creating or updating PR Environment `{self.pr_environment_name}`. {skip_reason}",
-                    GithubCheckConclusion.FAILURE: f":x: Failed to create or update PR Environment `{self.pr_environment_name}`.\n\n{failure_msg}",
+                    GithubCheckConclusion.FAILURE: f":x: Failed to create or update PR Environment `{self.pr_environment_name}` :x:\n\n{failure_msg}",
                     GithubCheckConclusion.CANCELLED: f":stop_sign: Cancelled creating or updating PR Environment `{self.pr_environment_name}`",
                     GithubCheckConclusion.ACTION_REQUIRED: f":warning: Action Required to create or update PR Environment `{self.pr_environment_name}` :warning:\n\n{failure_msg}",
                 }
                 summary = conclusion_to_summary.get(
                     conclusion, f":interrobang: Got an unexpected conclusion: {conclusion.value}"
                 )
+                if plan_flags:
+                    plan_flags_section = self._generate_plan_flags_section(plan_flags)
+                    summary += f"\n\n{plan_flags_section}"
+
             self._append_output("pr_environment_name", self.pr_environment_name)
             return conclusion, check_title, summary
 
@@ -1006,6 +993,12 @@ class GithubController:
             title = conclusion_to_title.get(
                 conclusion, f"Got an unexpected conclusion: {conclusion.value}"
             )
+            if conclusion == GithubCheckConclusion.SUCCESS and summary:
+                summary = (
+                    f"This is a preview that shows the differences between this PR environment `{self.pr_environment_name}` and `prod`.\n\n"
+                    "These are the changes that would be deployed.\n\n"
+                ) + summary
+
             return conclusion, title, summary
 
         self._update_check_handler(
@@ -1115,3 +1108,232 @@ class GithubController:
     @property
     def running_in_github_actions(self) -> bool:
         return os.environ.get("GITHUB_ACTIONS", None) == "true"
+
+    @property
+    def version_info(self) -> str:
+        from sqlmesh.cli.main import _sqlmesh_version
+
+        return _sqlmesh_version()
+
+    def _generate_plan_flags_section(
+        self, user_provided_flags: t.Dict[str, UserProvidedFlags]
+    ) -> str:
+        # collapsed section syntax:
+        # https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/organizing-information-with-collapsed-sections#creating-a-collapsed-section
+        section = "<details>\n\n<summary>Plan flags</summary>\n\n"
+        for flag_name, flag_value in user_provided_flags.items():
+            section += f"- `{flag_name}` = `{flag_value}`\n"
+        section += "\n</details>"
+
+        return section
+
+    def _generate_pr_environment_summary_intro(self) -> str:
+        note = ""
+        subset_reasons = []
+
+        if self.bot_config.skip_pr_backfill:
+            subset_reasons.append("`skip_pr_backfill` is enabled")
+
+        if default_pr_start := self.bot_config.default_pr_start:
+            subset_reasons.append(f"`default_pr_start` is set to `{default_pr_start}`")
+
+        if subset_reasons:
+            note = (
+                "> [!IMPORTANT]\n"
+                f"> This PR environment may only contain a subset of data because:\n"
+                + "\n".join(f"> - {r}" for r in subset_reasons)
+                + "\n"
+                "> \n"
+                "> This means that deploying to `prod` may not be a simple virtual update if there is still some data to load.\n"
+                "> See `Dates not loaded in PR` below or the `Prod Plan Preview` check for more information.\n\n"
+            )
+
+        return (
+            f"Here is a summary of data that has been loaded into the PR environment `{self.pr_environment_name}` and could be deployed to `prod`.\n\n"
+            + note
+        )
+
+    def _generate_pr_environment_summary_list(self, plan: Plan) -> str:
+        added_snapshot_ids = set(plan.context_diff.added)
+        modified_snapshot_ids = set(
+            s.snapshot_id for s, _ in plan.context_diff.modified_snapshots.values()
+        )
+        removed_snapshot_ids = set(plan.context_diff.removed_snapshots.keys())
+
+        # note: we sort these to get a deterministic order for the output tests
+        table_records = sorted(
+            [
+                SnapshotSummaryRecord(snapshot_id=snapshot_id, plan=plan)
+                for snapshot_id in (
+                    added_snapshot_ids | modified_snapshot_ids | removed_snapshot_ids
+                )
+            ],
+            key=lambda r: r.display_name,
+        )
+
+        sections = [
+            ("### Added", [r for r in table_records if r.is_added]),
+            ("### Removed", [r for r in table_records if r.is_removed]),
+            ("### Directly Modified", [r for r in table_records if r.is_directly_modified]),
+            ("### Indirectly Modified", [r for r in table_records if r.is_indirectly_modified]),
+            (
+                "### Metadata Updated",
+                [r for r in table_records if r.is_metadata_updated and not r.is_modified],
+            ),
+        ]
+
+        summary = ""
+        for title, records in sections:
+            if records:
+                summary += f"\n{title}\n"
+
+            for record in records:
+                summary += f"{record.as_markdown_list_item}\n"
+
+        return summary
+
+
+@dataclass
+class SnapshotSummaryRecord:
+    snapshot_id: SnapshotId
+    plan: Plan
+
+    @property
+    def snapshot(self) -> Snapshot:
+        if self.is_removed:
+            raise ValueError("Removed snapshots only have SnapshotTableInfo available")
+        return self.plan.snapshots[self.snapshot_id]
+
+    @cached_property
+    def snapshot_table_info(self) -> SnapshotTableInfo:
+        if self.is_removed:
+            return self.plan.modified_snapshots[self.snapshot_id].table_info
+        return self.plan.snapshots[self.snapshot_id].table_info
+
+    @property
+    def display_name(self) -> str:
+        dialect = None if self.is_removed else self.snapshot.node.dialect
+        return self.snapshot_table_info.display_name(
+            self.plan.environment_naming_info, default_catalog=None, dialect=dialect
+        )
+
+    @property
+    def change_category(self) -> str:
+        if self.is_removed:
+            return SNAPSHOT_CHANGE_CATEGORY_STR[SnapshotChangeCategory.BREAKING]
+
+        if change_category := self.snapshot.change_category:
+            return SNAPSHOT_CHANGE_CATEGORY_STR[change_category]
+
+        return "Uncategorized"
+
+    @property
+    def is_added(self) -> bool:
+        return self.snapshot_id in self.plan.context_diff.added
+
+    @property
+    def is_removed(self) -> bool:
+        return self.snapshot_id in self.plan.context_diff.removed_snapshots
+
+    @property
+    def is_dev_preview(self) -> bool:
+        return not self.plan.deployability_index.is_deployable(self.snapshot_id)
+
+    @property
+    def is_directly_modified(self) -> bool:
+        return self.plan.context_diff.directly_modified(self.snapshot_table_info.name)
+
+    @property
+    def is_indirectly_modified(self) -> bool:
+        return self.plan.context_diff.indirectly_modified(self.snapshot_table_info.name)
+
+    @property
+    def is_modified(self) -> bool:
+        return self.is_directly_modified or self.is_indirectly_modified
+
+    @property
+    def is_metadata_updated(self) -> bool:
+        return self.plan.context_diff.metadata_updated(self.snapshot_table_info.name)
+
+    @property
+    def is_incremental(self) -> bool:
+        return self.snapshot_table_info.is_incremental
+
+    @property
+    def modification_type(self) -> str:
+        if self.is_directly_modified:
+            return "Directly modified"
+        if self.is_indirectly_modified:
+            return "Indirectly modified"
+        if self.is_metadata_updated:
+            return "Metadata updated"
+
+        return "Unknown"
+
+    @property
+    def loaded_intervals(self) -> SnapshotIntervals:
+        if self.is_removed:
+            raise ValueError("Removed snapshots dont have loaded intervals available")
+
+        return SnapshotIntervals(
+            snapshot_id=self.snapshot_id,
+            intervals=(
+                self.snapshot.dev_intervals
+                if self.snapshot.is_forward_only
+                else self.snapshot.intervals
+            ),
+        )
+
+    @property
+    def loaded_intervals_rendered(self) -> str:
+        if self.is_removed:
+            return "REMOVED"
+
+        return self._format_intervals(self.loaded_intervals)
+
+    @property
+    def missing_intervals(self) -> t.Optional[SnapshotIntervals]:
+        return next(
+            (si for si in self.plan.missing_intervals if si.snapshot_id == self.snapshot_id),
+            None,
+        )
+
+    @property
+    def missing_intervals_formatted(self) -> str:
+        if not self.is_removed and (intervals := self.missing_intervals):
+            return self._format_intervals(intervals)
+
+        return "N/A"
+
+    @property
+    def as_markdown_list_item(self) -> str:
+        if self.is_removed:
+            return f"- `{self.display_name}` ({self.change_category})"
+
+        how_applied = ""
+
+        if not self.is_incremental:
+            from sqlmesh.core.console import _format_missing_intervals
+
+            # note: this is to re-use the '[recreate view]' and '[full refresh]' text and keep it in sync with updates to the CLI
+            # it doesnt actually use the passed intervals, those are handled differently
+            how_applied = _format_missing_intervals(self.snapshot, self.loaded_intervals)
+
+        how_applied_str = f" [{how_applied}]" if how_applied else ""
+
+        item = f"- `{self.display_name}` ({self.change_category})\n"
+
+        if self.snapshot_table_info.model_kind_name:
+            item += f"  **Kind:** {self.snapshot_table_info.model_kind_name}{how_applied_str}\n"
+
+        if self.is_incremental:
+            # in-depth interval info is only relevant for incremental models
+            item += f"  **Dates loaded in PR:** [{self.loaded_intervals_rendered}]\n"
+            if self.missing_intervals:
+                item += f"  **Dates *not* loaded in PR:** [{self.missing_intervals_formatted}]\n"
+
+        return item
+
+    def _format_intervals(self, intervals: SnapshotIntervals) -> str:
+        preview_modifier = " (**preview**)" if self.is_dev_preview else ""
+        return f"{intervals.format_intervals(self.snapshot.node.interval_unit)}{preview_modifier}"

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.199.1.dev1
+Version: 0.199.1.dev3
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/sqlmesh.egg-info/SOURCES.txt

@@ -784,9 +784,10 @@ vscode/extension/tests/bad_setup.spec.ts
 vscode/extension/tests/broken_project.spec.ts
 vscode/extension/tests/completions.spec.ts
 vscode/extension/tests/diagnostics.spec.ts
+vscode/extension/tests/extension.setup.ts
+vscode/extension/tests/extension.teardown.ts
 vscode/extension/tests/find_references.spec.ts
 vscode/extension/tests/format.spec.ts
-vscode/extension/tests/global-setup.ts
 vscode/extension/tests/go_to_definition.spec.ts
 vscode/extension/tests/hints.spec.ts
 vscode/extension/tests/lineage.spec.ts

{sqlmesh-0.199.1.dev1 → sqlmesh-0.199.1.dev3}/tests/integrations/github/cicd/test_github_controller.py

@@ -11,14 +11,13 @@ from sqlmesh.core import constants as c
 from sqlmesh.core.config import CategorizerConfig
 from sqlmesh.core.dialect import parse_one
 from sqlmesh.core.model import SqlModel
-from sqlmesh.core.snapshot import SnapshotChangeCategory
 from sqlmesh.core.user import User, UserRole
 from sqlmesh.integrations.github.cicd.config import GithubCICDBotConfig, MergeMethod
 from sqlmesh.integrations.github.cicd.controller import (
     BotCommand,
-    GithubCheckStatus,
     MergeStateStatus,
 )
+from sqlmesh.integrations.github.cicd.command import _update_pr_environment
 from sqlmesh.utils.date import to_datetime, now
 from tests.integrations.github.cicd.conftest import MockIssueComment
 
@@ -545,16 +544,11 @@ def test_uncategorized(
     make_mock_issue_comment,
     tmp_path: pathlib.Path,
 ):
-    snapshot_categrozied = make_snapshot(SqlModel(name="a", query=parse_one("select 1, ds")))
-    snapshot_categrozied.categorize_as(SnapshotChangeCategory.BREAKING)
     snapshot_uncategorized = make_snapshot(SqlModel(name="b", query=parse_one("select 1, ds")))
     mocker.patch(
-        "sqlmesh.core.plan.Plan.modified_snapshots",
+        "sqlmesh.core.plan.Plan.uncategorized",
         PropertyMock(
-            return_value={
-                snapshot_categrozied.snapshot_id: snapshot_categrozied,
-                snapshot_uncategorized.snapshot_id: snapshot_uncategorized,
-            },
+            return_value=[snapshot_uncategorized],
         ),
     )
     mock_repo = github_client.get_repo()
@@ -570,21 +564,30 @@ def test_uncategorized(
         )
     )
     mock_issue.get_comments = mocker.MagicMock(side_effect=lambda: created_comments)
+
+    # note: context is deliberately not mocked out so that context.apply() throws UncategorizedPlanError due to the uncategorized snapshot
     controller = make_controller(
-        "tests/fixtures/github/pull_request_synchronized.json", github_client
+        "tests/fixtures/github/pull_request_synchronized.json",
+        github_client,
+        mock_out_context=False,
     )
+    assert controller.pr_plan.uncategorized
 
     github_output_file = tmp_path / "github_output.txt"
 
     with mock.patch.dict(os.environ, {"GITHUB_OUTPUT": str(github_output_file)}):
-        controller.update_pr_environment_check(GithubCheckStatus.COMPLETED)
+        _update_pr_environment(controller)
 
     assert "SQLMesh - PR Environment Synced" in controller._check_run_mapping
     pr_environment_check_run = controller._check_run_mapping[
         "SQLMesh - PR Environment Synced"
     ].all_kwargs
-    assert len(pr_environment_check_run) == 1
-    assert (
-        pr_environment_check_run[0]["output"]["summary"]
-        == """<table><thead><tr><th colspan="3">PR Environment Summary</th></tr><tr><th>Model</th><th>Change Type</th><th>Dates Loaded</th></tr></thead><tbody><tr><td>a</td><td>Breaking</td><td>N/A</td></tr><tr><td>b</td><td>Uncategorized</td><td>N/A</td></tr></tbody></table>"""
-    )
+    assert len(pr_environment_check_run) == 2
+    assert pr_environment_check_run[0]["status"] == "in_progress"
+    assert pr_environment_check_run[1]["status"] == "completed"
+    assert pr_environment_check_run[1]["conclusion"] == "action_required"
+    summary = pr_environment_check_run[1]["output"]["summary"]
+    assert "Action Required to create or update PR Environment" in summary
+    assert "The following models could not be categorized automatically" in summary
+    assert '- "b"' in summary
+    assert "Run `sqlmesh plan hello_world_2` locally to apply these changes" in summary