fixed tests

Author: zilto

dlt/common/configuration/exceptions.py

@@ -147,7 +147,7 @@ def __init__(self, field_name: str, field_value: Any, hint: type) -> None:
         self.field_value = field_value
         self.hint = hint
         super().__init__(
-            f"Configured value for field {field_name} cannot be coerced into type {str(hint)}"
+            f"Configured value for field `{field_name}` cannot be coerced into type `{str(hint)}`"
         )
 
 

dlt/common/exceptions.py

@@ -141,7 +141,7 @@ def __init__(
         super().__init__(msg)
 
     def __str__(self) -> str:
-        return f"In path {self.path}: " + self.msg
+        return f"Path `{self.path}`: " + self.msg
 
 
 class ArgumentsOverloadException(DltException):

dlt/common/validation.py

@@ -68,11 +68,11 @@ def validate_dict(
     # check missing props
     missing = set(required_props.keys()).difference(props.keys())
     if len(missing):
-        raise DictValidationException(f"Missing required fields: `{missing}`", path)
+        raise DictValidationException(f"missing required fields `{missing}`", path)
     # check unknown props
     unexpected = set(props.keys()).difference(allowed_props.keys())
     if len(unexpected):
-        raise DictValidationException(f"Received unexpected fields: `{unexpected}`", path)
+        raise DictValidationException(f"received unexpected fields `{unexpected}`", path)
 
     def verify_prop(pk: str, pv: Any, t: Any) -> None:
         # covers none in optional and union types
@@ -99,7 +99,7 @@ def verify_prop(pk: str, pv: Any, t: Any) -> None:
                 if len(failed_validations) == len(union_types):
                     type_names = [get_type_name(ut) for ut in union_types]
                     msg = (
-                        f"field '{pk}' expects the following types: {', '.join(type_names)}."
+                        f"field '{pk}' expects the following types: {type_names}."
                         f" Provided value {pv} with type '{type(pv).__name__}' is invalid with the"
                         " following errors:\n"
                     )
@@ -121,12 +121,12 @@ def verify_prop(pk: str, pv: Any, t: Any) -> None:
             a_l = get_literal_args(t)
             if pv not in a_l:
                 raise DictValidationException(
-                    f"field '{pk}' with value `{pv}` is not one of: {a_l}", path, t, pk, pv
+                    f"field `{pk}={pv}` is not one of: {a_l}", path, t, pk, pv
                 )
         elif t in [int, bool, str, float]:
             if not isinstance(pv, t):
                 raise DictValidationException(
-                    f"field '{pk}' with value `{pv}` has invalid type '{type(pv).__name__}' while"
+                    f"field `{pk}={pv}` has invalid type '{type(pv).__name__}' while"
                     f" '{t.__name__}' is expected",
                     path,
                     t,

dlt/extract/incremental/__init__.py

@@ -285,8 +285,8 @@ def on_resolved(self) -> None:
                 msg = (
                     f"Incremental `initial_value={self.initial_value}` is greater than"
                     f" `end_value={self.end_value}` as determined by the custom `last_value_func`."
-                    f" The result of '{self.last_value_func.__name__}(`[end_value,"
-                    " initial_value]`)' must equal `end_value`"
+                    f" The result of `{self.last_value_func.__name__}([end_value,"
+                    " initial_value])` must equal `end_value`"
                 )
             raise ConfigurationValueError(msg)
 

dlt/sources/rest_api/config_setup.py

@@ -234,7 +234,7 @@ def setup_incremental_object(
             if param_config.get("end_value") or param_config.get("end_param"):
                 raise ValueError(
                     "Only `start_param` and `initial_value` are allowed in the configuration of"
-                    f" param: {param_name} "
+                    f" param: `{param_name}`. "
                     "To set `end_value` too use the incremental configuration at the resource"
                     " level. "
                     "See https://dlthub.com/docs/dlt-ecosystem/verified-sources/rest_api/basic#incremental-loading"
@@ -499,8 +499,8 @@ def _bind_path_params(resource: EndpointResource) -> None:
     if len(resolve_params) > 0:
         raise ValueError(
             f"Resource `{resource['name']}` defines resolve params `{resolve_params}` that are not"
-            f" bound in path `{path}`. To reference parent resource in query params use"
-            " resources.<parent_resource>.<field> syntax."
+            f" bound in path `{path}`. To reference parent resource in query params use syntax"
+            " 'resources.<parent_resource>.<field>'"
         )
 
     resource["endpoint"]["path"] = "".join(new_path_segments)
@@ -796,9 +796,9 @@ def collect_resolved_values(
             field_path = resolved_param.resolve_config["field"]
             raise ValueError(
                 f"Resource expects a field `{field_path}` to be present in the incoming data from"
-                f" resource `{parent_resource_name}` in order to bind it to path param"
+                f" resource `{parent_resource_name}` in order to bind it to path param:"
                 f" `{resolved_param.param_name}`. Available parent fields are:"
-                f" [{', '.join(item.keys())}]"
+                f" {list(item.keys())}"
             )
 
         params_values[resolved_param.param_name] = field_values[0]
@@ -893,7 +893,7 @@ def build_parent_record(
             raise ValueError(
                 f"Resource expects a field `{parent_key}` to be present in the incoming data "
                 f"from resource `{parent_resource_name}` in order to include it in child records"
-                f" under `{child_key}`. Available parent fields are: [{', '.join(item.keys())}]"
+                f" under `{child_key}`. Available parent fields are: {list(item.keys())}"
             )
         parent_record[child_key] = item[parent_key]
     return parent_record
@@ -976,7 +976,7 @@ def _raise_if_any_not_in(expressions: Set[str], available_contexts: Set[str], me
         if not any(expression.startswith(prefix + ".") for prefix in available_contexts):
             raise ValueError(
                 f"Expression `{expression}` defined in `{message}` is not valid. Valid expressions"
-                f" must start with one of: [{', '.join(available_contexts)}]. If you need to use"
+                f" must start with one of: `{available_contexts}`. If you need to use"
                 " literal curly braces in your expression, escape them by doubling them: {{ and"
                 " }}"
             )

dlt/sources/sql_database/helpers.py

@@ -88,7 +88,7 @@ def __init__(
                 self.cursor_column = table.c[column_name]
             except KeyError as e:
                 raise KeyError(
-                    f"Cursor column `{incremental.cursor_path} `does not exist in table"
+                    f"Cursor column `{incremental.cursor_path}` does not exist in table"
                     f" `{table.name}`"
                 ) from e
             self.last_value = incremental.last_value

tests/destinations/test_utils.py

@@ -40,5 +40,5 @@ def other_resource():
     def other_source():
         return [some_resource, other_resource]
 
-    with pytest.raises(ValueErrorWithKnownValues):
+    with pytest.raises(ValueError):
         get_resource_for_adapter(other_source())

tests/extract/test_incremental.py

@@ -2061,15 +2061,13 @@ def some_data(
     with pytest.raises(ConfigurationValueError) as ex:
         list(some_data(updated_at=dlt.sources.incremental(end_value=22)))
 
-    assert str(ex.value).startswith("Incremental 'end_value' was specified without 'initial_value'")
+    assert str(ex.value).startswith("Incremental `end_value` was specified without `initial_value`")
 
     # max function and end_value lower than initial_value
     with pytest.raises(ConfigurationValueError) as ex:
         list(some_data(updated_at=dlt.sources.incremental(initial_value=42, end_value=22)))
 
-    assert str(ex.value).startswith(
-        "Incremental 'initial_value' (42) is higher than 'end_value` (22)"
-    )
+    assert str(ex.value).startswith("Incremental `initial_value=42` is higher than `end_value=22`")
 
     # max function and end_value higher than initial_value
     with pytest.raises(ConfigurationValueError) as ex:
@@ -2081,9 +2079,7 @@ def some_data(
             )
         )
 
-    assert str(ex.value).startswith(
-        "Incremental 'initial_value' (22) is lower than 'end_value` (42)."
-    )
+    assert str(ex.value).startswith("Incremental `initial_value=22` is lower than `end_value=42`.")
 
     def custom_last_value(items):
         return max(items)
@@ -2099,7 +2095,7 @@ def custom_last_value(items):
         )
 
     assert (
-        "The result of 'custom_last_value([end_value, initial_value])' must equal 'end_value'"
+        "The result of `custom_last_value([end_value, initial_value])` must equal `end_value`"
         in str(ex.value)
     )
 

tests/helpers/dbt_tests/test_runner_dbt_versions.py

@@ -134,7 +134,7 @@ def test_dbt_run_exception_pickle() -> None:
     assert obj.command == "test"
     assert obj.run_results == "A"
     assert obj.dbt_results == "B"
-    assert str(obj) == "DBT command test could not be executed"
+    assert str(obj) == "DBT command `test` could not be executed"
 
 
 def test_runner_setup(client: PostgresClient, test_storage: FileStorage) -> None:

tests/load/pipeline/test_model_item_format.py

@@ -74,7 +74,7 @@
 )
 def test_model_builder_with_non_select_query(unsupported_model_query: str) -> None:
     with pytest.raises(
-        ValueError, match="Only SELECT statements are allowed to create a SqlModel."
+        ValueError, match="Only SELECT statements are allowed to create a `SqlModel`."
     ):
         SqlModel.from_query_string(query=unsupported_model_query)