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

tests/tasks/test_histogram.py

@@ -1,129 +0,0 @@
-import pytest
-
-from recce.tasks.histogram import (
-    HistogramDiffCheckValidator,
-    HistogramDiffTask,
-    _is_histogram_supported,
-)
-
-
-def test_histogram(dbt_test_helper):
-    csv_data = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        4,Dolly,50
-        """
-
-    dbt_test_helper.create_model("customers", csv_data, csv_data)
-
-    params = {"model": "customers", "column_name": "age", "column_type": "int"}
-
-    task = HistogramDiffTask(params)
-    run_result = task.execute()
-
-    # {
-    #     'base': {'counts': [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 'total': 4},
-    #     'current': {'counts': [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 'total': 4},
-    #     'min': 25, 'max': 50,
-    #     'bin_edges': [25, 26, ..., 51],
-    #     'labels': ['25-26', ..., '51-52']
-    # }
-    assert run_result["current"]["counts"][0] == 1
-    assert run_result["current"]["counts"][-1] == 1
-    assert run_result["current"]["total"] == 4
-    assert run_result["min"] == 25
-    assert run_result["max"] == 50
-    assert run_result["bin_edges"][0] == 25
-    assert run_result["bin_edges"][-1] == 51
-
-
-def test_histogram_emtpy(dbt_test_helper):
-    csv_data = """
-    customer_id,name,age
-    1,Alice,30
-    2,Bob,25
-    3,Charlie,35
-    4,Dolly,50
-    """
-
-    csv_data_zero = """
-    customer_id,name,age
-    """
-
-    dbt_test_helper.create_model("customers", csv_data_zero, csv_data_zero)
-    dbt_test_helper.create_model("customers2", csv_data, csv_data_zero)
-    dbt_test_helper.create_model("customers3", csv_data_zero, csv_data)
-
-    params = {"model": "customers", "column_name": "age", "column_type": "int"}
-
-    task = HistogramDiffTask(params)
-    run_result = task.execute()
-
-    assert len(run_result["current"]["counts"]) == 0
-    assert run_result["current"]["total"] == 0
-    assert run_result["min"] is None
-    assert run_result["max"] is None
-    assert len(run_result["bin_edges"]) == 0
-
-    params = {"model": "customers2", "column_name": "age", "column_type": "int"}
-
-    task = HistogramDiffTask(params)
-    run_result = task.execute()
-    assert run_result["base"]["counts"][0] == 1
-    assert run_result["base"]["counts"][-1] == 1
-    assert run_result["base"]["total"] == 4
-    assert run_result["current"]["counts"][0] == 0
-    assert run_result["current"]["counts"][-1] == 0
-    assert run_result["current"]["total"] == 0
-    assert run_result["min"] == 25
-    assert run_result["max"] == 50
-    assert run_result["bin_edges"][0] == 25
-    assert run_result["bin_edges"][-1] == 51
-
-    params = {"model": "customers3", "column_name": "age", "column_type": "int"}
-
-    task = HistogramDiffTask(params)
-    run_result = task.execute()
-    assert run_result["base"]["counts"][0] == 0
-    assert run_result["base"]["counts"][-1] == 0
-    assert run_result["base"]["total"] == 0
-    assert run_result["current"]["counts"][0] == 1
-    assert run_result["current"]["counts"][-1] == 1
-    assert run_result["current"]["total"] == 4
-    assert run_result["min"] == 25
-    assert run_result["max"] == 50
-    assert run_result["bin_edges"][0] == 25
-    assert run_result["bin_edges"][-1] == 51
-
-
-def test_validator():
-    def validate(params: dict = {}, view_options: dict = {}):
-        HistogramDiffCheckValidator().validate(
-            {
-                "name": "test",
-                "type": "histogram_diff",
-                "params": params,
-                "view_options": view_options,
-            }
-        )
-
-    validate(
-        {
-            "model": "customers",
-            "column_name": "age",
-            "column_type": "int",
-        }
-    )
-
-    with pytest.raises(ValueError):
-        validate({})
-
-
-def test_is_column_type_supported_by_histogram():
-    assert _is_histogram_supported("varchar") is False
-    assert _is_histogram_supported("varchar(16)") is False
-    assert _is_histogram_supported("varchar(256)") is False
-    assert _is_histogram_supported("bool") is False
-    assert _is_histogram_supported("int") is True

tests/tasks/test_lineage.py

@@ -1,55 +0,0 @@
-import pytest
-
-
-def test_validator():
-    from recce.tasks.lineage import LineageDiffCheckValidator
-
-    validator = LineageDiffCheckValidator()
-
-    def validate(params: dict):
-        validator.validate(
-            {
-                "name": "test",
-                "type": "schema_diff",
-                "params": params,
-            }
-        )
-
-    # Select all models
-    validate({})
-
-    # 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_preset_checks.py

@@ -1,64 +0,0 @@
-import pytest
-
-
-def test_default_validator():
-    from recce.tasks.core import CheckValidator
-
-    CheckValidator().validate(
-        {
-            "name": "test",
-            "type": "row_count_diff",
-            "params": {},
-        }
-    )
-
-    with pytest.raises(ValueError):
-        CheckValidator().validate(
-            {
-                "type": "row_count_diff",
-            }
-        )
-
-
-def test_query_diff_validator():
-    from recce.tasks.query import QueryDiffCheckValidator
-
-    QueryDiffCheckValidator().validate(
-        {
-            "name": "test",
-            "type": "query_diff",
-            "params": {"sql_template": "select * from {{ model }}"},
-        }
-    )
-    with pytest.raises(ValueError):
-        QueryDiffCheckValidator().validate(
-            {
-                "name": "test",
-                "type": "query_diff",
-            }
-        )
-
-
-def test_lineage_diff_validator():
-    from recce.tasks.lineage import LineageDiffCheckValidator
-
-    LineageDiffCheckValidator().validate(
-        {
-            "name": "test",
-            "type": "lineage_diff",
-            "params": {},
-        }
-    )
-    LineageDiffCheckValidator().validate(
-        {
-            "name": "test",
-            "type": "lineage_diff",
-            "view_options": {},
-        }
-    )
-    with pytest.raises(ValueError):
-        LineageDiffCheckValidator().validate(
-            {
-                "type": "lineage_diff",
-            }
-        )

tests/tasks/test_profile.py

@@ -1,397 +0,0 @@
-import pytest
-from jinja2 import Template
-from sqlglot import parse_one
-
-from recce.tasks import ProfileDiffTask, ProfileTask
-from recce.tasks.profile import PROFILE_COLUMN_JINJA_TEMPLATE
-
-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
-    """
-
-
-def test_profile(dbt_test_helper):
-    dbt_test_helper.create_model("customers", None, csv_data_curr)
-    params = dict(model="customers")
-    task = ProfileTask(params)
-    run_result = task.execute()
-
-    assert len(run_result.current.data) == 3
-
-
-def test_profile_with_selected_columns(dbt_test_helper):
-    dbt_test_helper.create_model("customers", None, csv_data_curr)
-    params = dict(model="customers", columns=["name", "age"])
-    task = ProfileTask(params)
-    run_result = task.execute()
-    assert len(run_result.current.data) == 2
-
-
-def test_profile_diff(dbt_test_helper):
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(model="customers")
-    task = ProfileDiffTask(params)
-    run_result = task.execute()
-
-    assert len(run_result.current.data) == 3
-    assert len(run_result.base.data) == 3
-
-
-def test_profile_diff_with_selected_columns(dbt_test_helper):
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(model="customers", columns=["name", "age"])
-    task = ProfileDiffTask(params)
-    run_result = task.execute()
-    assert len(run_result.current.data) == 2
-    assert len(run_result.base.data) == 2
-
-
-def test_validator():
-    from recce.tasks.profile import ProfileCheckValidator
-
-    def validate(params: dict = {}, view_options: dict = {}):
-        ProfileCheckValidator().validate(
-            {
-                "name": "test",
-                "type": "profile_diff",
-                "params": params,
-                "view_options": view_options,
-            }
-        )
-
-    validate(
-        {
-            "model": "customers",
-        }
-    )
-
-    with pytest.raises(ValueError):
-        validate({})
-
-
-def test_profile_column_jinja_template():
-
-    class DummyAdapter:
-        def __init__(self, database_type="duckdb"):
-            self.database_type = database_type
-
-        def quote(self, col):
-            quote_marks = {
-                "athena": '"',
-                "bigquery": "`",
-                "databricks": "`",
-                "duckdb": '"',
-                "postgres": '"',
-                "redshift": '"',
-                "snowflake": '"',
-                "sqlite": '"',
-                "sqlserver": '"',
-                "trino": '"',
-            }
-            quote_mark = quote_marks.get(self.database_type, '"')
-            return f"{quote_mark}{col}{quote_mark}"
-
-    class DummyDbt:
-        def __init__(self, database_type="Postgres"):
-            self.database_type = database_type
-
-        def type_bigint(self):
-            bigint_types = {
-                "athena": "BIGINT",
-                "bigquery": "INT64",
-                "databricks": "BIGINT",
-                "duckdb": "BIGINT",
-                "postgres": "BIGINT",
-                "redshift": "BIGINT",
-                "snowflake": "NUMBER",
-                "sqlite": "INTEGER",
-                "sqlserver": "BIGINT",
-                "trino": "BIGINT",
-            }
-            return bigint_types.get(self.database_type, "bigint")
-
-        def type_numeric(self):
-            numeric_types = {
-                "athena": "DECIMAL",
-                "bigquery": "NUMERIC",
-                "databricks": "DECIMAL",
-                "duckdb": "DECIMAL",
-                "postgres": "NUMERIC",
-                "redshift": "DECIMAL",
-                "snowflake": "NUMBER",
-                "sqlite": "NUMERIC",
-                "sqlserver": "DECIMAL",
-                "trino": "DECIMAL",
-            }
-            return numeric_types.get(self.database_type, "numeric")
-
-        def type_string(self):
-            string_types = {
-                "athena": "VARCHAR",
-                "bigquery": "STRING",
-                "databricks": "STRING",
-                "duckdb": "VARCHAR",
-                "postgres": "TEXT",
-                "redshift": "VARCHAR",
-                "snowflake": "VARCHAR",
-                "sqlite": "TEXT",
-                "sqlserver": "VARCHAR",
-                "trino": "VARCHAR",
-            }
-            return string_types.get(self.database_type, "varchar")
-
-    test_db_column_types = {
-        "athena": [
-            "boolean",
-            "int",
-            "double",
-            "decimal",
-            "char",
-            "string",
-            "binary",
-            "date",
-            "array",
-            "struct",
-            "map",
-        ],
-        "bigquery": [
-            "array",
-            "bool",
-            "bytes",
-            "date",
-            "datetime",
-            "interval",
-            "json",
-            "int64",
-            "bignumeric",
-            "range",
-            "string",
-            "struct",
-            "time",
-            "timestamp",
-        ],
-        "databricks": [
-            "bigint",
-            "binary",
-            "boolean",
-            "date",
-            "decimal",
-            "double",
-            "float",
-            "int",
-            "interval",
-            "void",
-            "string",
-            "timestamp",
-            "array",
-            "map",
-            "struct",
-            "variant",
-            "object",
-        ],
-        "duckdb": [
-            "boolean",
-            "integer",
-            "bigint",
-            "real",
-            "double",
-            "decimal",
-            "varchar",
-            "date",
-            "time",
-            "timestamp",
-            "blob",
-            "array",
-            "list",
-            "struct",
-            "map",
-            "union",
-            "uuid",
-            "json",
-        ],
-        "postgres": [
-            "bigint",
-            "bigserial",
-            "bit",
-            "boolean",
-            "box",
-            "bytea",
-            "character",
-            "cidr",
-            "circle",
-            "date",
-            "double precision",
-            "inet",
-            "integer",
-            "interval",
-            "json",
-            "jsonb",
-            "line",
-            "lseg",
-            "macaddr",
-            "money",
-            "numeric",
-            "path",
-            "pg_lsn",
-            "point",
-            "polygon",
-            "real",
-            "smallint",
-            "smallserial",
-            "serial",
-            "text",
-            "time",
-            "timestamp",
-            "tsquery",
-            "tsvector",
-            "txid_snapshot",
-            "uuid",
-            "xml",
-            "array",
-        ],
-        "redshift": [
-            "smallint",
-            "integer",
-            "bigint",
-            "decimal",
-            "real",
-            "double precision",
-            "boolean",
-            "char",
-            "varchar",
-            "date",
-            "timestamp",
-            "timestamptz",
-            "super",
-            "time",
-            "timetz",
-            "varbyte",
-            "geometry",
-            "geography",
-            "hllsketch",
-        ],
-        "snowflake": [
-            "number",
-            "decimal",
-            "numeric",
-            "int",
-            "integer",
-            "bigint",
-            "smallint",
-            "tinyint",
-            "byteint",
-            "float",
-            "float4",
-            "float8",
-            "double",
-            "double precision",
-            "real",
-            "varchar",
-            "char",
-            "character",
-            "string",
-            "text",
-            "binary",
-            "varbinary",
-            "boolean",
-            "date",
-            "datetime",
-            "time",
-            "timestamp",
-            "timestamp_ltz",
-            "timestamp_ntz",
-            "timestamp_tz",
-            "variant",
-            "object",
-            "array",
-            "geography",
-            "geometry",
-        ],
-        "sqlite": ["integer", "real", "text", "blob", "numeric", "boolean", "date", "datetime", "json"],
-        "trino": [
-            "boolean",
-            "tinyint",
-            "smallint",
-            "integer",
-            "bigint",
-            "real",
-            "double",
-            "decimal",
-            "varchar",
-            "char",
-            "varbinary",
-            "json",
-            "date",
-            "time",
-            "timestamp",
-            "timestamp with time zone",
-            "interval year to month",
-            "interval day to second",
-            "array",
-            "map",
-            "row",
-            "ipaddress",
-            "uuid",
-            "hyperloglog",
-            "p4hyperloglog",
-            "qdigest",
-        ],
-        "sqlserver": [
-            "bigint",
-            "int",
-            "smallint",
-            "tinyint",
-            "bit",
-            "decimal",
-            "numeric",
-            "money",
-            "smallmoney",
-            "float",
-            "real",
-            "date",
-            "datetime",
-            "datetime2",
-            "smalldatetime",
-            "time",
-            "char",
-            "varchar",
-            "text",
-            "nchar",
-            "nvarchar",
-            "ntext",
-            "binary",
-            "varbinary",
-            "image",
-            "timestamp",
-            "uniqueidentifier",
-            "xml",
-            "cursor",
-            "table",
-            "sql_variant",
-        ],
-    }
-
-    for db_type, column_types in test_db_column_types.items():
-        for column_type in column_types:
-            context = {
-                "column_type": column_type,
-                "column_name": "profile_column",
-                "db_type": db_type,
-                "relation": "test_table",
-                "adapter": DummyAdapter(),
-                "dbt": DummyDbt(),
-            }
-
-            sql = Template(PROFILE_COLUMN_JINJA_TEMPLATE).render(context)
-            dialect = db_type if db_type != "sqlserver" else "tsql"
-            parse_one(sql, read=dialect)