recce-nightly 1.2.0.20250506__py3-none-any.whl → 1.26.0.20251124__py3-none-any.whl

tests/test_config.py

@@ -10,7 +10,7 @@ test_root_path = os.path.dirname(os.path.abspath(__file__))
 
 class RecceConfigTestCase(TestCase):
     def setUp(self):
-        self.recce_config_path = os.path.join(test_root_path, 'data', 'config', 'recce.yml')
+        self.recce_config_path = os.path.join(test_root_path, "data", "config", "recce.yml")
         pass
 
     def tearDown(self):
@@ -21,25 +21,23 @@ class RecceConfigTestCase(TestCase):
         config = RecceConfig(self.recce_config_path)
 
         # Test data contains 2 checks
-        preset_checks = config.config.get('checks')
+        preset_checks = config.config.get("checks")
         self.assertIsNotNone(preset_checks)
         self.assertIsInstance(preset_checks, list)
         self.assertEqual(len(preset_checks), 2)
 
-    @patch('recce.config.RecceConfig.save')
+    @patch("recce.config.RecceConfig.save")
     def test_recce_config_not_found(self, mock_save):
-        default_config = RecceConfig('NOT_EXISTING_FILE')
+        default_config = RecceConfig("NOT_EXISTING_FILE")
         assert mock_save.called is True
         # Default config should be generated
-        preset_checks = default_config.config.get('checks')
+        preset_checks = default_config.config.get("checks")
         self.assertIsNotNone(default_config.config)
         self.assertIsInstance(preset_checks, list)
         self.assertEqual(len(preset_checks), 2)
 
-    @patch('recce.yaml.safe_load')
+    @patch("recce.yaml.safe_load")
     def test_recce_config_null_checks(self, mock_yaml_safe_load):
         # mock to load a yaml file with null checks
-        mock_yaml_safe_load.return_value = {
-            'checks': None
-        }
+        mock_yaml_safe_load.return_value = {"checks": None}
         RecceConfig(self.recce_config_path)

tests/test_connect_to_cloud.py

@@ -0,0 +1,82 @@
+import base64
+import unittest
+from unittest.mock import patch
+from urllib.parse import quote
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import padding
+
+from recce.connect_to_cloud import (
+    connect_to_cloud_background_task,
+    decrypt_code,
+    generate_key_pair,
+    is_callback_server_running,
+    prepare_connection_url,
+)
+
+
+class ConnectToCloudTests(unittest.TestCase):
+
+    def test_generate_key_pair(self):
+        private_key, public_key = generate_key_pair()
+        self.assertIsNotNone(private_key)
+        self.assertIsNotNone(public_key)
+        self.assertEqual(private_key.public_key().public_numbers(), public_key.public_numbers())
+
+    def test_prepare_connection_url(self):
+        _, public_key = generate_key_pair()
+        url, port = prepare_connection_url(public_key)
+        self.assertIn("connect?", url)
+        self.assertTrue(port >= 10000 and port <= 15000)
+
+    def test_decrypt_code(self):
+        private_key, public_key = generate_key_pair()
+        test_string = "recce-api-token-123"
+        ciphertext = public_key.encrypt(
+            test_string.encode(),
+            padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None),
+        )
+        b64_ciphertext = base64.b64encode(ciphertext).decode()
+        result = decrypt_code(private_key, b64_ciphertext)
+        self.assertEqual(result, test_string)
+
+    @patch("recce.connect_to_cloud.update_recce_api_token")
+    @patch("recce.connect_to_cloud.update_onboarding_state")
+    @patch("recce.connect_to_cloud.RecceCloud")
+    def test_handle_callback_request_success(self, mock_recce_cloud, mock_update_state, mock_update_token):
+        private_key, public_key = generate_key_pair()
+
+        # Prepare encrypted token
+        test_token = "recce-api-token-xyz"
+        ciphertext = public_key.encrypt(
+            test_token.encode(),
+            padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None),
+        )
+        encrypted_b64 = base64.b64encode(ciphertext).decode()
+
+        # Set up mocks
+        mock_recce_cloud.return_value.verify_token.return_value = True
+
+        from recce.connect_to_cloud import handle_callback_request
+
+        result = handle_callback_request(f"code={quote(encrypted_b64)}", private_key)
+
+        assert result == test_token
+        mock_update_token.assert_called_once_with(test_token)
+        mock_update_state.assert_called_once_with(test_token, False)
+
+    def test_is_callback_server_running(self):
+        # Should return False by default
+        self.assertFalse(is_callback_server_running())
+
+    @patch("recce.connect_to_cloud.run_one_time_http_server")
+    def test_connect_to_cloud_background_task_runs(self, mock_server):
+        private_key, public_key = generate_key_pair()
+        url, port = prepare_connection_url(public_key)
+
+        connect_to_cloud_background_task(private_key, port, url)
+        mock_server.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_core.py

@@ -1,5 +1,152 @@
 # noinspection PyUnresolvedReferences
-from tests.adapter.dbt_adapter.conftest import dbt_test_helper
+import os
+import unittest
+from datetime import datetime
+
+from recce.core import RecceContext
+from recce.models import Check, Run, RunType
+from recce.state import ArtifactsRoot, FileStateLoader, RecceState
+from tests.adapter.dbt_adapter.conftest import dbt_test_helper  # noqa: F401
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+
+class TestRecceState(unittest.TestCase):
+    def test_load(self):
+        run = Run(type=RunType.QUERY, params=dict(sql_template="select * from users"))
+        check = Check(name="check 1", description="desc 1", type=run.type, params=run.params)
+
+        state = RecceState(runs=[run], checks=[check])
+        json_content = state.to_json()
+        new_state = RecceState.from_json(json_content)
+
+        run_loaded = new_state.runs[0]
+        check_loaded = new_state.checks[0]
+
+        assert run.run_id == run_loaded.run_id
+        assert check.check_id == check_loaded.check_id
+
+    def test_merge_checks(self):
+        check1 = Check(name="test1", description="", type="query")
+        check2 = Check(name="test2", description="", type="query", updated_at=datetime(2000, 1, 1))
+        check2_2 = Check(
+            name="test2_2", description="", type="query", updated_at=datetime(2020, 1, 1), check_id=check2.check_id
+        )
+        check3 = Check(name="test3", description="", type="query")
+
+        context = RecceContext()
+        state = RecceState(checks=[check1], runs=[])
+        context.import_state(state)
+        self.assertEqual(1, len(context.checks))
+        self.assertEqual(check1.name, context.checks[0].name)
+
+        context = RecceContext(checks=[check1, check2])
+        state = RecceState(checks=[check1, check2_2, check3], runs=[])
+        context.import_state(state)
+        self.assertEqual(3, len(context.checks))
+        self.assertEqual(check2_2.name, context.checks[1].name)
+
+    def test_merge_preset_checks(self):
+        check1 = Check(
+            name="test1",
+            description="test1",
+            type="query",
+            params=dict(foo="bar"),
+            updated_at=datetime(2000, 1, 1),
+            is_preset=True,
+        )
+        check2 = Check(
+            name="test2",
+            description="test2",
+            type="query",
+            params=dict(foo="bar"),
+            updated_at=datetime(2001, 1, 1),
+            is_preset=True,
+        )
+
+        context = RecceContext(checks=[check1])
+        state = RecceState(checks=[check2], runs=[])
+        context.import_state(state)
+        self.assertEqual(1, len(context.checks))
+        self.assertEqual(check2.name, context.checks[0].name)
+
+        context = RecceContext(checks=[check2])
+        state = RecceState(checks=[check1], runs=[])
+        context.import_state(state)
+        self.assertEqual(1, len(context.checks))
+        self.assertEqual(check2.name, context.checks[0].name)
+
+    def test_revert_checks(self):
+        check1 = Check(name="test1", description="", type="query")
+        check2 = Check(name="test2", description="", type="query")
+        check2_2 = Check(name="test2_2", description="", type="query", check_id=check2.check_id)
+        check3 = Check(name="test3", description="", type="query")
+
+        context = RecceContext(checks=[check1, check2])
+        state = RecceState(checks=[check2_2, check3], runs=[])
+        context.import_state(state, merge=False)
+        self.assertEqual(2, len(context.checks))
+        self.assertEqual(check2_2.name, context.checks[0].name)
+
+    def test_merge_runs(self):
+        run1 = Run(type="query")
+        run2 = Run(type="query")
+        run3 = Run(type="query")
+
+        context = RecceContext(runs=[])
+        state = RecceState(runs=[run1])
+        context.import_state(state)
+        self.assertEqual(1, len(context.runs))
+
+        context = RecceContext(runs=[run1, run2])
+        state = RecceState(runs=[run2, run3])
+        context.import_state(state)
+        self.assertEqual(3, len(context.runs))
+
+    def test_merge_dbt_artifacts(self):
+        import json
+        import os
+
+        with open(os.path.join(current_dir, "manifest.json"), "r") as f:
+            manifest = json.load(f)
+        manifest["metadata"]["generated_at"] = "2000-01-01T00:00:00Z"
+        artifacts = ArtifactsRoot(
+            base=dict(
+                manifest=manifest,
+            ),
+            current=dict(
+                manifest=manifest,
+            ),
+        )
+
+        from tests.adapter.dbt_adapter.dbt_test_helper import DbtTestHelper
+
+        adapter = DbtTestHelper().adapter
+        adapter.import_artifacts(artifacts)
+        self.assertNotEqual(adapter.base_manifest.metadata.invocation_id, manifest.get("metadata").get("invocation_id"))
+
+        manifest["metadata"]["generated_at"] = "2099-01-01T00:00:00Z"
+        adapter.import_artifacts(artifacts)
+        self.assertEqual(adapter.base_manifest.metadata.invocation_id, manifest.get("metadata").get("invocation_id"))
+
+    def test_state_loader(self):
+        # copy ./recce_state.json to temp and open
+
+        # use library to create a temp file in the context
+        import os
+        import shutil
+        import tempfile
+
+        with tempfile.NamedTemporaryFile() as f:
+            # copy ./recce_state.json to temp file
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            state_file = os.path.join(current_dir, "recce_state.json")
+            shutil.copy(state_file, f.name)
+
+            # load the state file
+            state_loader = FileStateLoader(state_file=f.name)
+            state = state_loader.load()
+            assert len(state.runs) == 17
 
 
 def test_lineage_diff(dbt_test_helper):
@@ -21,7 +168,7 @@ def test_lineage_diff(dbt_test_helper):
     dbt_test_helper.create_model("model1", sql_model1, sql_model1)
     dbt_test_helper.create_model("model2", sql_model2, sql_model2_)
     result = dbt_test_helper.context.get_lineage_diff()
-    nodediff = result.diff.get('model1')
+    nodediff = result.diff.get("model1")
     assert nodediff is None
-    nodediff2 = result.diff.get('model2')
-    assert nodediff2 is not None and nodediff2.change_status == 'modified' and nodediff2.change.category == 'non_breaking'
+    nodediff2 = result.diff.get("model2")
+    assert nodediff2 is not None and nodediff2.change_status == "modified"

tests/test_dbt.py

@@ -1,18 +1,18 @@
 import os
 from unittest import TestCase
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock
 
-from recce.adapter.dbt_adapter import load_manifest, load_catalog, DbtAdapter
+from recce.adapter.dbt_adapter import DbtAdapter, load_catalog, load_manifest
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 
 
 class TestAdapterLineage(TestCase):
     def setUp(self) -> None:
-        self.manifest = load_manifest(path=os.path.join(current_dir, 'manifest.json'))
+        self.manifest = load_manifest(path=os.path.join(current_dir, "manifest.json"))
         assert self.manifest is not None
 
-        self.catalog = load_catalog(path=os.path.join(current_dir, 'catalog.json'))
+        self.catalog = load_catalog(path=os.path.join(current_dir, "catalog.json"))
         assert self.catalog is not None
 
     def tearDown(self):
@@ -22,8 +22,8 @@ class TestAdapterLineage(TestCase):
         dbt_adapter = DbtAdapter(curr_manifest=self.manifest)
         lineage = dbt_adapter.get_lineage()
         assert lineage is not None
-        assert lineage['nodes']['model.jaffle_shop.orders'] is not None
-        assert 'columns' not in lineage['nodes']['model.jaffle_shop.orders']
+        assert lineage["nodes"]["model.jaffle_shop.orders"] is not None
+        assert "columns" not in lineage["nodes"]["model.jaffle_shop.orders"]
 
     def test_load_lineage_with_catalog(self):
         mock_adapter = MagicMock()
@@ -33,4 +33,4 @@ class TestAdapterLineage(TestCase):
         dbt_adapter.adapter = mock_adapter
         lineage = dbt_adapter.get_lineage()
         assert lineage is not None
-        assert len(lineage['nodes']['model.jaffle_shop.orders']['columns']) == 9
+        assert len(lineage["nodes"]["model.jaffle_shop.orders"]["columns"]) == 9

tests/test_mcp_server.py

@@ -0,0 +1,332 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+# Skip all tests in this module if mcp is not available
+pytest.importorskip("mcp")
+
+from recce.core import RecceContext  # noqa: E402
+from recce.mcp_server import RecceMCPServer, run_mcp_server  # noqa: E402
+from recce.models.types import LineageDiff  # noqa: E402
+from recce.server import RecceServerMode  # noqa: E402
+from recce.tasks.profile import ProfileDiffTask  # noqa: E402
+from recce.tasks.query import QueryDiffTask, QueryTask  # noqa: E402
+from recce.tasks.rowcount import RowCountDiffTask  # noqa: E402
+
+
+@pytest.fixture
+def mcp_server():
+    """Fixture to create a RecceMCPServer instance for testing"""
+    mock_context = MagicMock(spec=RecceContext)
+    return RecceMCPServer(mock_context), mock_context
+
+
+class TestRecceMCPServer:
+    """Test cases for the RecceMCPServer class"""
+
+    def test_server_initialization(self, mcp_server):
+        """Test that the MCP server initializes correctly"""
+        server, mock_context = mcp_server
+        assert server.context == mock_context
+        assert server.server is not None
+        assert server.server.name == "recce"
+
+    @pytest.mark.asyncio
+    async def test_tool_lineage_diff(self, mcp_server):
+        """Test the lineage_diff tool"""
+        server, mock_context = mcp_server
+        # Mock the lineage diff response
+        mock_lineage_diff = MagicMock(spec=LineageDiff)
+        mock_lineage_diff.model_dump.return_value = {
+            "base": {
+                "nodes": {
+                    "model.project.model_a": {
+                        "name": "model_a",
+                        "resource_type": "model",
+                        "config": {"materialized": "view"},
+                    },
+                    "model.project.model_b": {
+                        "name": "model_b",
+                        "resource_type": "model",
+                    },
+                },
+                "parent_map": {
+                    "model.project.model_a": [],
+                    "model.project.model_b": ["model.project.model_a"],
+                },
+            },
+            "current": {
+                "nodes": {
+                    "model.project.model_a": {
+                        "name": "model_a",
+                        "resource_type": "model",
+                        "config": {"materialized": "view"},
+                    },
+                    "model.project.model_b": {
+                        "name": "model_b",
+                        "resource_type": "model",
+                    },
+                },
+                "parent_map": {
+                    "model.project.model_a": [],
+                    "model.project.model_b": ["model.project.model_a"],
+                },
+            },
+            "diff": {
+                "model.project.model_a": {"change_status": "modified"},
+            },
+        }
+        mock_context.get_lineage_diff.return_value = mock_lineage_diff
+        mock_context.adapter.select_nodes.return_value = {
+            "model.project.model_a",
+            "model.project.model_b",
+        }
+
+        # Execute the method
+        result = await server._tool_lineage_diff({})
+
+        # Verify the result structure
+        assert "nodes" in result
+        assert "parent_map" in result
+
+        # Verify nodes is a DataFrame dict with columns and data
+        nodes = result["nodes"]
+        assert "columns" in nodes
+        assert "data" in nodes
+
+        # Verify data is a list with 2 rows
+        assert isinstance(nodes["data"], list)
+        assert len(nodes["data"]) == 2
+
+        mock_context.get_lineage_diff.assert_called_once()
+        mock_context.adapter.select_nodes.assert_called()
+
+    @pytest.mark.asyncio
+    async def test_tool_schema_diff(self, mcp_server):
+        """Test the schema_diff tool"""
+        server, mock_context = mcp_server
+        # Mock the lineage diff response with schema information
+        mock_lineage_diff = MagicMock(spec=LineageDiff)
+        mock_lineage_diff.model_dump.return_value = {
+            "base": {
+                "nodes": {
+                    "model.project.model_a": {
+                        "name": "model_a",
+                        "resource_type": "model",
+                        "columns": {
+                            "id": {"name": "id", "type": "integer"},
+                            "name": {"name": "name", "type": "text"},
+                        },
+                    },
+                },
+            },
+            "current": {
+                "nodes": {
+                    "model.project.model_a": {
+                        "name": "model_a",
+                        "resource_type": "model",
+                        "columns": {
+                            "id": {"name": "id", "type": "integer"},
+                            "name": {"name": "name", "type": "text"},
+                            "age": {"name": "age", "type": "integer"},
+                        },
+                    },
+                },
+            },
+        }
+        mock_context.get_lineage_diff.return_value = mock_lineage_diff
+        mock_context.adapter.select_nodes.return_value = {"model.project.model_a"}
+
+        # Execute the method
+        result = await server._tool_schema_diff({})
+
+        # Verify the result is a DataFrame dict with columns and data
+        assert "columns" in result
+        assert "data" in result
+        assert "limit" in result
+        assert "more" in result
+
+        # Verify limit and more fields
+        assert result["limit"] == 100
+        assert isinstance(result["more"], bool)
+        assert isinstance(result["data"], list)
+        # Verify the data contains the added column
+        assert len(result["data"]) > 0
+
+        mock_context.get_lineage_diff.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_tool_row_count_diff(self, mcp_server):
+        """Test the row_count_diff tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = {"results": [{"node_id": "model.project.my_model", "base": 100, "current": 105, "diff": 5}]}
+
+        with patch.object(RowCountDiffTask, "execute", return_value=mock_result):
+            result = await server._tool_row_count_diff({"node_names": ["my_model"]})
+
+        # Verify the result
+        assert result == mock_result
+        assert "results" in result
+
+    @pytest.mark.asyncio
+    async def test_tool_query(self, mcp_server):
+        """Test the query tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {
+            "columns": ["id", "name"],
+            "data": [[1, "Alice"], [2, "Bob"]],
+        }
+
+        with patch.object(QueryTask, "execute", return_value=mock_result):
+            result = await server._tool_query({"sql_template": "SELECT * FROM {{ ref('my_model') }}", "base": False})
+
+        # Verify the result
+        assert "columns" in result
+        assert "data" in result
+        mock_result.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_tool_query_with_base_flag(self, mcp_server):
+        """Test the query tool with base environment flag"""
+        server, _ = mcp_server
+        mock_result = {"columns": ["id"], "data": [[1]]}
+
+        with patch.object(QueryTask, "execute", return_value=mock_result) as mock_execute:
+            with patch.object(QueryTask, "__init__", return_value=None):
+                task = QueryTask(params={"sql_template": "SELECT 1"})
+                task.is_base = True
+                task.execute = mock_execute
+
+                result = await server._tool_query({"sql_template": "SELECT 1", "base": True})
+
+                # Verify base flag was set (would need to inspect task creation)
+                assert result == mock_result
+
+    @pytest.mark.asyncio
+    async def test_tool_query_diff(self, mcp_server):
+        """Test the query_diff tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {
+            "diff": {
+                "added": [[3, "Charlie"]],
+                "removed": [[1, "Alice"]],
+                "modified": [],
+            }
+        }
+
+        with patch.object(QueryDiffTask, "execute", return_value=mock_result):
+            result = await server._tool_query_diff(
+                {
+                    "sql_template": "SELECT * FROM {{ ref('my_model') }}",
+                    "primary_keys": ["id"],
+                }
+            )
+
+        # Verify the result
+        assert "diff" in result
+        mock_result.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_tool_profile_diff(self, mcp_server):
+        """Test the profile_diff tool"""
+        server, _ = mcp_server
+        # Mock the task execution
+        mock_result = MagicMock()
+        mock_result.model_dump.return_value = {
+            "columns": {
+                "id": {
+                    "base": {"min": 1, "max": 100, "avg": 50.5},
+                    "current": {"min": 1, "max": 105, "avg": 53.0},
+                }
+            }
+        }
+
+        with patch.object(ProfileDiffTask, "execute", return_value=mock_result):
+            result = await server._tool_profile_diff({"model": "my_model", "columns": ["id"]})
+
+        # Verify the result
+        assert "columns" in result
+        mock_result.model_dump.assert_called_once_with(mode="json")
+
+    @pytest.mark.asyncio
+    async def test_error_handling(self, mcp_server):
+        """Test error handling in tool execution"""
+        server, mock_context = mcp_server
+        # Make get_lineage_diff raise an exception
+        mock_context.get_lineage_diff.side_effect = Exception("Test error")
+
+        # The method should raise the exception
+        with pytest.raises(Exception, match="Test error"):
+            await server._tool_lineage_diff({})
+
+
+class TestRunMCPServer:
+    """Test cases for the run_mcp_server function"""
+
+    @pytest.mark.asyncio
+    @patch("recce.mcp_server.load_context")
+    @patch.object(RecceMCPServer, "run")
+    async def test_run_mcp_server(self, mock_run, mock_load_context):
+        """Test the run_mcp_server entry point"""
+        # Mock the context
+        mock_context = MagicMock(spec=RecceContext)
+        mock_load_context.return_value = mock_context
+
+        # Mock the server run method
+        mock_run.return_value = None
+
+        # Run the server
+        await run_mcp_server(project_dir="/test/path")
+
+        # Verify context was loaded with correct kwargs
+        mock_load_context.assert_called_once_with(project_dir="/test/path")
+
+        # Verify server was run
+        mock_run.assert_called_once()
+
+    @pytest.mark.asyncio
+    @patch("recce.mcp_server.load_context")
+    async def test_run_mcp_server_context_error(self, mock_load_context):
+        """Test run_mcp_server handles context loading errors"""
+        # Make load_context raise an exception
+        mock_load_context.side_effect = FileNotFoundError("manifest.json not found")
+
+        # The function should raise the exception
+        with pytest.raises(FileNotFoundError):
+            await run_mcp_server()
+
+
+def test_mcp_cli_command_exists():
+    """Test that the mcp-server CLI command is registered"""
+    from recce.cli import cli
+
+    # Check that mcp_server is in the CLI commands
+    commands = [cmd.name for cmd in cli.commands.values()]
+    assert "mcp_server" in commands or "mcp-server" in commands
+
+
+class TestMCPServerModes:
+    """Test cases for MCP server mode functionality"""
+
+    def test_server_mode_default(self):
+        """Test that server mode is the default when not specified"""
+        mock_context = MagicMock(spec=RecceContext)
+        server = RecceMCPServer(mock_context)
+
+        # Default mode should be server
+        assert server.mode == RecceServerMode.server
+
+    def test_non_server_mode_restricts_tools(self):
+        """Test that non-server mode (preview, read-only) restricts diff tools"""
+        mock_context = MagicMock(spec=RecceContext)
+        server = RecceMCPServer(mock_context, mode=RecceServerMode.preview)
+
+        # Verify mode is set correctly
+        assert server.mode == RecceServerMode.preview
+        # Verify it's not server mode
+        assert server.mode != RecceServerMode.server

tests/test_pull_request.py

@@ -4,7 +4,7 @@ from unittest.mock import patch
 import pytest
 import requests
 
-from recce.pull_request import fetch_pr_metadata_from_event_path, _fetch_pr_title
+from recce.pull_request import _fetch_pr_title, fetch_pr_metadata_from_event_path
 
 
 @pytest.fixture