8295 unit testing artifacts

.changes/unreleased/Features-20230828-101825.yaml

@@ -0,0 +1,6 @@
+kind: Features
+body: Unit test manifest artifacts and selection
+time: 2023-08-28T10:18:25.958929-04:00
+custom:
+  Author: gshank
+  Issue: "8295"

core/dbt/cli/main.py

@@ -879,14 +879,12 @@ def test(ctx, **kwargs):
 @requires.project
 @requires.runtime_config
 @requires.manifest
-@requires.unit_test_collection
 def unit_test(ctx, **kwargs):
     """Runs tests on data in deployed models. Run this after `dbt run`"""
     task = UnitTestTask(
         ctx.obj["flags"],
         ctx.obj["runtime_config"],
         ctx.obj["manifest"],
-        ctx.obj["unit_test_collection"],
     )
 
     results = task.run()

core/dbt/cli/requires.py

@@ -23,7 +23,6 @@
 from dbt.profiler import profiler
 from dbt.tracking import active_user, initialize_from_flags, track_run
 from dbt.utils import cast_dict_to_dict_of_strings
-from dbt.parser.unit_tests import UnitTestManifestLoader
 from dbt.plugins import set_up_plugin_manager, get_plugin_manager
 
 from click import Context
@@ -266,25 +265,3 @@ def wrapper(*args, **kwargs):
     if len(args0) == 0:
         return outer_wrapper
     return outer_wrapper(args0[0])
-
-
-def unit_test_collection(func):
-    """A decorator used by click command functions for generating a unit test collection provided a manifest"""
-
-    def wrapper(*args, **kwargs):
-        ctx = args[0]
-        assert isinstance(ctx, Context)
-
-        req_strs = ["manifest", "runtime_config"]
-        reqs = [ctx.obj.get(req_str) for req_str in req_strs]
-
-        if None in reqs:
-            raise DbtProjectError("manifest and runtime_config required for unit_test_collection")
-
-        collection = UnitTestManifestLoader.load(ctx.obj["manifest"], ctx.obj["runtime_config"])
-
-        ctx.obj["unit_test_collection"] = collection
-
-        return func(*args, **kwargs)
-
-    return update_wrapper(wrapper, func)

core/dbt/compilation.py

@@ -96,6 +96,7 @@ def _generate_stats(manifest: Manifest):
     stats[NodeType.Macro] += len(manifest.macros)
     stats[NodeType.Group] += len(manifest.groups)
     stats[NodeType.SemanticModel] += len(manifest.semantic_models)
+    stats[NodeType.Unit] += len(manifest.unit_tests)
 
     # TODO: should we be counting dimensions + entities?
 
@@ -196,6 +197,8 @@ def link_graph(self, manifest: Manifest):
             self.link_node(exposure, manifest)
         for metric in manifest.metrics.values():
             self.link_node(metric, manifest)
+        for unit_test in manifest.unit_tests.values():
+            self.link_node(unit_test, manifest)
 
         cycle = self.find_cycles()
 

core/dbt/constants.py

@@ -14,3 +14,4 @@
 MANIFEST_FILE_NAME = "manifest.json"
 SEMANTIC_MANIFEST_FILE_NAME = "semantic_manifest.json"
 PARTIAL_PARSE_FILE_NAME = "partial_parse.msgpack"
+UNIT_TEST_MANIFEST_FILE_NAME = "unit_test_manifest.json"

core/dbt/contracts/files.py

@@ -231,6 +231,7 @@ class SchemaSourceFile(BaseSourceFile):
     # node patches contain models, seeds, snapshots, analyses
     ndp: List[str] = field(default_factory=list)
     semantic_models: List[str] = field(default_factory=list)
+    unit_tests: List[str] = field(default_factory=list)
     # any macro patches in this file by macro unique_id.
     mcp: Dict[str, str] = field(default_factory=dict)
     # any source patches in this file. The entries are package, name pairs

core/dbt/contracts/graph/manifest.py

@@ -40,6 +40,7 @@
     SemanticModel,
     SourceDefinition,
     UnpatchedSourceDefinition,
+    UnitTestDefinition,
 )
 from dbt.contracts.graph.unparsed import SourcePatch, NodeVersion, UnparsedVersion
 from dbt.contracts.graph.manifest_upgrade import upgrade_manifest_json
@@ -742,6 +743,7 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
     disabled: MutableMapping[str, List[GraphMemberNode]] = field(default_factory=dict)
     env_vars: MutableMapping[str, str] = field(default_factory=dict)
     semantic_models: MutableMapping[str, SemanticModel] = field(default_factory=dict)
+    unit_tests: MutableMapping[str, UnitTestDefinition] = field(default_factory=dict)
 
     _doc_lookup: Optional[DocLookup] = field(
         default=None, metadata={"serialize": lambda x: None, "deserialize": lambda x: None}
@@ -895,6 +897,7 @@ def deepcopy(self):
             files={k: _deepcopy(v) for k, v in self.files.items()},
             state_check=_deepcopy(self.state_check),
             semantic_models={k: _deepcopy(v) for k, v in self.semantic_models.items()},
+            unit_tests={k: _deepcopy(v) for k, v in self.unit_tests.items()},
         )
         copy.build_flat_graph()
         return copy
@@ -954,6 +957,7 @@ def writable_manifest(self) -> "WritableManifest":
             parent_map=self.parent_map,
             group_map=self.group_map,
             semantic_models=self.semantic_models,
+            unit_tests=self.unit_tests,
         )
 
     def write(self, path):
@@ -972,6 +976,8 @@ def expect(self, unique_id: str) -> GraphMemberNode:
             return self.metrics[unique_id]
         elif unique_id in self.semantic_models:
             return self.semantic_models[unique_id]
+        elif unique_id in self.unit_tests:
+            return self.unit_tests[unique_id]
         else:
             # something terrible has happened
             raise dbt.exceptions.DbtInternalError(
@@ -1374,6 +1380,12 @@ def add_semantic_model(self, source_file: SchemaSourceFile, semantic_model: Sema
         self.semantic_models[semantic_model.unique_id] = semantic_model
         source_file.semantic_models.append(semantic_model.unique_id)
 
+    def add_unit_test(self, source_file: SchemaSourceFile, unit_test: UnitTestDefinition):
+        if unit_test.unique_id in self.unit_tests:
+            raise DuplicateResourceNameError(unit_test, self.unit_tests[unit_test.unique_id])
+        self.unit_tests[unit_test.unique_id] = unit_test
+        source_file.unit_tests.append(unit_test.unique_id)
+
     # end of methods formerly in ParseResult
 
     # Provide support for copy.deepcopy() - we just need to avoid the lock!
@@ -1401,6 +1413,7 @@ def __reduce_ex__(self, protocol):
             self.disabled,
             self.env_vars,
             self.semantic_models,
+            self.unit_tests,
             self._doc_lookup,
             self._source_lookup,
             self._ref_lookup,
@@ -1479,6 +1492,11 @@ class WritableManifest(ArtifactMixin):
             description="Metadata about the manifest",
         )
     )
+    unit_tests: Mapping[UniqueID, UnitTestDefinition] = field(
+        metadata=dict(
+            description="The unit tests defined in the project",
+        )
+    )
 
     @classmethod
     def compatible_previous_versions(self):

core/dbt/contracts/graph/manifest_upgrade.py

@@ -83,6 +83,9 @@ def upgrade_manifest_json(manifest: dict, manifest_schema_version: int) -> dict:
         manifest["groups"] = {}
     if "group_map" not in manifest:
         manifest["group_map"] = {}
+    # add unit_tests key
+    if "unit_tests" not in manifest:
+        manifest["unit_tests"] = {}
     for metric_content in manifest.get("metrics", {}).values():
         # handle attr renames + value translation ("expression" -> "derived")
         metric_content = upgrade_ref_content(metric_content)

core/dbt/contracts/graph/nodes.py

@@ -34,7 +34,8 @@
     UnparsedSourceDefinition,
     UnparsedSourceTableDefinition,
     UnparsedColumn,
-    UnparsedUnitTestOverrides,
+    UnitTestOverrides,
+    InputFixture,
 )
 from dbt.contracts.graph.node_args import ModelNodeArgs
 from dbt.contracts.util import Replaceable, AdditionalPropertiesMixin
@@ -1055,7 +1056,22 @@ def test_node_type(self):
 class UnitTestNode(CompiledNode):
     resource_type: NodeType = field(metadata={"restrict": [NodeType.Unit]})
     attached_node: Optional[str] = None
-    overrides: Optional[UnparsedUnitTestOverrides] = None
+    overrides: Optional[UnitTestOverrides] = None
+
+
+@dataclass
+class UnitTestDefinition(GraphNode):
+    model: str
+    attached_node: str
+    given: Sequence[InputFixture]
+    expect: List[Dict[str, Any]]
+    description: str = ""
+    overrides: Optional[UnitTestOverrides] = None
+    depends_on: DependsOn = field(default_factory=DependsOn)
+
+    @property
+    def depends_on_nodes(self):
+        return self.depends_on.nodes
 
 
 # ====================================
@@ -1754,6 +1770,7 @@ class ParsedMacroPatch(ParsedPatch):
     Exposure,
     Metric,
     SemanticModel,
+    UnitTestDefinition,
 ]
 
 # All "nodes" (or node-like objects) in this file

core/dbt/contracts/graph/unparsed.py

@@ -671,34 +671,6 @@ def validate(cls, data):
             raise ValidationError("Group owner must have at least one of 'name' or 'email'.")
 
 
-@dataclass
-class UnparsedInputFixture(dbtClassMixin):
-    input: str
-    rows: List[Dict[str, Any]] = field(default_factory=list)
-
-
-@dataclass
-class UnparsedUnitTestOverrides(dbtClassMixin):
-    macros: Dict[str, Any] = field(default_factory=dict)
-    vars: Dict[str, Any] = field(default_factory=dict)
-    env_vars: Dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class UnparsedUnitTestCase(dbtClassMixin):
-    name: str
-    given: Sequence[UnparsedInputFixture]
-    expect: List[Dict[str, Any]]
-    description: str = ""
-    overrides: Optional[UnparsedUnitTestOverrides] = None
-
-
-@dataclass
-class UnparsedUnitTestSuite(dbtClassMixin):
-    model: str  # name of the model being unit tested
-    tests: Sequence[UnparsedUnitTestCase]
-
-
 #
 # semantic interfaces unparsed objects
 #
@@ -773,3 +745,31 @@ def normalize_date(d: Optional[datetime.date]) -> Optional[datetime.datetime]:
         dt = dt.astimezone()
 
     return dt
+
+
+@dataclass
+class InputFixture(dbtClassMixin):
+    input: str
+    rows: List[Dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class UnitTestOverrides(dbtClassMixin):
+    macros: Dict[str, Any] = field(default_factory=dict)
+    vars: Dict[str, Any] = field(default_factory=dict)
+    env_vars: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class UnparsedUnitTestDefinition(dbtClassMixin):
+    name: str
+    given: Sequence[InputFixture]
+    expect: List[Dict[str, Any]]
+    description: str = ""
+    overrides: Optional[UnitTestOverrides] = None
+
+
+@dataclass
+class UnparsedUnitTestSuite(dbtClassMixin):
+    model: str  # name of the model being unit tested
+    tests: Sequence[UnparsedUnitTestDefinition]

core/dbt/graph/selector.py

@@ -31,6 +31,8 @@ def can_select_indirectly(node):
     """
     if node.resource_type == NodeType.Test:
         return True
+    elif node.resource_type == NodeType.Unit:
+        return True
     else:
         return False
 
@@ -170,6 +172,8 @@ def _is_graph_member(self, unique_id: UniqueId) -> bool:
             return metric.config.enabled
         elif unique_id in self.manifest.semantic_models:
             return True
+        elif unique_id in self.manifest.unit_tests:
+            return True
         node = self.manifest.nodes[unique_id]
 
         if self.include_empty_nodes:
@@ -195,6 +199,8 @@ def _is_match(self, unique_id: UniqueId) -> bool:
             node = self.manifest.metrics[unique_id]
         elif unique_id in self.manifest.semantic_models:
             node = self.manifest.semantic_models[unique_id]
+        elif unique_id in self.manifest.unit_tests:
+            node = self.manifest.unit_tests[unique_id]
         else:
             raise DbtInternalError(f"Node {unique_id} not found in the manifest!")
         return self.node_is_match(node)
@@ -240,8 +246,11 @@ def expand_selection(
             )
 
         for unique_id in self.graph.select_successors(selected):
-            if unique_id in self.manifest.nodes:
-                node = self.manifest.nodes[unique_id]
+            if unique_id in self.manifest.nodes or unique_id in self.manifest.unit_tests:
+                if unique_id in self.manifest.nodes:
+                    node = self.manifest.nodes[unique_id]
+                elif unique_id in self.manifest.unit_tests:
+                    node = self.manifest.unit_tests[unique_id]  # type: ignore
                 if can_select_indirectly(node):
                     # should we add it in directly?
                     if indirect_selection == IndirectSelection.Eager or set(