task: add validation to DatetimeBasedCursor

Author: ChristoGrab

airbyte_cdk/sources/declarative/incremental/datetime_based_cursor.py

@@ -21,6 +21,7 @@
 )
 from airbyte_cdk.sources.message import MessageRepository
 from airbyte_cdk.sources.types import Config, Record, StreamSlice, StreamState
+from airbyte_cdk.utils.mapping_helpers import _validate_multiple_request_options
 
 
 @dataclass
@@ -121,6 +122,8 @@ def __post_init__(self, parameters: Mapping[str, Any]) -> None:
 
         if not self.cursor_datetime_formats:
             self.cursor_datetime_formats = [self.datetime_format]
+            
+        _validate_multiple_request_options(self.config, self.start_time_option, self.end_time_option)
 
     def get_stream_state(self) -> StreamState:
         return {self.cursor_field.eval(self.config): self._cursor} if self._cursor else {}  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__

unit_tests/utils/test_mapping_helpers.py

@@ -1,6 +1,6 @@
 import pytest
 
-from airbyte_cdk.utils.mapping_helpers import combine_mappings
+from airbyte_cdk.utils.mapping_helpers import combine_mappings, _validate_multiple_request_options, RequestOption, RequestOptionType
 
 
 @pytest.mark.parametrize(
@@ -46,14 +46,14 @@ def test_string_handling(test_name, mappings, expected_result, expected_error):
 @pytest.mark.parametrize(
     "test_name, mappings, expected_error",
     [
-        ("duplicate_keys_same_value", [{"a": 1}, {"a": 1}], "Duplicate keys found"),
-        ("duplicate_keys_different_value", [{"a": 1}, {"a": 2}], "Duplicate keys found"),
+        ("duplicate_keys_same_value", [{"a": 1}, {"a": 1}], "duplicate keys detected"),
+        ("duplicate_keys_different_value", [{"a": 1}, {"a": 2}], "duplicate keys detected"),
         (
             "nested_structure_not_allowed",
             [{"a": {"b": 1}}, {"a": {"c": 2}}],
-            "Duplicate keys found",
+            "duplicate keys detected",
         ),
-        ("any_nesting_not_allowed", [{"a": {"b": 1}}, {"a": {"d": 2}}], "Duplicate keys found"),
+        ("any_nesting_not_allowed", [{"a": {"b": 1}}, {"a": {"d": 2}}], "duplicate keys detected"),
     ],
 )
 def test_non_body_json_requests(test_name, mappings, expected_error):
@@ -96,13 +96,13 @@ def test_non_body_json_requests(test_name, mappings, expected_error):
             "nested_conflict",
             [{"a": {"b": 1}}, {"a": {"b": 2}}],
             None,
-            "Duplicate keys found",
+            "duplicate keys detected",
         ),
         (
             "type_conflict",
             [{"a": 1}, {"a": {"b": 2}}],
             None,
-            "Duplicate keys found",
+            "duplicate keys detected",
         ),
     ],
 )
@@ -113,3 +113,64 @@ def test_body_json_requests(test_name, mappings, expected_result, expected_error
             combine_mappings(mappings, allow_same_value_merge=True)
     else:
         assert combine_mappings(mappings, allow_same_value_merge=True) == expected_result
+
+
+@pytest.fixture
+def mock_config() -> dict[str, str]:
+    return {"test": "config"}
+
+@pytest.mark.parametrize(
+    "test_name, option1, option2, should_raise",
+    [
+        (
+            "different_fields",
+            RequestOption(field_name="field1", inject_into=RequestOptionType.body_json, parameters={}),
+            RequestOption(field_name="field2", inject_into=RequestOptionType.body_json, parameters={}),
+            False,
+        ),
+        (
+            "same_field_name_header",
+            RequestOption(field_name="field", inject_into=RequestOptionType.header, parameters={}),
+            RequestOption(field_name="field", inject_into=RequestOptionType.header, parameters={}),
+            True,
+        ),
+        (
+            "different_nested_paths",
+            RequestOption(field_path=["data", "query1", "limit"], inject_into=RequestOptionType.body_json, parameters={}),
+            RequestOption(field_path=["data", "query2", "limit"], inject_into=RequestOptionType.body_json, parameters={}),
+            False,
+        ),
+        (
+            "same_nested_paths",
+            RequestOption(field_path=["data", "query", "limit"], inject_into=RequestOptionType.body_json, parameters={}),
+            RequestOption(field_path=["data", "query", "limit"], inject_into=RequestOptionType.body_json, parameters={}),
+            True,
+        ),
+        (
+            "different_inject_types",
+            RequestOption(field_name="field", inject_into=RequestOptionType.header, parameters={}),
+            RequestOption(field_name="field", inject_into=RequestOptionType.body_json, parameters={}),
+            False,
+        ),
+    ]
+)
+def test_request_option_validation(test_name, option1, option2, should_raise, mock_config):
+    """Test various combinations of request option validation"""
+    if should_raise:
+        with pytest.raises(ValueError, match="duplicate keys detected"):
+            _validate_multiple_request_options(mock_config, option1, option2)
+    else:
+        _validate_multiple_request_options(mock_config, option1, option2)
+
+@pytest.mark.parametrize(
+    "test_name, options",
+    [
+        ("none_options", [None, RequestOption(field_name="field", inject_into=RequestOptionType.header, parameters={}), None]),
+        ("single_option", [RequestOption(field_name="field", inject_into=RequestOptionType.header, parameters={})]),
+        ("all_none", [None, None, None]),
+        ("empty_list", []),
+    ]
+)
+def test_edge_cases(test_name, options, mock_config):
+    """Test edge cases like None values and single options"""
+    _validate_multiple_request_options(mock_config, *options)