ADAP-850: Support test results as a view

.changes/unreleased/Features-20230915-174428.yaml

@@ -0,0 +1,6 @@
+kind: Features
+body: Support persisting test results as views
+time: 2023-09-15T17:44:28.833877-04:00
+custom:
+  Author: mikealfare
+  Issue: "6914"

core/dbt/contracts/graph/model_config.py

@@ -216,7 +216,6 @@ class Hook(dbtClassMixin, Replaceable):
 
 @dataclass
 class BaseConfig(AdditionalPropertiesAllowed, Replaceable):
-
     # enable syntax like: config['key']
     def __getitem__(self, key):
         return self.get(key)
@@ -560,6 +559,7 @@ class TestConfig(NodeAndTestConfig):
     fail_calc: str = "count(*)"
     warn_if: str = "!= 0"
     error_if: str = "!= 0"
+    strategy: Optional[str] = None
 
     @classmethod
     def same_contents(cls, unrendered: Dict[str, Any], other: Dict[str, Any]) -> bool:
@@ -572,6 +572,7 @@ def same_contents(cls, unrendered: Dict[str, Any], other: Dict[str, Any]) -> boo
             "warn_if",
             "error_if",
             "store_failures",
+            "strategy",
         ]
 
         seen = set()

core/dbt/contracts/graph/nodes.py

@@ -779,7 +779,6 @@
             or enforced_column_constraint_removed
             or materialization_changed
         ):
-
             breaking_changes = []
             if contract_enforced_disabled:
                 breaking_changes.append(
@@ -984,15 +983,15 @@
 class TestShouldStoreFailures:
     @property
     def should_store_failures(self):
-        if self.config.store_failures:
+        if self.config.strategy in ["view", "table"]:
+            return True
+        elif self.config.store_failures:
             return self.config.store_failures
         return get_flags().STORE_FAILURES
 
     @property
     def is_relational(self):
-        if self.should_store_failures:
-            return True
-        return False
+        return self.should_store_failures
 
 
 @dataclass

core/dbt/include/global_project/macros/materializations/configs.sql

@@ -14,7 +14,10 @@
 
 {% macro should_store_failures() %}
   {% set config_store_failures = config.get('store_failures') %}
-  {% if config_store_failures is none %}
+  {% set config_store_failures_strategy = config.get('strategy') %}
+  {% if config_store_failures_strategy in ['view', 'table'] %}
+    {% set config_store_failures = True %}
+  {% elif config_store_failures is none %}
     {% set config_store_failures = flags.STORE_FAILURES %}
   {% endif %}
   {% do return(config_store_failures) %}

core/dbt/include/global_project/macros/materializations/tests/test.sql

@@ -1,8 +1,33 @@
 {%- materialization test, default -%}
 
   {% set relations = [] %}
+    {% set relation_type = config.get('strategy') %}
 
-  {% if should_store_failures() %}
+    {% if relation_type in ['view', 'table'] %}
+
+        {% set identifier = model['alias'] %}
+        {% set existing_relation = adapter.get_relation(database=database, schema=schema, identifier=identifier) %}
+        {% set target_relation = api.Relation.create(
+            database=database, schema=schema, identifier=identifier, type=relation_type
+        ) %}
+
+        {% call statement(auto_begin=True) %}
+            {% if existing_relation %}
+                {{ get_replace_sql(existing_relation, target_relation, sql) }}
+            {% else %}
+                {{ get_create_sql(target_relation, sql) }}
+            {% endif %}
+        {% endcall %}
+
+        {% do relations.append(target_relation) %}
+
+        {% set main_sql %}
+            select * from {{ target_relation }}
+        {% endset %}
+
+        {{ adapter.commit() }}
+
+  {% elif should_store_failures() %}
 
     {% set identifier = model['alias'] %}
     {% set old_relation = adapter.get_relation(database=database, schema=schema, identifier=identifier) %}

core/dbt/include/global_project/macros/relations/create.sql

@@ -6,7 +6,13 @@
 
 {%- macro default__get_create_sql(relation, sql) -%}
 
-    {%- if relation.is_materialized_view -%}
+    {%- if relation.is_view -%}
+        {{ get_create_view_as_sql(relation, sql) }}
+
+    {%- elif relation.is_table -%}
+        {{ get_create_table_as_sql(False, relation, sql) }}
+
+    {%- elif relation.is_materialized_view -%}
         {{ get_create_materialized_view_as_sql(relation, sql) }}
 
     {%- else -%}

core/dbt/parser/generic_test_builders.py

@@ -101,6 +101,7 @@
         "error_if",
         "fail_calc",
         "store_failures",
+        "strategy",
         "meta",
         "database",
         "schema",
@@ -149,7 +150,6 @@
             if not value and "config" in self.args:
                 value = self.args["config"].pop(key, None)
             if isinstance(value, str):
-
                 try:
                     value = get_rendered(value, render_ctx, native=True)
                 except UndefinedMacroError as e:
@@ -242,6 +242,10 @@
     def store_failures(self) -> Optional[bool]:
         return self.config.get("store_failures")
 
+    @property
+    def strategy(self) -> Optional[str]:
+        return self.config.get("strategy")
+
     @property
     def where(self) -> Optional[str]:
         return self.config.get("where")
@@ -294,6 +298,8 @@
             config["fail_calc"] = self.fail_calc
         if self.store_failures is not None:
             config["store_failures"] = self.store_failures
+        if self.strategy is not None:
+            config["strategy"] = self.strategy
         if self.meta is not None:
             config["meta"] = self.meta
         if self.database is not None:

tests/adapter/dbt/tests/adapter/store_test_failures_tests/test_persist_results.py

@@ -0,0 +1,77 @@
+import pytest
+
+from dbt.contracts.results import TestStatus
+from dbt.tests.util import run_dbt
+
+
+seeds__chipmunks_stage = """
+name,shirt
+alvin,red
+simon,blue
+theodore,green
+""".strip()
+
+
+models__chipmunks = """
+{{ config(materialized='view') }}
+select *
+from {{ ref('chipmunks_stage') }}
+"""
+
+tests__fail_with_view_strategy = """
+{{ config(strategy="view") }}
+select *
+from {{ ref('chipmunks') }}
+where shirt = 'green'
+"""
+
+
+tests__pass_with_view_strategy = """
+{{ config(strategy="view") }}
+select *
+from {{ ref('chipmunks') }}
+where shirt = 'purple'
+"""
+
+
+class TestPersistResults:
+    @pytest.fixture(scope="function", autouse=True)
+    def setup_teardown(self, project):
+        run_dbt(["seed"])
+        run_dbt(["run"])
+
+        yield
+
+        with project.adapter.connection_named("__test"):
+            test_results_schema = project.adapter.Relation.create(
+                database=project.database, schema=f"{project.test_schema}_dbt_test__audit"
+            )
+            relations_schema = project.adapter.Relation.create(
+                database=project.database, schema=project.test_schema
+            )
+            project.adapter.drop_schema(test_results_schema)
+            project.adapter.drop_schema(relations_schema)
+
+    @pytest.fixture(scope="class")
+    def seeds(self):
+        return {"chipmunks_stage.csv": seeds__chipmunks_stage}
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"chipmunks.sql": models__chipmunks}
+
+    @pytest.fixture(scope="class")
+    def tests(self):
+        return {
+            "fail_with_view_strategy.sql": tests__fail_with_view_strategy,
+            "pass_with_view_strategy.sql": tests__pass_with_view_strategy,
+        }
+
+    def test_tests_run_successfully_and_are_persisted_as_views(self, project):
+        results = run_dbt(["test"], expect_pass=False)
+        actual_results = {(result.node.name, result.status) for result in results}
+        expected_results = {
+            ("pass_with_view_strategy", TestStatus.Pass),
+            ("fail_with_view_strategy", TestStatus.Fail),
+        }
+        assert actual_results == expected_results