recce-nightly 1.9.0.20250623__py3-none-any.whl → 1.25.0.20251112a2066__py3-none-any.whl

tests/adapter/dbt_adapter/test_dbt_cll.py

@@ -1,34 +1,80 @@
 from recce.adapter.dbt_adapter import DbtAdapter
 from recce.models.types import CllData
-
-
-def assert_column(result: CllData, node_name, column_name, transformation_type, depends_on):
-    column_id = f"{node_name}_{column_name}"
+from recce.util.lineage import build_column_key
+
+
+def assert_parent_map(result: CllData, node_or_column_id, parents):
+    a_parents = result.parent_map.get(node_or_column_id) or set()
+
+    assert len(a_parents) == len(parents), "parents length mismatch"
+    for parent in parents:
+        if isinstance(parent, str):
+            node_id = parent
+            assert node_id in a_parents, f"Node {node_id} not found in parent list"
+        elif len(parent) == 1:
+            (node_id,) = parent
+            assert node_id in a_parents, f"Column {parent} not found in parent list"
+        elif len(parent) == 2:
+            node, column = parent
+            column_id = build_column_key(node, column)
+            assert column_id in a_parents, f"Column {column_id} not found in parent list for {node_or_column_id}"
+        else:
+            raise ValueError(f"Invalid parent format: {parent}. Expected node_id or (node_id, column_name).")
+
+
+def assert_column(
+    result: CllData,
+    node_id,
+    column_name,
+    transformation_type=None,
+    change_status=None,
+    parents=None,
+):
+    column_id = build_column_key(node_id, column_name)
     entry = result.columns.get(column_id)
     assert entry is not None, f"Column {column_id} not found in result"
     assert (
         entry.transformation_type == transformation_type
     ), f"Column {column_name} type mismatch: expected {transformation_type}, got {entry.transformation_type}"
-    parents = result.parent_map.get(column_id)
+    assert_parent_map(result, column_id, parents)
+    assert (
+        entry.change_status == change_status
+    ), f"Column {column_name} change status mismatch: expected {change_status}, got {entry.change_status}"
 
-    assert len(parents) == len(depends_on), "depends_on length mismatch"
-    for i in range(len(depends_on)):
-        node, column = depends_on[i]
-        parent_column_id = f"{node}_{column}"
 
-        assert parent_column_id in parents, f"Column {parent_column_id} not found in {column_id}'s parent list"
+def assert_model(
+    result: CllData,
+    node_id,
+    change_category=None,
+    impacted=None,
+    parents=None,
+):
+    entry = result.nodes.get(node_id)
+    assert entry is not None, f"Node {node_id} not found in result"
+    assert_parent_map(result, node_id, parents)
 
+    assert (
+        entry.change_category == change_category
+    ), f"Node {node_id} change category mismatch: expected {change_category}, got {entry.change_category}"
 
-def assert_model(result: CllData, node_name, depends_on):
-    assert result.nodes.get(node_name) is not None, f"Node {node_name} not found in result"
-    parent_map = result.parent_map.get(node_name)
-    assert parent_map is not None, f"Parent map {node_name} not found in result"
-    # assert len(parent_map) == len(depends_on), "depends_on length mismatch"
-    for i in range(len(depends_on)):
-        node, column = depends_on[i]
-        column_id = f"{node}_{column}"
+    assert (
+        entry.impacted == impacted
+    ), f"Node {node_id} impacted status mismatch: expected {impacted}, got {entry.impacted}"
 
-        assert column_id in parent_map, f"Parent map {node_name} does not contain {column_id}"
+
+def assert_cll_contain_nodes(cll_data: CllData, nodes):
+    assert len(nodes) == len(cll_data.nodes), "Model count mismatch"
+    for node in nodes:
+        assert node in cll_data.nodes, f"Model {node} not found in lineage"
+
+
+def assert_cll_contain_columns(cll_data: CllData, columns):
+    assert len(columns) == len(cll_data.columns), "Column count mismatch"
+    for column in columns:
+        column_key = f"{column[0]}_{column[1]}"
+        assert column_key in cll_data.columns, f"Column {column} not found in lineage"
+        assert column[0] == cll_data.columns[column_key].table_id, f"Column {column[0]} node mismatch"
+        assert column[1] == cll_data.columns[column_key].name, f"Column {column[1]} name mismatch"
 
 
 def test_cll_basic(dbt_test_helper):
@@ -51,13 +97,12 @@ def test_cll_basic(dbt_test_helper):
     )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
 
-    result = adapter.get_cll("model.model2", no_filter=True)
-    assert_model(result, "model.model2", [("model.model1", "c")])
-    assert_column(result, "model.model2", "c", "passthrough", [("model.model1", "c")])
+    result = adapter.get_cll("model.model1", "c")
+    assert_model(result, "model.model2", parents=[("model.model1", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
 
-    result = adapter.get_cll("model.model3", no_filter=True)
-    assert_model(result, "model.model3", [("model.model1", "c")])
-    assert_column(result, "model.model3", "c", "passthrough", [("model.model1", "c")])
+    assert_model(result, "model.model3", parents=[("model.model1", "c")])
+    assert_column(result, "model.model3", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
 
 
 def test_cll_table_alisa(dbt_test_helper):
@@ -75,8 +120,8 @@ def test_cll_table_alisa(dbt_test_helper):
         depends_on=["model.model1"],
     )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll("model.model1", no_filter=True)
-    assert_column(result, "model.model2", "c", "passthrough", [("model.model1", "c")])
+    result = adapter.get_cll("model.model1", "c")
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
 
 
 def test_seed(dbt_test_helper):
@@ -103,11 +148,17 @@ def test_seed(dbt_test_helper):
     )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
 
-    result = adapter.get_cll("model.model1", no_filter=True)
-    assert_model(result, "seed.seed1", [])
-    assert_column(result, "seed.seed1", "customer_id", "source", [])
-    assert_model(result, "model.model1", [("seed.seed1", "age")])
-    assert_column(result, "model.model1", "customer_id", "passthrough", [("seed.seed1", "customer_id")])
+    result = adapter.get_cll("model.model1")
+    assert_model(result, "seed.seed1", parents=[])
+    assert_column(result, "seed.seed1", "customer_id", transformation_type="source", parents=[])
+    assert_model(result, "model.model1", parents=["seed.seed1", ("seed.seed1", "age")])
+    assert_column(
+        result,
+        "model.model1",
+        "customer_id",
+        transformation_type="passthrough",
+        parents=[("seed.seed1", "customer_id")],
+    )
 
 
 def test_python_model(dbt_test_helper):
@@ -134,8 +185,9 @@ def test_python_model(dbt_test_helper):
     assert not adapter.is_python_model("model1")
     assert adapter.is_python_model("model2")
 
-    result = adapter.get_cll("model1", no_filter=True)
-    assert_column(result, "model2", "customer_id", "unknown", [])
+    result = adapter.get_cll("model2")
+    assert_model(result, "model2", parents=["model1"])
+    assert_column(result, "model2", "customer_id", transformation_type="unknown", parents=[])
 
 
 def test_source(dbt_test_helper):
@@ -161,43 +213,33 @@ def test_source(dbt_test_helper):
         depends_on=["source.source1.table1"],
     )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll("source.source1.table1", no_filter=True)
-    assert_column(result, "source.source1.table1", "customer_id", "source", [])
-    result = adapter.get_cll("model.model1", no_filter=True)
-    assert_column(result, "model.model1", "customer_id", "passthrough", [("source.source1.table1", "customer_id")])
+    result = adapter.get_cll("model.model1")
+    assert_column(result, "source.source1.table1", "customer_id", transformation_type="source", parents=[])
+    assert_column(
+        result,
+        "model.model1",
+        "customer_id",
+        transformation_type="passthrough",
+        parents=[("source.source1.table1", "customer_id")],
+    )
 
 
 def test_parse_error(dbt_test_helper):
     dbt_test_helper.create_model("model1", curr_sql="select 1 as c", curr_columns={"c": "int"})
     dbt_test_helper.create_model("model2", curr_sql="this is not a valid sql", curr_columns={"c": "int"})
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll("model2", no_filter=True)
-    assert_column(result, "model2", "c", "unknown", [])
+    result = adapter.get_cll("model2")
+    assert_column(result, "model2", "c", transformation_type="unknown", parents=[])
 
 
 def test_model_without_catalog(dbt_test_helper):
     dbt_test_helper.create_model("model1", curr_sql="select 1 as c")
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll("model1", no_filter=True)
+    result = adapter.get_cll("model1")
     assert not result.nodes["model1"].columns
 
 
-def assert_lineage_model(cll_data: CllData, nodes):
-    assert len(nodes) == len(cll_data.nodes), "Model count mismatch"
-    for node in nodes:
-        assert node in cll_data.nodes, f"Model {node} not found in lineage"
-
-
-def assert_lineage_column(cll_data: CllData, columns):
-    assert len(columns) == len(cll_data.columns), "Column count mismatch"
-    for column in columns:
-        column_key = f"{column[0]}_{column[1]}"
-        assert column_key in cll_data.columns, f"Column {column} not found in lineage"
-        assert column[0] == cll_data.columns[column_key].table_id, f"Column {column[0]} node mismatch"
-        assert column[1] == cll_data.columns[column_key].name, f"Column {column[1]} name mismatch"
-
-
-def test_cll_column_filter(dbt_test_helper):
+def test_column_level_lineage(dbt_test_helper):
     dbt_test_helper.create_model(
         "model1", unique_id="model.model1", curr_sql="select 1 as c", curr_columns={"c": "int"}
     )
@@ -226,19 +268,300 @@ def test_cll_column_filter(dbt_test_helper):
     adapter: DbtAdapter = dbt_test_helper.context.adapter
 
     result = adapter.get_cll("model.model2", "c")
-    assert_lineage_model(result, [])
-    assert_lineage_column(result, [("model.model1", "c"), ("model.model2", "c"), ("model.model3", "c")])
+    assert_cll_contain_nodes(result, [])
+    assert_cll_contain_columns(result, [("model.model1", "c"), ("model.model2", "c"), ("model.model3", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
 
     result = adapter.get_cll("model.model2", "y")
-    assert_lineage_model(result, ["model.model3"])
-    assert_lineage_column(result, [("model.model2", "y"), ("model.model4", "y")])
+    assert_cll_contain_nodes(result, ["model.model3"])
+    assert_cll_contain_columns(result, [("model.model2", "y"), ("model.model4", "y")])
+    assert_column(result, "model.model2", "y", transformation_type="source", parents=[])
 
     result = adapter.get_cll("model.model3", "c")
-    assert_lineage_model(result, [])
-    assert_lineage_column(result, [("model.model1", "c"), ("model.model2", "c"), ("model.model3", "c")])
+    assert_cll_contain_nodes(result, [])
+    assert_cll_contain_columns(result, [("model.model1", "c"), ("model.model2", "c"), ("model.model3", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
+
+    result = adapter.get_cll("model.model2", "c", no_upstream=True, no_downstream=True)
+    assert_cll_contain_nodes(result, [])
+    assert_cll_contain_columns(result, [("model.model2", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[])
+
+
+def test_impact_radius_no_change_analysis_no_cll(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll(no_cll=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4", "model.model5"])
+    assert_model(result, "model.model1", parents=[])
+    assert_model(result, "model.model2", parents=["model.model1"])
+    assert_model(result, "model.model3", parents=["model.model2"])
+    assert_model(result, "model.model4", parents=["model.model2"])
+    assert_model(result, "model.model5", parents=["model.model1"])
+
+
+def test_impact_radius_with_change_analysis_no_cll(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    # breaking
+    result = adapter.get_cll(change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4"])
+    assert_model(result, "model.model1", parents=[], change_category="non_breaking", impacted=False)
+    assert_model(result, "model.model2", parents=[], change_category="breaking", impacted=True)
+    assert_model(result, "model.model3", parents=["model.model2"], change_category=None, impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], change_category="partial_breaking", impacted=True)
+
+
+def test_impact_radius_with_change_analysis_no_cll_2(dbt_test_helper):
+    # partial breaking
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 2 as c",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    # breaking
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    # no change
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    # partial breaking
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    # no change
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    # breaking
+    result = adapter.get_cll(change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4", "model.model5"])
+    assert_model(result, "model.model1", parents=[], change_category="partial_breaking", impacted=True)
+    assert_model(result, "model.model2", parents=["model.model1"], change_category="breaking", impacted=True)
+    assert_model(result, "model.model3", parents=["model.model2"], change_category=None, impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], change_category="partial_breaking", impacted=True)
+    assert_model(result, "model.model5", parents=["model.model1"], impacted=True)
+
+
+def test_impact_radius_with_change_analysis_with_cll(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll(change_analysis=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4"])
+    assert_cll_contain_columns(result, [("model.model4", "year")])
+    assert_model(result, "model.model1", parents=[], change_category="non_breaking", impacted=False)
+    assert_model(result, "model.model2", parents=[], change_category="breaking", impacted=True)
+    assert_model(result, "model.model3", parents=["model.model2"], change_category=None, impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], change_category="partial_breaking", impacted=True)
+
+
+def test_impact_radius_with_change_analysis_with_cll_added_removed(dbt_test_helper):
+    # rename model
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        base_sql="select 1 as c",
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model1_v2",
+        unique_id="model.model1_v2",
+        curr_sql="select 1 as c",
+        curr_columns={"c": "int"},
+    )
+    # change upstream
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        base_sql='select c from {{ ref("model1") }}',
+        base_columns={"c": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c from {{ ref("model1_v2") }}',
+        curr_columns={"c": "int"},
+        depends_on=["model.model1_v2"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+    result = adapter.get_cll(change_analysis=True, no_upstream=True)
+    assert_model(result, "model.model1_v2", parents=[], impacted=True)
+    assert_column(result, "model.model1_v2", "c", transformation_type="source", change_status="added", parents=[])
+    assert_model(result, "model.model2", parents=["model.model1_v2"], change_category="breaking", impacted=True)
+    assert_cll_contain_nodes(result, ["model.model1_v2", "model.model2"])
+    assert_cll_contain_columns(result, [("model.model1_v2", "c"), ("model.model2", "c")])
 
 
-def test_impact_radius_nodes(dbt_test_helper):
+def test_impact_radius_by_node_no_cll(dbt_test_helper):
     # non-breaking
     dbt_test_helper.create_model(
         "model1",
@@ -280,15 +603,15 @@ def test_impact_radius_nodes(dbt_test_helper):
     adapter: DbtAdapter = dbt_test_helper.context.adapter
 
     # breaking
-    result = adapter.get_impacted_nodes("model.model2")
-    assert_lineage_model(result, ["model.model2", "model.model3", "model.model4"])
+    result = adapter.get_cll(node_id="model.model2", change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model2", "model.model3", "model.model4"])
 
     # non-breaking
-    result = adapter.get_impacted_nodes("model.model1")
-    assert_lineage_model(result, [])
+    result = adapter.get_cll(node_id="model.model1", change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1"])
 
 
-def test_impact_radius_columns(dbt_test_helper):
+def test_impact_radius_by_node_with_cll(dbt_test_helper):
     # added column
     dbt_test_helper.create_model(
         "model1",
@@ -329,16 +652,21 @@ def test_impact_radius_columns(dbt_test_helper):
 
     adapter: DbtAdapter = dbt_test_helper.context.adapter
 
-    result = adapter.get_impacted_cll("model.model2")
-    assert_lineage_model(result, ["model.model3"])
-    assert_lineage_column(result, [("model.model2", "y"), ("model.model4", "y")])
+    result = adapter.get_cll(node_id="model.model2", change_analysis=True, no_upstream=True)
+    assert_model(result, "model.model2", parents=[], change_category="partial_breaking", impacted=False)
+    assert_model(result, "model.model3", parents=[("model.model2", "y")], impacted=True)
+    assert_column(result, "model.model2", "y", transformation_type="source", parents=[], change_status="modified")
+    assert_cll_contain_nodes(result, ["model.model2", "model.model3"])
+    assert_cll_contain_columns(result, [("model.model2", "y"), ("model.model4", "y")])
 
-    result = adapter.get_impacted_cll("model.model1")
-    assert_lineage_model(result, [])
-    assert_lineage_column(result, [("model.model1", "d")])
+    result = adapter.get_cll(node_id="model.model1", change_analysis=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1"])
+    assert_cll_contain_columns(result, [("model.model1", "d")])
+    assert_model(result, "model.model1", parents=[], change_category="non_breaking", impacted=False)
+    assert_column(result, "model.model1", "d", transformation_type="source", parents=[], change_status="added")
 
 
-def test_impact_radius(dbt_test_helper):
+def test_impact_radius_by_node_with_cll_2(dbt_test_helper):
     # added column
     dbt_test_helper.create_model(
         "model1",
@@ -379,6 +707,11 @@ def test_impact_radius(dbt_test_helper):
 
     adapter: DbtAdapter = dbt_test_helper.context.adapter
 
-    result = adapter.get_impact_radius("model.model2")
-    assert_lineage_model(result, ["model.model2", "model.model3", "model.model4"])
-    assert_lineage_column(result, [("model.model2", "d"), ("model.model2", "y"), ("model.model4", "y")])
+    result = adapter.get_cll(node_id="model.model2", change_analysis=True, no_upstream=True)
+    assert_model(result, "model.model2", parents=[], change_category="breaking", impacted=True)
+    assert_column(result, "model.model2", "y", transformation_type="source", parents=[], change_status="modified")
+    assert_model(result, "model.model3", parents=["model.model2", ("model.model2", "y")], impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], impacted=True)
+    assert_column(result, "model.model4", "y", transformation_type="passthrough", parents=[("model.model2", "y")])
+    assert_cll_contain_nodes(result, ["model.model2", "model.model3", "model.model4"])
+    assert_cll_contain_columns(result, [("model.model2", "d"), ("model.model2", "y"), ("model.model4", "y")])