sqlmesh 0.195.0__tar.gz → 0.195.1.dev2__tar.gz

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/PKG-INFO

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

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.195.0'
-__version_tuple__ = version_tuple = (0, 195, 0)
+__version__ = version = '0.195.1.dev2'
+__version_tuple__ = version_tuple = (0, 195, 1, 'dev2')

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/sqlmesh/core/console.py

@@ -1954,6 +1954,10 @@ class TerminalConsole(Console):
             plan_builder.apply()
 
     def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
+        # We don't log the test results if no tests were ran
+        if not result.testsRun:
+            return
+
         divider_length = 70
 
         self._log_test_details(result)
@@ -2827,6 +2831,10 @@ class NotebookMagicConsole(TerminalConsole):
         self.display(radio)
 
     def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
+        # We don't log the test results if no tests were ran
+        if not result.testsRun:
+            return
+
         import ipywidgets as widgets
 
         divider_length = 70
@@ -3206,6 +3214,10 @@ class MarkdownConsole(CaptureTerminalConsole):
         self._print(message)
 
     def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
+        # We don't log the test results if no tests were ran
+        if not result.testsRun:
+            return
+
         message = f"Ran `{result.testsRun}` Tests Against `{target_dialect}`"
 
         if result.wasSuccessful():

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/sqlmesh/lsp/main.py

@@ -52,6 +52,7 @@ from sqlmesh.lsp.reference import (
     get_references,
     get_all_references,
 )
+from sqlmesh.lsp.rename import prepare_rename, rename_symbol, get_document_highlights
 from sqlmesh.lsp.uri import URI
 from web.server.api.endpoints.lineage import column_lineage, model_lineage
 from web.server.api.endpoints.models import get_models
@@ -435,6 +436,59 @@ class SQLMeshLanguageServer:
                 ls.show_message(f"Error getting locations: {e}", types.MessageType.Error)
                 return None
 
+        @self.server.feature(types.TEXT_DOCUMENT_PREPARE_RENAME)
+        def prepare_rename_handler(
+            ls: LanguageServer, params: types.PrepareRenameParams
+        ) -> t.Optional[types.PrepareRenameResult]:
+            """Prepare for rename operation by checking if the symbol can be renamed."""
+            try:
+                uri = URI(params.text_document.uri)
+                self._ensure_context_for_document(uri)
+                if self.lsp_context is None:
+                    raise RuntimeError(f"No context found for document: {uri}")
+
+                result = prepare_rename(self.lsp_context, uri, params.position)
+                return result
+            except Exception as e:
+                ls.log_trace(f"Error preparing rename: {e}")
+                return None
+
+        @self.server.feature(types.TEXT_DOCUMENT_RENAME)
+        def rename_handler(
+            ls: LanguageServer, params: types.RenameParams
+        ) -> t.Optional[types.WorkspaceEdit]:
+            """Perform rename operation on the symbol at the given position."""
+            try:
+                uri = URI(params.text_document.uri)
+                self._ensure_context_for_document(uri)
+                if self.lsp_context is None:
+                    raise RuntimeError(f"No context found for document: {uri}")
+
+                workspace_edit = rename_symbol(
+                    self.lsp_context, uri, params.position, params.new_name
+                )
+                return workspace_edit
+            except Exception as e:
+                ls.show_message(f"Error performing rename: {e}", types.MessageType.Error)
+                return None
+
+        @self.server.feature(types.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT)
+        def document_highlight_handler(
+            ls: LanguageServer, params: types.DocumentHighlightParams
+        ) -> t.Optional[t.List[types.DocumentHighlight]]:
+            """Highlight all occurrences of the symbol at the given position."""
+            try:
+                uri = URI(params.text_document.uri)
+                self._ensure_context_for_document(uri)
+                if self.lsp_context is None:
+                    raise RuntimeError(f"No context found for document: {uri}")
+
+                highlights = get_document_highlights(self.lsp_context, uri, params.position)
+                return highlights
+            except Exception as e:
+                ls.log_trace(f"Error getting document highlights: {e}")
+                return None
+
         @self.server.feature(types.TEXT_DOCUMENT_DIAGNOSTIC)
         def diagnostic(
             ls: LanguageServer, params: types.DocumentDiagnosticParams

sqlmesh-0.195.1.dev2/sqlmesh/lsp/rename.py

@@ -0,0 +1,137 @@
+import typing as t
+from lsprotocol.types import (
+    Position,
+    TextEdit,
+    WorkspaceEdit,
+    PrepareRenameResult_Type1,
+    DocumentHighlight,
+    DocumentHighlightKind,
+)
+
+from sqlmesh.lsp.context import LSPContext
+from sqlmesh.lsp.reference import (
+    _position_within_range,
+    get_cte_references,
+    LSPCteReference,
+)
+from sqlmesh.lsp.uri import URI
+
+
+def prepare_rename(
+    lsp_context: LSPContext, document_uri: URI, position: Position
+) -> t.Optional[PrepareRenameResult_Type1]:
+    """
+    Prepare for rename operation by checking if the symbol at the position can be renamed.
+
+    Args:
+        lsp_context: The LSP context
+        document_uri: The URI of the document
+        position: The position in the document
+
+    Returns:
+        PrepareRenameResult if the symbol can be renamed, None otherwise
+    """
+    # Check if there's a CTE at this position
+    cte_references = get_cte_references(lsp_context, document_uri, position)
+    if cte_references:
+        # Find the target CTE definition to get its range
+        target_range = None
+        for ref in cte_references:
+            # Check if cursor is on a CTE usage
+            if _position_within_range(position, ref.range):
+                target_range = ref.target_range
+                break
+            # Check if cursor is on the CTE definition
+            elif _position_within_range(position, ref.target_range):
+                target_range = ref.target_range
+                break
+        if target_range:
+            return PrepareRenameResult_Type1(range=target_range, placeholder="cte_name")
+
+    # For now, only CTEs are supported
+    return None
+
+
+def rename_symbol(
+    lsp_context: LSPContext, document_uri: URI, position: Position, new_name: str
+) -> t.Optional[WorkspaceEdit]:
+    """
+    Perform rename operation on the symbol at the given position.
+
+    Args:
+        lsp_context: The LSP context
+        document_uri: The URI of the document
+        position: The position in the document
+        new_name: The new name for the symbol
+
+    Returns:
+        WorkspaceEdit with the changes, or None if no symbol to rename
+    """
+    # Check if there's a CTE at this position
+    cte_references = get_cte_references(lsp_context, document_uri, position)
+    if cte_references:
+        return _rename_cte(cte_references, new_name)
+
+    # For now, only CTEs are supported
+    return None
+
+
+def _rename_cte(cte_references: t.List[LSPCteReference], new_name: str) -> WorkspaceEdit:
+    """
+    Create a WorkspaceEdit for renaming a CTE.
+
+    Args:
+        cte_references: List of CTE references (definition and usages)
+        new_name: The new name for the CTE
+
+    Returns:
+        WorkspaceEdit with the text edits for renaming the CTE
+    """
+    changes: t.Dict[str, t.List[TextEdit]] = {}
+
+    for ref in cte_references:
+        uri = ref.uri
+        if uri not in changes:
+            changes[uri] = []
+
+        # Create a text edit for this reference
+        text_edit = TextEdit(range=ref.range, new_text=new_name)
+        changes[uri].append(text_edit)
+
+    return WorkspaceEdit(changes=changes)
+
+
+def get_document_highlights(
+    lsp_context: LSPContext, document_uri: URI, position: Position
+) -> t.Optional[t.List[DocumentHighlight]]:
+    """
+    Get document highlights for all occurrences of the symbol at the given position.
+
+    This function finds all occurrences of a symbol (CTE) within the current document
+    and returns them as DocumentHighlight objects for "Change All Occurrences" feature.
+
+    Args:
+        lsp_context: The LSP context
+        document_uri: The URI of the document
+        position: The position in the document to find highlights for
+
+    Returns:
+        List of DocumentHighlight objects or None if no symbol found
+    """
+    # Check if there's a CTE at this position
+    cte_references = get_cte_references(lsp_context, document_uri, position)
+    if cte_references:
+        highlights = []
+        for ref in cte_references:
+            # Determine the highlight kind based on whether it's a definition or usage
+            kind = (
+                DocumentHighlightKind.Write
+                if ref.range == ref.target_range
+                else DocumentHighlightKind.Read
+            )
+
+            highlights.append(DocumentHighlight(range=ref.range, kind=kind))
+        return highlights
+
+    # For now, only CTEs are supported
+    return None

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/sqlmesh.egg-info/PKG-INFO

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

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/sqlmesh.egg-info/SOURCES.txt

@@ -366,6 +366,7 @@ sqlmesh/lsp/helpers.py
 sqlmesh/lsp/hints.py
 sqlmesh/lsp/main.py
 sqlmesh/lsp/reference.py
+sqlmesh/lsp/rename.py
 sqlmesh/lsp/uri.py
 sqlmesh/migrations/__init__.py
 sqlmesh/migrations/v0001_init.py
@@ -683,6 +684,7 @@ tests/lsp/test_completions.py
 tests/lsp/test_context.py
 tests/lsp/test_description.py
 tests/lsp/test_diagnostics.py
+tests/lsp/test_document_highlight.py
 tests/lsp/test_hints.py
 tests/lsp/test_reference.py
 tests/lsp/test_reference_cte.py
@@ -693,6 +695,7 @@ tests/lsp/test_reference_macro_find_all.py
 tests/lsp/test_reference_macro_multi.py
 tests/lsp/test_reference_model_column_prefix.py
 tests/lsp/test_reference_model_find_all.py
+tests/lsp/test_rename_cte.py
 tests/schedulers/__init__.py
 tests/utils/__init__.py
 tests/utils/pandas.py
@@ -780,6 +783,7 @@ vscode/extension/tests/go_to_definition.spec.ts
 vscode/extension/tests/hints.spec.ts
 vscode/extension/tests/lineage.spec.ts
 vscode/extension/tests/python_env.spec.ts
+vscode/extension/tests/rename_cte.spec.ts
 vscode/extension/tests/render.spec.ts
 vscode/extension/tests/stop.spec.ts
 vscode/extension/tests/tcloud.spec.ts

{sqlmesh-0.195.0 → sqlmesh-0.195.1.dev2}/tests/core/test_test.py

@@ -2685,6 +2685,10 @@ test_foo:
         else:
             result.addFailure(test, (e.__class__, e, e.__traceback__))
 
+        # Since we're simulating an error/failure, this doesn't go through the
+        # test runner logic, so we need to manually set how many tests were ran
+        result.testsRun = 1
+
     with capture_output() as captured_output:
         get_console().log_test_results(result, "duckdb")
 
@@ -2729,3 +2733,23 @@ def test_timestamp_normalization() -> None:
             context=Context(config=Config(model_defaults=ModelDefaultsConfig(dialect="duckdb"))),
         ).run()
     )
+
+
+@use_terminal_console
+def test_disable_test_logging_if_no_tests_found(mocker: MockerFixture, tmp_path: Path) -> None:
+    init_example_project(tmp_path, dialect="duckdb")
+
+    config = Config(
+        default_connection=DuckDBConnectionConfig(),
+        model_defaults=ModelDefaultsConfig(dialect="duckdb"),
+        default_test_connection=DuckDBConnectionConfig(concurrent_tasks=8),
+    )
+
+    rmtree(tmp_path / "tests")
+
+    with capture_output() as captured_output:
+        context = Context(paths=tmp_path, config=config)
+        context.plan(no_prompts=True, auto_apply=True)
+
+    output = captured_output.stdout
+    assert "test" not in output.lower()

sqlmesh-0.195.1.dev2/tests/lsp/test_document_highlight.py

@@ -0,0 +1,111 @@
+from lsprotocol.types import Position, DocumentHighlightKind
+
+from sqlmesh.core.context import Context
+from sqlmesh.lsp.context import LSPContext, ModelTarget
+from sqlmesh.lsp.rename import get_document_highlights
+from sqlmesh.lsp.uri import URI
+from tests.lsp.test_reference_cte import find_ranges_from_regex
+
+
+def test_get_document_highlights_cte():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    # Use the existing customers.sql model which has CTEs
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    test_uri = URI.from_path(sushi_customers_path)
+
+    # Find the ranges for "current_marketing" CTE (not outer one)
+    ranges = find_ranges_from_regex(read_file, r"current_marketing(?!_outer)")
+    assert len(ranges) >= 2  # Should have definition + usage
+
+    # Test highlighting CTE definition - position on "current_marketing" definition
+    position = Position(line=ranges[0].start.line, character=ranges[0].start.character + 4)
+    highlights = get_document_highlights(lsp_context, test_uri, position)
+
+    assert highlights is not None
+    assert len(highlights) >= 2  # Definition + at least 1 usage
+
+    # Check that we have both definition (Write) and usage (Read) highlights
+    highlight_kinds = [h.kind for h in highlights]
+    assert DocumentHighlightKind.Write in highlight_kinds  # CTE definition
+    assert DocumentHighlightKind.Read in highlight_kinds  # CTE usage
+
+    # Test highlighting CTE usage - position on "current_marketing" usage
+    position = Position(line=ranges[1].start.line, character=ranges[1].start.character + 4)
+    highlights = get_document_highlights(lsp_context, test_uri, position)
+
+    assert highlights is not None
+    assert len(highlights) >= 2  # Should find the same references
+
+
+def test_get_document_highlights_no_symbol():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    # Use the existing customers.sql model
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    test_uri = URI.from_path(sushi_customers_path)
+
+    # Test position not on any CTE symbol - just on a random keyword
+    position = Position(line=5, character=5)
+    highlights = get_document_highlights(lsp_context, test_uri, position)
+
+    assert highlights is None
+
+
+def test_get_document_highlights_multiple_ctes():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    # Use the existing customers.sql model which has both outer and inner CTEs
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    test_uri = URI.from_path(sushi_customers_path)
+
+    # Test the outer CTE - "current_marketing_outer"
+    outer_ranges = find_ranges_from_regex(read_file, r"current_marketing_outer")
+    assert len(outer_ranges) >= 2  # Should have definition + usage
+
+    # Test highlighting outer CTE - should only highlight that CTE
+    position = Position(
+        line=outer_ranges[0].start.line, character=outer_ranges[0].start.character + 4
+    )
+    highlights = get_document_highlights(lsp_context, test_uri, position)
+
+    assert highlights is not None
+    assert len(highlights) == len(outer_ranges)  # Should match all occurrences of outer CTE
+
+    # Test the inner CTE - "current_marketing" (not outer)
+    inner_ranges = find_ranges_from_regex(read_file, r"current_marketing(?!_outer)")
+    assert len(inner_ranges) >= 2  # Should have definition + usage
+
+    # Test highlighting inner CTE - should only highlight that CTE, not the outer one
+    position = Position(
+        line=inner_ranges[0].start.line, character=inner_ranges[0].start.character + 4
+    )
+    highlights = get_document_highlights(lsp_context, test_uri, position)
+
+    # This should return the column usages as well
+    assert highlights is not None
+    assert len(highlights) == 4

sqlmesh-0.195.1.dev2/tests/lsp/test_rename_cte.py

@@ -0,0 +1,212 @@
+from lsprotocol.types import Position
+from sqlmesh.core.context import Context
+from sqlmesh.lsp.context import LSPContext, ModelTarget
+from sqlmesh.lsp.rename import prepare_rename, rename_symbol
+from sqlmesh.lsp.uri import URI
+from tests.lsp.test_reference_cte import find_ranges_from_regex
+
+
+def test_prepare_rename_cte():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    # Test clicking on CTE definition for "current_marketing"
+    ranges = find_ranges_from_regex(read_file, r"current_marketing(?!_outer)")
+    assert len(ranges) == 2
+
+    # Click on the CTE definition
+    position = Position(line=ranges[0].start.line, character=ranges[0].start.character + 4)
+    result = prepare_rename(lsp_context, URI.from_path(sushi_customers_path), position)
+
+    assert result is not None
+    assert result.placeholder == "cte_name"
+    assert result.range == ranges[0]  # Should return the definition range
+
+    # Test clicking on CTE usage
+    position = Position(line=ranges[1].start.line, character=ranges[1].start.character + 4)
+    result = prepare_rename(lsp_context, URI.from_path(sushi_customers_path), position)
+
+    assert result is not None
+    assert result.placeholder == "cte_name"
+    assert result.range == ranges[0]  # Should still return the definition range
+
+
+def test_prepare_rename_cte_outer():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    # Test clicking on CTE definition for "current_marketing_outer"
+    ranges = find_ranges_from_regex(read_file, r"current_marketing_outer")
+    assert len(ranges) == 2
+
+    # Click on the CTE definition
+    position = Position(line=ranges[0].start.line, character=ranges[0].start.character + 4)
+    result = prepare_rename(lsp_context, URI.from_path(sushi_customers_path), position)
+
+    assert result is not None
+    assert result.placeholder == "cte_name"
+    assert result.range == ranges[0]  # Should return the definition range
+
+
+def test_prepare_rename_non_cte():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    # Click on a regular table reference (not a CTE)
+    ranges = find_ranges_from_regex(read_file, r"sushi\.orders")
+    assert len(ranges) >= 1
+
+    position = Position(line=ranges[0].start.line, character=ranges[0].start.character + 4)
+    result = prepare_rename(lsp_context, URI.from_path(sushi_customers_path), position)
+
+    assert result is None
+
+
+def test_rename_cte():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    # Test renaming "current_marketing" to "new_marketing"
+    ranges = find_ranges_from_regex(read_file, r"current_marketing(?!_outer)")
+    assert len(ranges) == 2
+
+    # Click on the CTE definition
+    position = Position(line=ranges[0].start.line, character=ranges[0].start.character + 4)
+    workspace_edit = rename_symbol(
+        lsp_context, URI.from_path(sushi_customers_path), position, "new_marketing"
+    )
+
+    assert workspace_edit is not None
+    assert workspace_edit.changes is not None
+
+    uri = URI.from_path(sushi_customers_path).value
+    assert uri in workspace_edit.changes
+
+    edits = workspace_edit.changes[uri]
+
+    # Should have edited four occurences including column usages
+    assert len(edits) == 4
+
+    # Verify that both ranges are being edited
+    edit_ranges = [edit.range for edit in edits]
+    for expected_range in ranges:
+        assert any(
+            edit_range.start.line == expected_range.start.line
+            and edit_range.start.character == expected_range.start.character
+            for edit_range in edit_ranges
+        ), (
+            f"Expected to find edit at line {expected_range.start.line}, char {expected_range.start.character}"
+        )
+
+    # Verify that all edits have the new name
+    assert all(edit.new_text == "new_marketing" for edit in edits)
+
+    # Apply the edits to verify the result
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        lines = file.readlines()
+
+    # Apply edits in reverse order to avoid offset issues
+    sorted_edits = sorted(
+        edits, key=lambda e: (e.range.start.line, e.range.start.character), reverse=True
+    )
+    for edit in sorted_edits:
+        line_idx = edit.range.start.line
+        start_char = edit.range.start.character
+        end_char = edit.range.end.character
+
+        line = lines[line_idx]
+        new_line = line[:start_char] + edit.new_text + line[end_char:]
+        lines[line_idx] = new_line
+
+    # Verify the edited content
+    edited_content = "".join(lines)
+    assert "new_marketing" in edited_content
+    assert "current_marketing" not in edited_content.replace("current_marketing_outer", "")
+    assert edited_content.count("new_marketing") == 4
+    assert (
+        "  SELECT new_marketing.* FROM new_marketing WHERE new_marketing.customer_id != 100\n"
+        in lines
+    )
+
+
+def test_rename_cte_outer():
+    context = Context(paths=["examples/sushi"])
+    lsp_context = LSPContext(context)
+
+    sushi_customers_path = next(
+        path
+        for path, info in lsp_context.map.items()
+        if isinstance(info, ModelTarget) and "sushi.customers" in info.names
+    )
+
+    with open(sushi_customers_path, "r", encoding="utf-8") as file:
+        read_file = file.readlines()
+
+    # Test renaming "current_marketing_outer" to "new_marketing_outer"
+    ranges = find_ranges_from_regex(read_file, r"current_marketing_outer")
+    assert len(ranges) == 2
+
+    # Click on the CTE usage
+    position = Position(line=ranges[1].start.line, character=ranges[1].start.character + 4)
+    workspace_edit = rename_symbol(
+        lsp_context, URI.from_path(sushi_customers_path), position, "new_marketing_outer"
+    )
+
+    assert workspace_edit is not None
+    assert workspace_edit.changes is not None
+
+    uri = URI.from_path(sushi_customers_path).value
+    assert uri in workspace_edit.changes
+
+    edits = workspace_edit.changes[uri]
+    assert len(edits) == 2  # Should have 2 edits: definition + usage
+
+    # Verify that both ranges are being edited
+    edit_ranges = [edit.range for edit in edits]
+    for expected_range in ranges:
+        assert any(
+            edit_range.start.line == expected_range.start.line
+            and edit_range.start.character == expected_range.start.character
+            for edit_range in edit_ranges
+        ), (
+            f"Expected to find edit at line {expected_range.start.line}, char {expected_range.start.character}"
+        )
+
+    # Verify that all edits have the new name
+    assert all(edit.new_text == "new_marketing_outer" for edit in edits)