recce-nightly 1.10.0.20250625__py3-none-any.whl → 1.30.0.20251221__py3-none-any.whl

tests/tasks/test_query.py

@@ -1,151 +0,0 @@
-import pytest
-
-from recce.tasks import QueryDiffTask, QueryTask
-
-
-def test_query_diff_in_client(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(sql_template='select * from {{ ref("customers") }}')
-    task = QueryTask(params)
-    run_result = task.execute()
-    assert len(run_result.current.data) == 3
-
-
-def test_query_diff_in_client(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(sql_template='select * from {{ ref("customers") }}')
-    task = QueryDiffTask(params)
-    run_result = task.execute()
-    assert len(run_result.base.data) == 3
-    assert len(run_result.current.data) == 3
-
-    params = dict(
-        base_sql_template='select * from {{ ref("customers") }} where customer_id <= 2',
-        sql_template='select * from {{ ref("customers") }}',
-    )
-    task = QueryDiffTask(params)
-    run_result = task.execute()
-    assert len(run_result.base.data) == 2
-    assert len(run_result.current.data) == 3
-
-
-def test_query_diff_in_warehouse(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(sql_template='select * from {{ ref("customers") }}', primary_keys=["customer_id"])
-    task = QueryDiffTask(params)
-    run_result = task.execute()
-    assert len(run_result.diff.data) == 2
-
-    params = dict(
-        base_sql_template='select * from {{ ref("customers") }} where customer_id == 1',
-        sql_template='select * from {{ ref("customers") }}',
-        primary_keys=["customer_id"],
-    )
-    task = QueryDiffTask(params)
-    run_result = task.execute()
-    assert len(run_result.diff.data) == 4
-
-
-def test_validator():
-    from recce.tasks.query import QueryCheckValidator, QueryDiffCheckValidator
-
-    def validate(params: dict = {}, view_options: dict = {}):
-        QueryCheckValidator().validate(
-            {
-                "name": "test",
-                "type": "query",
-                "params": params,
-                "view_options": view_options,
-            }
-        )
-
-    def validate_diff(params: dict = {}, view_options: dict = {}):
-        QueryDiffCheckValidator().validate(
-            {
-                "name": "test",
-                "type": "query_diff",
-                "params": params,
-                "view_options": view_options,
-            }
-        )
-
-    # query
-    validate({"sql_template": "select * from abc"})
-
-    # diff in client
-    validate_diff({"sql_template": "select * from abc"})
-    validate_diff(
-        {
-            "sql_template": "select * from abc",
-            "base_sql_template": "select * from abc",
-        }
-    )
-
-    # diff in warehouse
-    validate_diff(
-        {
-            "primary_keys": ["customer_id"],
-            "sql_template": "select * from abc",
-        }
-    )
-    validate_diff(
-        {"sql_template": "select * from abc", "base_sql_template": "select * from abc", "primary_keys": ["customer_id"]}
-    )
-    validate_diff(
-        {"sql_template": "select * from abc", "base_sql_template": "select * from abc", "primary_keys": ["customer_id"]}
-    )
-
-    # invalid
-    with pytest.raises(ValueError):
-        validate()
-
-    with pytest.raises(ValueError):
-        validate_diff()
-
-    with pytest.raises(ValueError):
-        validate_diff({"sql_template": 123, "primary_keys": "xyz"})
-
-    with pytest.raises(ValueError):
-        validate_diff({"sql_template": "s", "primary_keys": "xyz"})

tests/tasks/test_row_count.py

@@ -1,135 +0,0 @@
-import pytest
-
-from recce.tasks import RowCountDiffTask
-
-
-def test_row_count(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        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"]))
-    run_result = task.execute()
-    assert run_result["customers"]["base"] == 2
-    assert run_result["customers"]["curr"] == 3
-
-    task = RowCountDiffTask(dict(node_names=["customers_"]))
-    run_result = task.execute()
-    assert run_result["customers_"]["base"] is None
-    assert run_result["customers_"]["curr"] is None
-
-    task = RowCountDiffTask(dict(node_ids=["model.customers"]))
-    run_result = task.execute()
-    assert run_result["customers"]["base"] == 2
-    assert run_result["customers"]["curr"] == 3
-
-
-def test_row_count_with_selector(dbt_test_helper):
-    csv_data_1 = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_2 = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        """
-
-    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"))
-    run_result = task.execute()
-    assert len(run_result) == 1
-
-    task = RowCountDiffTask(dict(select="model_1+"))
-    run_result = task.execute()
-    assert len(run_result) == 2
-
-
-def test_validator():
-    from recce.tasks.rowcount import RowCountDiffCheckValidator
-
-    validator = RowCountDiffCheckValidator()
-
-    def validate(params: dict):
-        validator.validate(
-            {
-                "name": "test",
-                "type": "row_count_diff",
-                "params": params,
-            }
-        )
-
-    # Select all modesl
-    validate({})
-
-    # Select by node name
-    validate(
-        {
-            "node_names": ["abc"],
-        }
-    )
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "node_names": "abc",
-            }
-        )
-
-    # Select by node id
-    validate(
-        {
-            "node_ids": ["model.abc"],
-        }
-    )
-
-    # Select by selector
-    validate(
-        {
-            "select": "customers",
-            "exclude": "customers",
-            "packages": ["jaffle_shop"],
-            "view_mode": "all",
-        }
-    )
-
-    # packages should be an array
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "packages": "jaffle_shop",
-            }
-        )
-
-    # view_mode should be 'all' or 'changed_models'
-    validate(
-        {
-            "view_mode": None,
-        }
-    )
-    validate(
-        {
-            "view_mode": "all",
-        }
-    )
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "view_mode": "abc",
-            }
-        )

tests/tasks/test_schema.py

@@ -1,122 +0,0 @@
-import os
-from unittest import TestCase
-from unittest.mock import MagicMock
-
-import pytest
-
-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,
-            }
-        )
-
-    # Select all models
-    validate({})
-
-    # Select by node name
-    validate(
-        {
-            "node_id": "abc",
-        }
-    )
-    validate(
-        {
-            "node_id": ["abc"],
-        }
-    )
-
-    # Select by selector
-    validate(
-        {
-            "select": "customers",
-            "exclude": "customers",
-            "packages": ["jaffle_shop"],
-            "view_mode": "all",
-        }
-    )
-
-    # packages should be an array
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "packages": "jaffle_shop",
-            }
-        )
-
-    # view_mode should be 'all' or 'changed_models'
-    validate(
-        {
-            "view_mode": None,
-        }
-    )
-    validate(
-        {
-            "view_mode": "all",
-        }
-    )
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "view_mode": "abc",
-            }
-        )
-
-
-test_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-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"))
-        dbt_adapter = DbtAdapter(curr_manifest=manifest, curr_catalog=catalog)
-        self.default_context.adapter = dbt_adapter
-
-        dbt_adapter.adapter = MagicMock()
-        dbt_adapter.adapter.type.return_value = None
-
-        dbt_adapter.select_nodes = MagicMock()
-        # Base and Current will be the same
-        self.default_context.get_lineage.return_value = dbt_adapter.get_lineage()
-        set_default_context(self.default_context)
-
-    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",
-            }
-        )
-        assert is_approved is True
-
-        # Node_id is list
-        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",
-            }
-        )
-        assert is_approved is True

tests/tasks/test_top_k.py

@@ -1,77 +0,0 @@
-import pytest
-
-from recce.tasks import TopKDiffTask
-from recce.tasks.top_k import TopKDiffCheckValidator
-
-
-def test_top_k(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        4,Bob,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        4,,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-
-    params = dict(
-        model="customers",
-        column_name="name",
-        k=50,
-    )
-
-    task = TopKDiffTask(params)
-    run_result = task.execute()
-
-    # {
-    #     'values': ['Bob', 'Alice', 'Charlie'],
-    #     'counts': [2, 1, 1],
-    #     '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
-
-    # {
-    #     'values': ['Bob', 'Alice', 'Charlie'],
-    #     'counts': [1, 1, 1],
-    #     'valids': 3,
-    #     '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,
-            }
-        )
-
-    validate(
-        {
-            "model": "customers",
-            "column_name": "name",
-            "k": 50,
-        }
-    )
-
-    with pytest.raises(ValueError):
-        validate({})

tests/tasks/test_valuediff.py

@@ -1,85 +0,0 @@
-import pytest
-
-from recce.tasks import ValueDiffDetailTask, ValueDiffTask
-
-
-def test_value_diff(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    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"])
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    assert len(run_result.columns) == 5
-    assert len(run_result.data) == 2
-
-
-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,
-            }
-        )
-
-    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({})
-
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "model": "customers",
-            }
-        )
-
-    with pytest.raises(ValueError):
-        validate(
-            {
-                "model": "customers",
-                "primary_key": ["customer_id"],
-                "columns": "name",
-            }
-        )

tests/test_cli.py

@@ -1,133 +0,0 @@
-from unittest import TestCase
-from unittest.mock import MagicMock, patch
-
-from click.testing import CliRunner
-
-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 import __version__
-    from recce.cli import version
-
-    runner = CliRunner()
-    result = runner.invoke(version, [])
-    assert result.exit_code == 0
-    assert result.output.replace("\n", "") == __version__
-
-
-class TestCommandServer(TestCase):
-    def setUp(self):
-        self.runner = CliRunner()
-        pass
-
-    @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, "--single-env"])
-        mock_run.assert_called_once_with(app, host="unittest", port=5566, lifespan="on")
-
-    @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"])
-        assert result.exit_code == 1
-
-    @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"])
-        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
-    ):
-        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_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", "--single-env"]
-        )
-        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):
-        mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(
-            cli_command_server,
-            ["--single-env", "--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
-
-        # 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
-    ):
-        mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(
-            cli_command_server,
-            [
-                "existed_state_file",
-                "--review",
-                "--single-env",
-                "--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
-
-
-class TestCommandRun(TestCase):
-    def setUp(self):
-        self.runner = CliRunner()
-        pass
-
-    @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
-
-        self.runner.invoke(cli_command_run, [])
-        mock_cli_run.assert_called_once()