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

tests/tasks/test_row_count.py

@@ -17,21 +17,21 @@ def test_row_count(dbt_test_helper):
         2,Bob,25
         """
 
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr, unique_id='model.customers')
-    task = RowCountDiffTask(dict(node_names=['customers']))
+    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr, unique_id="model.customers")
+    task = RowCountDiffTask(dict(node_names=["customers"]))
     run_result = task.execute()
-    assert run_result['customers']['base'] == 2
-    assert run_result['customers']['curr'] == 3
+    assert run_result["customers"]["base"] == 2
+    assert run_result["customers"]["curr"] == 3
 
-    task = RowCountDiffTask(dict(node_names=['customers_']))
+    task = RowCountDiffTask(dict(node_names=["customers_"]))
     run_result = task.execute()
-    assert run_result['customers_']['base'] is None
-    assert run_result['customers_']['curr'] is None
+    assert run_result["customers_"]["base"] is None
+    assert run_result["customers_"]["curr"] is None
 
-    task = RowCountDiffTask(dict(node_ids=['model.customers']))
+    task = RowCountDiffTask(dict(node_ids=["model.customers"]))
     run_result = task.execute()
-    assert run_result['customers']['base'] == 2
-    assert run_result['customers']['curr'] == 3
+    assert run_result["customers"]["base"] == 2
+    assert run_result["customers"]["curr"] == 3
 
 
 def test_row_count_with_selector(dbt_test_helper):
@@ -49,13 +49,14 @@ def test_row_count_with_selector(dbt_test_helper):
         """
 
     dbt_test_helper.create_model("model_1", csv_data_1, csv_data_2, depends_on=[])
-    dbt_test_helper.create_model("model_2", csv_data_1, csv_data_1, depends_on=['model_1'],
-                                 package_name='other_package')
-    task = RowCountDiffTask(dict(select='model_1'))
+    dbt_test_helper.create_model(
+        "model_2", csv_data_1, csv_data_1, depends_on=["model_1"], package_name="other_package"
+    )
+    task = RowCountDiffTask(dict(select="model_1"))
     run_result = task.execute()
     assert len(run_result) == 1
 
-    task = RowCountDiffTask(dict(select='model_1+'))
+    task = RowCountDiffTask(dict(select="model_1+"))
     run_result = task.execute()
     assert len(run_result) == 2
 
@@ -66,51 +67,69 @@ def test_validator():
     validator = RowCountDiffCheckValidator()
 
     def validate(params: dict):
-        validator.validate({
-            'name': 'test',
-            'type': 'row_count_diff',
-            'params': params,
-        })
+        validator.validate(
+            {
+                "name": "test",
+                "type": "row_count_diff",
+                "params": params,
+            }
+        )
 
     # Select all modesl
     validate({})
 
     # Select by node name
-    validate({
-        'node_names': ['abc'],
-    })
+    validate(
+        {
+            "node_names": ["abc"],
+        }
+    )
     with pytest.raises(ValueError):
-        validate({
-            'node_names': 'abc',
-        })
+        validate(
+            {
+                "node_names": "abc",
+            }
+        )
 
     # Select by node id
-    validate({
-        'node_ids': ['model.abc'],
-    })
+    validate(
+        {
+            "node_ids": ["model.abc"],
+        }
+    )
 
     # Select by selector
-    validate({
-        'select': 'customers',
-        'exclude': 'customers',
-        'packages': ['jaffle_shop'],
-        'view_mode': 'all',
-    })
+    validate(
+        {
+            "select": "customers",
+            "exclude": "customers",
+            "packages": ["jaffle_shop"],
+            "view_mode": "all",
+        }
+    )
 
     # packages should be an array
     with pytest.raises(ValueError):
-        validate({
-            'packages': 'jaffle_shop',
-        })
+        validate(
+            {
+                "packages": "jaffle_shop",
+            }
+        )
 
     # view_mode should be 'all' or 'changed_models'
-    validate({
-        'view_mode': None,
-    })
-    validate({
-        'view_mode': 'all',
-    })
+    validate(
+        {
+            "view_mode": None,
+        }
+    )
+    validate(
+        {
+            "view_mode": "all",
+        }
+    )
     with pytest.raises(ValueError):
-        validate({
-            'view_mode': 'abc',
-        })
+        validate(
+            {
+                "view_mode": "abc",
+            }
+        )

tests/tasks/test_schema.py

@@ -4,58 +4,75 @@ from unittest.mock import MagicMock
 
 import pytest
 
-from recce.adapter.dbt_adapter import load_manifest, load_catalog, DbtAdapter
+from recce.adapter.dbt_adapter import DbtAdapter, load_catalog, load_manifest
 from recce.core import RecceContext, set_default_context
 from recce.run import schema_diff_should_be_approved
 
 
 def test_validator():
     from recce.tasks.schema import SchemaDiffCheckValidator
+
     validator = SchemaDiffCheckValidator()
 
     def validate(params: dict):
-        validator.validate({
-            'name': 'test',
-            'type': 'schema_diff',
-            'params': params,
-        })
+        validator.validate(
+            {
+                "name": "test",
+                "type": "schema_diff",
+                "params": params,
+            }
+        )
 
     # Select all models
     validate({})
 
     # Select by node name
-    validate({
-        'node_id': 'abc',
-    })
-    validate({
-        'node_id': ['abc'],
-    })
+    validate(
+        {
+            "node_id": "abc",
+        }
+    )
+    validate(
+        {
+            "node_id": ["abc"],
+        }
+    )
 
     # Select by selector
-    validate({
-        'select': 'customers',
-        'exclude': 'customers',
-        'packages': ['jaffle_shop'],
-        'view_mode': 'all',
-    })
+    validate(
+        {
+            "select": "customers",
+            "exclude": "customers",
+            "packages": ["jaffle_shop"],
+            "view_mode": "all",
+        }
+    )
 
     # packages should be an array
     with pytest.raises(ValueError):
-        validate({
-            'packages': 'jaffle_shop',
-        })
+        validate(
+            {
+                "packages": "jaffle_shop",
+            }
+        )
 
     # view_mode should be 'all' or 'changed_models'
-    validate({
-        'view_mode': None,
-    })
-    validate({
-        'view_mode': 'all',
-    })
+    validate(
+        {
+            "view_mode": None,
+        }
+    )
+    validate(
+        {
+            "view_mode": "all",
+        }
+    )
     with pytest.raises(ValueError):
-        validate({
-            'view_mode': 'abc',
-        })
+        validate(
+            {
+                "view_mode": "abc",
+            }
+        )
 
 
 test_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -65,8 +82,8 @@ class TestSchemaDiffAutoApprove(TestCase):
 
     def setUp(self):
         self.default_context = MagicMock(spec=RecceContext)
-        manifest = load_manifest(path=os.path.join(test_root_path, 'manifest.json'))
-        catalog = load_catalog(path=os.path.join(test_root_path, 'catalog.json'))
+        manifest = load_manifest(path=os.path.join(test_root_path, "manifest.json"))
+        catalog = load_catalog(path=os.path.join(test_root_path, "catalog.json"))
         dbt_adapter = DbtAdapter(curr_manifest=manifest, curr_catalog=catalog)
         self.default_context.adapter = dbt_adapter
 
@@ -80,20 +97,26 @@ class TestSchemaDiffAutoApprove(TestCase):
 
     def test_schema_diff_should_be_approved(self):
         # Node_id is string
-        is_approved = schema_diff_should_be_approved({
-            'node_id': 'model.jaffle_shop.customers',
-        })
+        is_approved = schema_diff_should_be_approved(
+            {
+                "node_id": "model.jaffle_shop.customers",
+            }
+        )
         assert is_approved is True
 
         # Node_id is list
-        is_approved = schema_diff_should_be_approved({
-            'node_id': ['model.jaffle_shop.customers'],
-        })
+        is_approved = schema_diff_should_be_approved(
+            {
+                "node_id": ["model.jaffle_shop.customers"],
+            }
+        )
         assert is_approved is True
 
         # Select all models
-        self.default_context.adapter.select_nodes.return_value = ['model.jaffle_shop.customers']
-        is_approved = schema_diff_should_be_approved({
-            'select': 'customers',
-        })
+        self.default_context.adapter.select_nodes.return_value = ["model.jaffle_shop.customers"]
+        is_approved = schema_diff_should_be_approved(
+            {
+                "select": "customers",
+            }
+        )
         assert is_approved is True

tests/tasks/test_top_k.py

@@ -38,10 +38,10 @@ def test_top_k(dbt_test_helper):
     #     'valids': 4,
     #     'total': 4
     # }
-    assert run_result['current']['values'][0] == 'Bob'
-    assert run_result['current']['counts'][0] == 2
-    assert run_result['current']['valids'] == 4
-    assert run_result['current']['total'] == 4
+    assert run_result["current"]["values"][0] == "Bob"
+    assert run_result["current"]["counts"][0] == 2
+    assert run_result["current"]["valids"] == 4
+    assert run_result["current"]["total"] == 4
 
     # {
     #     'values': ['Bob', 'Alice', 'Charlie'],
@@ -49,25 +49,29 @@ def test_top_k(dbt_test_helper):
     #     'valids': 3,
     #     'total': 4
     # }
-    assert run_result['base']['counts'][0] == 1
-    assert run_result['base']['valids'] == 3
-    assert run_result['base']['total'] == 4
+    assert run_result["base"]["counts"][0] == 1
+    assert run_result["base"]["valids"] == 3
+    assert run_result["base"]["total"] == 4
 
 
 def test_validator():
     def validate(params: dict = {}, view_options: dict = {}):
-        TopKDiffCheckValidator().validate({
-            'name': 'test',
-            'type': 'top_k_diff',
-            'params': params,
-            'view_options': view_options,
-        })
+        TopKDiffCheckValidator().validate(
+            {
+                "name": "test",
+                "type": "top_k_diff",
+                "params": params,
+                "view_options": view_options,
+            }
+        )
 
-    validate({
-        "model": "customers",
-        "column_name": "name",
-        "k": 50,
-    })
+    validate(
+        {
+            "model": "customers",
+            "column_name": "name",
+            "k": 50,
+        }
+    )
 
     with pytest.raises(ValueError):
         validate({})

tests/tasks/test_valuediff.py

@@ -1,6 +1,6 @@
 import pytest
 
-from recce.tasks import ValueDiffTask, ValueDiffDetailTask
+from recce.tasks import ValueDiffDetailTask, ValueDiffTask
 
 
 def test_value_diff(dbt_test_helper):
@@ -19,13 +19,13 @@ def test_value_diff(dbt_test_helper):
         """
 
     dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(model='customers', primary_key=['customer_id'])
+    params = dict(model="customers", primary_key=["customer_id"])
     task = ValueDiffTask(params)
     run_result = task.execute()
     assert len(run_result.data.columns) == 3
     assert len(run_result.data.data) == 3
 
-    params = dict(model='customers', primary_key=['customer_id'])
+    params = dict(model="customers", primary_key=["customer_id"])
     task = ValueDiffDetailTask(params)
     run_result = task.execute()
     assert len(run_result.columns) == 5
@@ -36,39 +36,50 @@ def test_validator():
     from recce.tasks.valuediff import ValueDiffCheckValidator
 
     def validate(params: dict = {}, view_options: dict = {}):
-        ValueDiffCheckValidator().validate({
-            'name': 'test',
-            'type': 'value_diff',
-            'params': params,
-            'view_options': view_options,
-        })
+        ValueDiffCheckValidator().validate(
+            {
+                "name": "test",
+                "type": "value_diff",
+                "params": params,
+                "view_options": view_options,
+            }
+        )
 
-    validate({
-        'model': 'customers',
-        'primary_key': 'customer_id',
-    })
-    validate({
-        'model': 'customers',
-        'primary_key': ['customer_id'],
-    })
-    validate({
-        'model': 'customers',
-        'primary_key': ['customer_id'],
-        'columns': ['name', 'age'],
-    })
+    validate(
+        {
+            "model": "customers",
+            "primary_key": "customer_id",
+        }
+    )
+    validate(
+        {
+            "model": "customers",
+            "primary_key": ["customer_id"],
+        }
+    )
+    validate(
+        {
+            "model": "customers",
+            "primary_key": ["customer_id"],
+            "columns": ["name", "age"],
+        }
+    )
 
     with pytest.raises(ValueError):
-        validate({
-        })
+        validate({})
 
     with pytest.raises(ValueError):
-        validate({
-            'model': 'customers',
-        })
+        validate(
+            {
+                "model": "customers",
+            }
+        )
 
     with pytest.raises(ValueError):
-        validate({
-            'model': 'customers',
-            'primary_key': ['customer_id'],
-            'columns': 'name',
-        })
+        validate(
+            {
+                "model": "customers",
+                "primary_key": ["customer_id"],
+                "columns": "name",
+            }
+        )

tests/test_cli.py

@@ -1,20 +1,22 @@
 from unittest import TestCase
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
 
 from click.testing import CliRunner
 
-from recce.cli import server as cli_command_server, run as cli_command_run
+from recce.cli import run as cli_command_run
+from recce.cli import server as cli_command_server
 from recce.core import RecceContext
 from recce.state import RecceStateLoader
 
 
 def test_cmd_version():
-    from recce.cli import version
     from recce import __version__
+    from recce.cli import version
+
     runner = CliRunner()
     result = runner.invoke(version, [])
     assert result.exit_code == 0
-    assert result.output.replace('\n', '') == __version__
+    assert result.output.replace("\n", "") == __version__
 
 
 class TestCommandServer(TestCase):
@@ -22,90 +24,101 @@ class TestCommandServer(TestCase):
         self.runner = CliRunner()
         pass
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.cli.uvicorn.run')
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("recce.cli.uvicorn.run")
     def test_cmd_server(self, mock_run, mock_verify_required_artifacts):
         from recce.server import app
+
         mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server, ['--host', 'unittest', '--port', 5566])
-        mock_run.assert_called_once_with(app, host='unittest', port=5566, lifespan='on')
+        self.runner.invoke(cli_command_server, ["--host", "unittest", "--port", 5566])
+        mock_run.assert_called_once_with(app, host="unittest", port=5566, lifespan="on")
 
-    @patch('recce.cli.uvicorn.run')
+    @patch("recce.cli.uvicorn.run")
     def test_cmd_server_with_cloud_without_password(self, mock_run):
         # Should fail if no password is provided
-        result = self.runner.invoke(cli_command_server, ['--cloud'])
+        result = self.runner.invoke(cli_command_server, ["--cloud"])
         assert result.exit_code == 1
 
-    @patch('recce.cli.uvicorn.run')
+    @patch("recce.cli.uvicorn.run")
     def test_cmd_server_with_cloud_without_token(self, mock_run):
         # Should fail if no token is provided
-        result = self.runner.invoke(cli_command_server, ['--cloud', '--password', 'unittest'])
+        result = self.runner.invoke(cli_command_server, ["--cloud", "--password", "unittest"])
         assert result.exit_code == 1
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.util.recce_cloud.get_recce_cloud_onboarding_state')
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.cli.RecceStateLoader')
-    def test_cmd_server_with_cloud(self, mock_state_loader_class, mock_run, mock_get_recce_cloud_onboarding_state,
-                                   mock_verify_required_artifacts):
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("recce.util.recce_cloud.get_recce_cloud_onboarding_state")
+    @patch("recce.cli.uvicorn.run")
+    @patch("recce.cli.RecceStateLoader")
+    def test_cmd_server_with_cloud(
+        self, mock_state_loader_class, mock_run, mock_get_recce_cloud_onboarding_state, mock_verify_required_artifacts
+    ):
         mock_state_loader = MagicMock(spec=RecceStateLoader)
         mock_state_loader.verify.return_value = True
         mock_state_loader.review_mode = True
-        mock_get_recce_cloud_onboarding_state.return_value = 'completed'
+        mock_get_recce_cloud_onboarding_state.return_value = "completed"
         mock_verify_required_artifacts.return_value = True, None
 
         mock_state_loader_class.return_value = mock_state_loader
-        self.runner.invoke(cli_command_server, ['--cloud', '--password', 'unittest', '--cloud-token', 'unittest'])
+        self.runner.invoke(cli_command_server, ["--cloud", "--password", "unittest", "--cloud-token", "unittest"])
         mock_state_loader_class.assert_called_once()
         mock_run.assert_called_once()
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('os.path.isdir', side_effect=lambda path: True if path == 'existed_folder' else False)
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.server.AppState')
-    def test_cmd_server_with_single_env(self,
-                                        mock_app_state, mock_run, mock_isdir, mock_verify_required_artifacts):
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("os.path.isdir", side_effect=lambda path: True if path == "existed_folder" else False)
+    @patch("recce.cli.uvicorn.run")
+    @patch("recce.server.AppState")
+    def test_cmd_server_with_single_env(self, mock_app_state, mock_run, mock_isdir, mock_verify_required_artifacts):
         mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server,
-                           [
-                               '--target-path', 'existed_folder',
-                               '--target-base-path', 'non_existed_folder',
-                           ])
+        self.runner.invoke(
+            cli_command_server,
+            [
+                "--target-path",
+                "existed_folder",
+                "--target-base-path",
+                "non_existed_folder",
+            ],
+        )
         mock_run.assert_called_once()
 
         # Onboarding mode should be set to True
         app_state_call_args = mock_app_state.call_args
-        app_state_flag = app_state_call_args.kwargs['flag']
-        assert 'single_env_onboarding' in app_state_flag
-        assert app_state_flag['single_env_onboarding'] is True
-        assert 'show_relaunch_hint' in app_state_flag
-        assert app_state_flag['show_relaunch_hint'] is True
+        app_state_flag = app_state_call_args.kwargs["flag"]
+        assert "single_env_onboarding" in app_state_flag
+        assert app_state_flag["single_env_onboarding"] is True
+        assert "show_relaunch_hint" in app_state_flag
+        assert app_state_flag["show_relaunch_hint"] is True
 
         # The target_base_path should be set to the same as target_path
         verify_required_artifacts_args = mock_verify_required_artifacts.call_args
-        assert verify_required_artifacts_args.kwargs['target_path'] == verify_required_artifacts_args.kwargs[
-            'target_base_path']
-
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('os.path.isdir', side_effect=lambda path: True if path == 'existed_folder' else False)
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.server.AppState')
-    def test_cmd_server_with_single_env_but_review_mode_enabled(self,
-                                                                mock_app_state, mock_run, mock_isdir,
-                                                                mock_verify_required_artifacts):
+        assert (
+            verify_required_artifacts_args.kwargs["target_path"]
+            == verify_required_artifacts_args.kwargs["target_base_path"]
+        )
+
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("os.path.isdir", side_effect=lambda path: True if path == "existed_folder" else False)
+    @patch("recce.cli.uvicorn.run")
+    @patch("recce.server.AppState")
+    def test_cmd_server_with_single_env_but_review_mode_enabled(
+        self, mock_app_state, mock_run, mock_isdir, mock_verify_required_artifacts
+    ):
         mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server,
-                           [
-                               'existed_state_file',
-                               '--review',
-                               '--target-path', 'existed_folder',
-                               '--target-base-path', 'non_existed_folder',
-                           ])
+        self.runner.invoke(
+            cli_command_server,
+            [
+                "existed_state_file",
+                "--review",
+                "--target-path",
+                "existed_folder",
+                "--target-base-path",
+                "non_existed_folder",
+            ],
+        )
         mock_run.assert_called_once()
         app_state_call_args = mock_app_state.call_args
-        app_state_flag = app_state_call_args.kwargs['flag']
-        assert 'single_env_onboarding' in app_state_flag
-        assert app_state_flag['single_env_onboarding'] is False
+        app_state_flag = app_state_call_args.kwargs["flag"]
+        assert "single_env_onboarding" in app_state_flag
+        assert app_state_flag["single_env_onboarding"] is False
 
 
 class TestCommandRun(TestCase):
@@ -113,8 +126,8 @@ class TestCommandRun(TestCase):
         self.runner = CliRunner()
         pass
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.cli.cli_run')
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("recce.cli.cli_run")
     def test_cmd_run(self, mock_cli_run, mock_verify_required_artifacts):
         mock_verify_required_artifacts.return_value = True, None