test: make constraints tests server-observable (add assertions, drop generated-SQL checks) (#1523)

Make the constraints functional tests assert **server-observable state**
rather than generated-SQL text or run-succeeded.

## Adds server-observable assertions
- **V1 contract-enforced table create** asserts PRIMARY KEY + FOREIGN
KEY + NOT NULL land in information_schema
(`TestV1ContractConstraintsApplied`). The V1 path was previously only
generated-SQL-tested.
- **type: custom** model constraint asserts delta.constraints.* via SHOW
TBLPROPERTIES (`TestCustomConstraint`).
- **Expression-form foreign key** asserts the referential constraint is
actually created (`TestIncrementalForeignKeyExpressionConstraint` was
previously assertion-free).
- **Incremental NOT NULL / CHECK removal** assert the after-state
(column nullable again / delta.constraints.* gone), not just that the
rerun succeeds.
- Enabled the previously-uncollected `TestInvalidColumnConstraints` (the
test method had a leading underscore, so pytest never ran it).

## Removes brittle generated-SQL checks
The `*DdlEnforcement` and quoted-column tests string-matched the
generated CREATE TABLE / ALTER SQL (reading target/run/*.sql), which is
brittle and outside the spirit of integration tests. Constraint SQL
generation is already unit-pinned in
tests/unit/macros/relations/test_constraint_macros.py, and the server
effect is now covered above. Removed
`TestTableConstraintsDdlEnforcement` /
`TestIncrementalConstraintsDdlEnforcement` /
`TestConstraintQuotedColumn` (V1 + V2), `BaseV2ConstraintSetup`, and the
`expected_sql` / `expected_sql_v2` fixtures. Kept the ColumnsEqual
(contract column matching) and rollback (server-observable enforcement)
tests.

No product code changes; tests only.

## Test plan
All new/strengthened assertions verified live on
databricks_uc_sql_endpoint; pre-commit (ruff / ruff-format / mypy)
clean.

Author: sd-db

tests/functional/adapter/constraints/fixtures.py

@@ -1,31 +1,5 @@
 from dbt.tests.adapter.constraints import fixtures
 
-# constraints are enforced via 'alter' statements that run after table creation
-expected_sql = """
-create or replace table <model_identifier>
-    using delta
-    as
-select
-  id,
-  color,
-  date_day
-from
-( select
-    'blue' as color,
-    1 as id,
-    '2019-01-01' as date_day ) as model_subq
-"""
-
-expected_sql_v2 = """
-create or replace table <model_identifier> (
-  `color` string,
-  `id` integer not null comment 'hello',
-  `date_day` string,
-  PRIMARY KEY (id),
-  FOREIGN KEY (id) REFERENCES <foreign_key_model_identifier> (id)
-  ) using delta
-"""
-
 constraints_yml = fixtures.model_schema_yml.replace("text", "string").replace("primary key", "")
 
 model_fk_constraint_schema_yml = """
@@ -318,3 +292,73 @@
             to: ref('parent_table')
             to_columns: [id]
 """
+
+
+# Contract-enforced table child carrying PRIMARY KEY + FOREIGN KEY + NOT NULL, so all
+# three constraint kinds can be observed in information_schema after create. Reuses the
+# column_constraint_gate parent (a table with a PK to satisfy the FK reference).
+v1_contract_child_table_sql = """
+{{ config(materialized='table') }}
+select
+  cast(1 as int) as id,
+  cast('name' as string) as name,
+  cast(1 as int) as parent_id
+"""
+
+v1_contract_child_table_schema_yml = f"""
+version: 2
+models:
+{_column_constraint_gate_parent_model_yml}  - name: v1_contract_child
+    config:
+      materialized: table
+      contract:
+        enforced: true
+    constraints:
+      - type: primary_key
+        name: pk_v1_contract_child
+        columns: ["id"]
+      - type: foreign_key
+        name: fk_v1_contract_child_parent
+        columns: ["parent_id"]
+        to: ref('parent_table')
+        to_columns: ["id"]
+    columns:
+      - name: id
+        data_type: int
+        constraints:
+          - type: not_null
+      - name: name
+        data_type: string
+        constraints:
+          - type: not_null
+      - name: parent_id
+        data_type: int
+        constraints:
+          - type: not_null
+"""
+
+
+# Contract-enforced `type: custom` constraint, rendered verbatim as
+# `add constraint <name> <expression>` and observable as a delta.constraints.* property.
+custom_constraint_model_sql = """
+{{ config(materialized="table") }}
+select 1 as id, 'blue' as color
+"""
+
+custom_constraint_schema_yml = """
+version: 2
+models:
+  - name: custom_constraint_model
+    config:
+      contract:
+        enforced: true
+    constraints:
+      - type: custom
+        name: custom_id_positive
+        expression: "CHECK (id > 0)"
+    columns:
+      - name: id
+        data_type: int
+      - name: color
+        data_type: string
+"""

tests/functional/adapter/constraints/test_column_constraint_gate.py

@@ -2,7 +2,11 @@
 from dbt.tests import util
 
 from tests.functional.adapter.constraints import fixtures
-from tests.functional.adapter.fixtures import MaterializationV2Mixin
+from tests.functional.adapter.fixtures import (
+    MaterializationV1Mixin,
+    MaterializationV2Mixin,
+    RerunSafeMixin,
+)
 
 
 def _constraint_rows(project, table_name, constraint_type):
@@ -128,3 +132,40 @@ def test_constraints_apply_and_survive_rerun(self, project):
         assert len(fk_rows_after) == 1, (
             f"Expected FOREIGN KEY to survive the second run, found {fk_rows_after}"
         )
+
+
+@pytest.mark.skip_profile("databricks_cluster")
+class TestV1ContractConstraintsApplied(RerunSafeMixin, MaterializationV1Mixin):
+    @pytest.fixture(scope="class")
+    def relations_to_reset(self):
+        # child holds the FK to parent_table, so drop it first.
+        return ("v1_contract_child", "parent_table")
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "parent_table.sql": fixtures.column_constraint_gate_parent_sql,
+            "v1_contract_child.sql": fixtures.v1_contract_child_table_sql,
+            "schema.yml": fixtures.v1_contract_child_table_schema_yml,
+        }
+
+    def _assert_all_constraints_present(self, project):
+        pk_rows = _constraint_rows(project, "v1_contract_child", "PRIMARY KEY")
+        assert len(pk_rows) == 1, f"Expected one PRIMARY KEY, found {pk_rows}"
+        assert _pk_columns(project, "v1_contract_child") == ["id"]
+
+        fk_rows = _constraint_rows(project, "v1_contract_child", "FOREIGN KEY")
+        assert len(fk_rows) == 1, f"Expected one FOREIGN KEY, found {fk_rows}"
+
+        not_null_cols = set(_not_null_columns(project, "v1_contract_child"))
+        assert {"id", "name", "parent_id"}.issubset(not_null_cols), (
+            f"Expected id/name/parent_id NOT NULL, got {sorted(not_null_cols)}"
+        )
+
+    def test_v1_contract_constraints_in_information_schema(self, project):
+        util.run_dbt(["run"])
+        self._assert_all_constraints_present(project)
+
+        # V1 tables recreate on every run, so the constraints must be re-applied.
+        util.run_dbt(["run"])
+        self._assert_all_constraints_present(project)

tests/functional/adapter/constraints/test_constraints.py

@@ -2,12 +2,9 @@
 from dbt.tests import util
 from dbt.tests.adapter.constraints import fixtures
 from dbt.tests.adapter.constraints.test_constraints import (
-    BaseConstraintQuotedColumn,
     BaseConstraintsRollback,
-    BaseConstraintsRuntimeDdlEnforcement,
     BaseIncrementalConstraintsColumnsEqual,
     BaseIncrementalConstraintsRollback,
-    BaseIncrementalConstraintsRuntimeDdlEnforcement,
     BaseTableConstraintsColumnsEqual,
     BaseViewConstraintsColumnsEqual,
 )
@@ -86,41 +83,6 @@ def models(self):
         }
 
 
-class BaseConstraintsDdlEnforcementSetup:
-    @pytest.fixture(scope="class")
-    def project_config_update(self):
-        return {"flags": {"use_materialization_v2": False}}
-
-    @pytest.fixture(scope="class")
-    def expected_sql(self):
-        return override_fixtures.expected_sql
-
-
-@pytest.mark.skip_profile("databricks_cluster")
-class TestTableConstraintsDdlEnforcement(
-    BaseConstraintsDdlEnforcementSetup, BaseConstraintsRuntimeDdlEnforcement
-):
-    @pytest.fixture(scope="class")
-    def models(self):
-        return {
-            "my_model.sql": fixtures.my_model_wrong_order_sql,
-            "constraints_schema.yml": override_fixtures.constraints_yml,
-        }
-
-
-@pytest.mark.skip_profile("databricks_cluster")
-class TestIncrementalConstraintsDdlEnforcement(
-    BaseConstraintsDdlEnforcementSetup,
-    BaseIncrementalConstraintsRuntimeDdlEnforcement,
-):
-    @pytest.fixture(scope="class")
-    def models(self):
-        return {
-            "my_model.sql": fixtures.my_model_incremental_wrong_order_sql,
-            "constraints_schema.yml": override_fixtures.constraints_yml,
-        }
-
-
 class BaseConstraintsRollbackSetup:
     @pytest.fixture(scope="class")
     def project_config_update(self):
@@ -200,53 +162,59 @@ def test_incremental_foreign_key_constraint(self, project):
         util.run_dbt(["run", "--select", "stg_numbers"])
         util.run_dbt(["run", "--select", "stg_numbers"])
 
+        # Verify the expression-form foreign key is registered in information_schema.
+        referential_constraints = project.run_sql(
+            """
+            SELECT constraint_name
+            FROM {database}.information_schema.referential_constraints
+            WHERE constraint_schema = '{schema}'
+            """,
+            fetch="all",
+        )
+        assert any(row[0] == "fk_n" for row in referential_constraints), (
+            f"expected FK 'fk_n' from the expression-form constraint, got {referential_constraints}"
+        )
+
 
 @pytest.mark.skip_profile("databricks_cluster")
-class TestForeignKeyParentConstraint:
+class TestCustomConstraint:
     @pytest.fixture(scope="class")
     def project_config_update(self):
         return {"flags": {"use_materialization_v2": False}}
 
     @pytest.fixture(scope="class")
     def models(self):
         return {
-            "schema.yml": override_fixtures.parent_foreign_key,
-            "parent_table.sql": override_fixtures.parent_sql,
-            "child_table.sql": override_fixtures.child_sql,
+            "custom_constraint_model.sql": override_fixtures.custom_constraint_model_sql,
+            "schema.yml": override_fixtures.custom_constraint_schema_yml,
         }
 
-    def test_foreign_key_constraint(self, project):
-        util.run_dbt(["build"])
+    def test_custom_constraint_applied(self, project):
+        util.run_dbt(["run"])
+        rows = project.run_sql(
+            "show tblproperties {database}.{schema}.custom_constraint_model", fetch="all"
+        )
+        constraints = {
+            row.key: row.value for row in rows if row.key.startswith("delta.constraints.")
+        }
+        assert constraints.get("delta.constraints.custom_id_positive") == "id > 0", (
+            f"custom constraint not persisted as expected; delta.constraints = {constraints}"
+        )
 
 
-class TestConstraintQuotedColumn(BaseConstraintQuotedColumn):
+@pytest.mark.skip_profile("databricks_cluster")
+class TestForeignKeyParentConstraint:
     @pytest.fixture(scope="class")
     def project_config_update(self):
         return {"flags": {"use_materialization_v2": False}}
 
     @pytest.fixture(scope="class")
     def models(self):
         return {
-            "my_model.sql": fixtures.my_model_with_quoted_column_name_sql,
-            "constraints_schema.yml": fixtures.model_quoted_column_schema_yml.replace(
-                "text", "string"
-            ).replace('"from"', "`from`"),
+            "schema.yml": override_fixtures.parent_foreign_key,
+            "parent_table.sql": override_fixtures.parent_sql,
+            "child_table.sql": override_fixtures.child_sql,
         }
 
-    @pytest.fixture(scope="class")
-    def expected_sql(self):
-        return """create or replace table <model_identifier>
-    using delta
-    as
-select
-  id,
-  `from`,
-  date_day
-from
-
-(
-    select
-    'blue' as `from`,
-    1 as id,
-    '2019-01-01' as date_day ) as model_subq
-"""
+    def test_foreign_key_constraint(self, project):
+        util.run_dbt(["build"])