Reorganize tests to match their code location

tests/unit/test_jinja.py → tests/unit/clients/test_jinja.py

@@ -1,4 +1,3 @@
-import unittest
 from contextlib import contextmanager
 
 import pytest
@@ -367,7 +366,7 @@ def expected_id(arg):
 
 
 @pytest.mark.parametrize("value,text_expectation,native_expectation", jinja_tests, ids=expected_id)
-def test_jinja_rendering(value, text_expectation, native_expectation):
+def test_jinja_rendering_string(value, text_expectation, native_expectation):
     foo_value = yaml.safe_load(value)["foo"]
     ctx = {"a_str": "100", "a_int": 100, "b_str": "hello"}
     with text_expectation as text_result:
@@ -377,40 +376,41 @@ def test_jinja_rendering(value, text_expectation, native_expectation):
         assert native_result == get_rendered(foo_value, ctx, native=True)
 
 
-class TestJinja(unittest.TestCase):
-    def test_do(self):
-        s = "{% set my_dict = {} %}\n{% do my_dict.update(a=1) %}"
+def test_do():
+    s = "{% set my_dict = {} %}\n{% do my_dict.update(a=1) %}"
 
-        template = get_template(s, {})
-        mod = template.make_module()
-        self.assertEqual(mod.my_dict, {"a": 1})
+    template = get_template(s, {})
+    mod = template.make_module()
+    assert mod.my_dict == {"a": 1}
 
-    def test_regular_render(self):
-        s = '{{ "some_value" | as_native }}'
-        value = get_rendered(s, {}, native=False)
-        assert value == "some_value"
-        s = "{{ 1991 | as_native }}"
-        value = get_rendered(s, {}, native=False)
-        assert value == "1991"
 
-        s = '{{ "some_value" | as_text }}'
-        value = get_rendered(s, {}, native=False)
-        assert value == "some_value"
-        s = "{{ 1991 | as_text }}"
-        value = get_rendered(s, {}, native=False)
-        assert value == "1991"
+def test_regular_render():
+    s = '{{ "some_value" | as_native }}'
+    value = get_rendered(s, {}, native=False)
+    assert value == "some_value"
+    s = "{{ 1991 | as_native }}"
+    value = get_rendered(s, {}, native=False)
+    assert value == "1991"
 
-    def test_native_render(self):
-        s = '{{ "some_value" | as_native }}'
-        value = get_rendered(s, {}, native=True)
-        assert value == "some_value"
-        s = "{{ 1991 | as_native }}"
-        value = get_rendered(s, {}, native=True)
-        assert value == 1991
+    s = '{{ "some_value" | as_text }}'
+    value = get_rendered(s, {}, native=False)
+    assert value == "some_value"
+    s = "{{ 1991 | as_text }}"
+    value = get_rendered(s, {}, native=False)
+    assert value == "1991"
 
-        s = '{{ "some_value" | as_text }}'
-        value = get_rendered(s, {}, native=True)
-        assert value == "some_value"
-        s = "{{ 1991 | as_text }}"
-        value = get_rendered(s, {}, native=True)
-        assert value == "1991"
+
+def test_native_render():
+    s = '{{ "some_value" | as_native }}'
+    value = get_rendered(s, {}, native=True)
+    assert value == "some_value"
+    s = "{{ 1991 | as_native }}"
+    value = get_rendered(s, {}, native=True)
+    assert value == 1991
+
+    s = '{{ "some_value" | as_text }}'
+    value = get_rendered(s, {}, native=True)
+    assert value == "some_value"
+    s = "{{ 1991 | as_text }}"
+    value = get_rendered(s, {}, native=True)
+    assert value == "1991"

tests/unit/config/test_selectors.py

@@ -4,7 +4,8 @@
 import yaml
 
 import dbt.exceptions
-from dbt.config.selectors import SelectorConfig, selector_config_from_data
+from dbt.config.selectors import SelectorConfig, SelectorDict, selector_config_from_data
+from dbt.exceptions import DbtSelectorsError
 
 
 def get_selector_dict(txt: str) -> dict:
@@ -201,3 +202,188 @@ def test_multiple_default_true(self):
             dbt.exceptions.DbtSelectorsError, "Found multiple selectors with `default: true`:"
         ):
             selector_config_from_data(dct)
+
+    def test_compare_cli_non_cli(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: nightly_diet_snowplow
+                description: "This uses more CLI-style syntax"
+                definition:
+                  union:
+                    - intersection:
+                        - '@source:snowplow'
+                        - 'tag:nightly'
+                    - 'models/export'
+                    - exclude:
+                        - intersection:
+                            - 'package:snowplow'
+                            - 'config.materialized:incremental'
+                        - export_performance_timing
+              - name: nightly_diet_snowplow_full
+                description: "This is a fuller YAML specification"
+                definition:
+                  union:
+                    - intersection:
+                        - method: source
+                          value: snowplow
+                          childrens_parents: true
+                        - method: tag
+                          value: nightly
+                    - method: path
+                      value: models/export
+                    - exclude:
+                        - intersection:
+                            - method: package
+                              value: snowplow
+                            - method: config.materialized
+                              value: incremental
+                        - method: fqn
+                          value: export_performance_timing
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list(dct["selectors"])
+        assert sel_dict
+        with_strings = sel_dict["nightly_diet_snowplow"]["definition"]
+        no_strings = sel_dict["nightly_diet_snowplow_full"]["definition"]
+        self.assertEqual(with_strings, no_strings)
+
+    def test_single_string_definition(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: nightly_selector
+                definition:
+                  'tag:nightly'
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list(dct["selectors"])
+        assert sel_dict
+        expected = {"method": "tag", "value": "nightly"}
+        definition = sel_dict["nightly_selector"]["definition"]
+        self.assertEqual(expected, definition)
+
+    def test_single_key_value_definition(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: nightly_selector
+                definition:
+                  tag: nightly
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list(dct["selectors"])
+        assert sel_dict
+        expected = {"method": "tag", "value": "nightly"}
+        definition = sel_dict["nightly_selector"]["definition"]
+        self.assertEqual(expected, definition)
+
+    def test_parent_definition(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: kpi_nightly_selector
+                definition:
+                  '+exposure:kpi_nightly'
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list(dct["selectors"])
+        assert sel_dict
+        expected = {"method": "exposure", "value": "kpi_nightly", "parents": True}
+        definition = sel_dict["kpi_nightly_selector"]["definition"]
+        self.assertEqual(expected, definition)
+
+    def test_plus_definition(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: my_model_children_selector
+                definition:
+                  'my_model+2'
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list(dct["selectors"])
+        assert sel_dict
+        expected = {"method": "fqn", "value": "my_model", "children": True, "children_depth": "2"}
+        definition = sel_dict["my_model_children_selector"]["definition"]
+        self.assertEqual(expected, definition)
+
+    def test_selector_definition(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: default
+                definition:
+                  union:
+                    - intersection:
+                      - tag: foo
+                      - tag: bar
+              - name: inherited
+                definition:
+                  method: selector
+                  value: default
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list(dct["selectors"])
+        assert sel_dict
+        definition = sel_dict["default"]["definition"]
+        expected = sel_dict["inherited"]["definition"]
+        self.assertEqual(expected, definition)
+
+    def test_selector_definition_with_exclusion(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: default
+                definition:
+                  union:
+                    - intersection:
+                      - tag: foo
+                      - tag: bar
+              - name: inherited
+                definition:
+                  union:
+                    - method: selector
+                      value: default
+                    - exclude:
+                      - tag: bar
+              - name: comparison
+                definition:
+                  union:
+                    - union:
+                      - intersection:
+                        - tag: foo
+                        - tag: bar
+                    - exclude:
+                      - tag: bar
+            """
+        )
+
+        sel_dict = SelectorDict.parse_from_selectors_list((dct["selectors"]))
+        assert sel_dict
+        definition = sel_dict["inherited"]["definition"]
+        expected = sel_dict["comparison"]["definition"]
+        self.assertEqual(expected, definition)
+
+    def test_missing_selector(self):
+        dct = get_selector_dict(
+            """\
+            selectors:
+              - name: inherited
+                definition:
+                  method: selector
+                  value: default
+            """
+        )
+        with self.assertRaises(DbtSelectorsError) as err:
+            SelectorDict.parse_from_selectors_list((dct["selectors"]))
+
+        self.assertEqual(
+            "Existing selector definition for default not found.", str(err.exception.msg)
+        )