validate query children

commit e9e0ca7
Author: Gerit Wagner <gerit.wagner@uni-bamberg.de>
Date:   Sat May 31 07:52:38 2025 +0200

    setters > OrQuery, AndQuery, ...

commit afb9d76
Author: Gerit Wagner <gerit.wagner@uni-bamberg.de>
Date:   Sat May 31 07:46:46 2025 +0200

    setter validation + tests

Author: Gerit Wagner

search_query/query.py

@@ -223,9 +223,15 @@ def children(self) -> typing.List[Query]:
 
     @children.setter
     def children(self, children: typing.List[Query]) -> None:
-        """Set the children of this query node, updating parent pointers."""
+        """Set the children of the query, updating parent pointers."""
         # Clear existing children and reset parent links (if necessary)
         self._children.clear()
+        if not isinstance(children, list):
+            raise TypeError("children must be a list of Query instances or strings")
+
+        # Note: OrQuery, AndQuery, NearQuery, NotQuery, RANGEQuery offeride the setter
+        # with specific validation.
+
         # Add each new child using add_child (ensures parent is set)
         for child in children or []:
             self.add_child(child)
@@ -241,6 +247,8 @@ def add_child(self, child: typing.Union[str, Query]) -> Query:
                 search_field=self.search_field,
                 platform=self.platform,
             )
+        if not isinstance(child, Query):
+            raise TypeError("Child must be a Query instance or a string")
         child._set_parent(self)  # pylint: disable=protected-access
         self._children.append(child)
         return child

search_query/query_and.py

@@ -37,3 +37,23 @@ def __init__(
             position=position,
             platform=platform,
         )
+
+    @property
+    def children(self) -> typing.List[Query]:
+        """Children property."""
+        return self._children
+
+    @children.setter
+    def children(self, children: typing.List[Query]) -> None:
+        """Set the children of AND query, updating parent pointers."""
+        # Clear existing children and reset parent links (if necessary)
+        self._children.clear()
+        if not isinstance(children, list):
+            raise TypeError("children must be a list of Query instances or strings")
+
+        if len(children) < 2:
+            raise ValueError("An AND query must have two children")
+
+        # Add each new child using add_child (ensures parent is set)
+        for child in children or []:
+            self.add_child(child)

search_query/query_near.py

@@ -41,3 +41,23 @@ def __init__(
             distance=distance,
             platform=platform,
         )
+
+    @property
+    def children(self) -> typing.List[Query]:
+        """Children property."""
+        return self._children
+
+    @children.setter
+    def children(self, children: typing.List[Query]) -> None:
+        """Set the children of NEAR query, updating parent pointers."""
+        # Clear existing children and reset parent links (if necessary)
+        self._children.clear()
+        if not isinstance(children, list):
+            raise TypeError("children must be a list of Query instances or strings")
+
+        if len(children) != 2:
+            raise ValueError("A NEAR query must have two children")
+
+        # Add each new child using add_child (ensures parent is set)
+        for child in children or []:
+            self.add_child(child)

search_query/query_not.py

@@ -37,3 +37,23 @@ def __init__(
             position=position,
             platform=platform,
         )
+
+    @property
+    def children(self) -> typing.List[Query]:
+        """Children property."""
+        return self._children
+
+    @children.setter
+    def children(self, children: typing.List[Query]) -> None:
+        """Set the children of NOT query, updating parent pointers."""
+        # Clear existing children and reset parent links (if necessary)
+        self._children.clear()
+        if not isinstance(children, list):
+            raise TypeError("children must be a list of Query instances or strings")
+
+        if len(children) != 2:
+            raise ValueError("A NOT query must have two children")
+
+        # Add each new child using add_child (ensures parent is set)
+        for child in children or []:
+            self.add_child(child)

search_query/query_or.py

@@ -38,3 +38,23 @@ def __init__(
             position=position,
             platform=platform,
         )
+
+    @property
+    def children(self) -> typing.List[Query]:
+        """Children property."""
+        return self._children
+
+    @children.setter
+    def children(self, children: typing.List[Query]) -> None:
+        """Set the children of OR query, updating parent pointers."""
+        # Clear existing children and reset parent links (if necessary)
+        self._children.clear()
+        if not isinstance(children, list):
+            raise TypeError("children must be a list of Query instances or strings")
+
+        if len(children) < 2:
+            raise ValueError("An OR query must have two children")
+
+        # Add each new child using add_child (ensures parent is set)
+        for child in children or []:
+            self.add_child(child)

search_query/query_range.py

@@ -25,7 +25,7 @@ def __init__(
         nested queries: queries whose roots are appended to the query
         search field: search field to which the query should be applied
         """
-        assert len(children) == 2, "RangeQuery must have exactly two children"
+
         super().__init__(
             value=Operators.RANGE,
             children=children,
@@ -37,3 +37,23 @@ def __init__(
             position=position,
             platform=platform,
         )
+
+    @property
+    def children(self) -> typing.List[Query]:
+        """Children property."""
+        return self._children
+
+    @children.setter
+    def children(self, children: typing.List[Query]) -> None:
+        """Set the children of RANGE query, updating parent pointers."""
+        # Clear existing children and reset parent links (if necessary)
+        self._children.clear()
+        if not isinstance(children, list):
+            raise TypeError("children must be a list of Query instances or strings")
+
+        if len(children) != 2:
+            raise ValueError("A RANGE query must have two children")
+
+        # Add each new child using add_child (ensures parent is set)
+        for child in children or []:
+            self.add_child(child)

test/test_query.py

@@ -8,7 +8,9 @@
 from search_query.query import SearchField
 from search_query.query_and import AndQuery
 from search_query.query_near import NEARQuery
+from search_query.query_not import NotQuery
 from search_query.query_or import OrQuery
+from search_query.query_range import RangeQuery
 from search_query.utils import format_query_string_positions
 
 # pylint: disable=line-too-long
@@ -174,3 +176,105 @@ def test_value_setter() -> None:
         ethics.operator = "non_operators"  # type: ignore
 
     ethics.value = "NEAR"
+
+
+def test_children_setter() -> None:
+    """Test children setter."""
+    # Test for OrQuery ---------------------------------------------
+    or_query = OrQuery(
+        ["ethics", "morality"],
+        search_field="abstract",
+    )
+    assert or_query.children[0].value == "ethics"
+    assert or_query.children[1].value == "morality"
+
+    with pytest.raises(TypeError):
+        or_query.children = "not_a_list"  # type: ignore
+
+    with pytest.raises(TypeError):
+        or_query.children = ["valid", 123]  # type: ignore
+
+    with pytest.raises(ValueError):
+        or_query.children = ["new_child"]  # type: ignore
+
+    or_query.children = ["new_child", "another_child", "third_child"]  # type: ignore
+
+    # Test for AndQuery ---------------------------------------------
+    and_query = AndQuery(
+        ["ethics", "morality"],
+        search_field="abstract",
+    )
+    assert and_query.children[0].value == "ethics"
+    assert and_query.children[1].value == "morality"
+
+    with pytest.raises(TypeError):
+        and_query.children = "not_a_list"  # type: ignore
+
+    with pytest.raises(TypeError):
+        and_query.children = ["valid", 123]  # type: ignore
+
+    with pytest.raises(ValueError):
+        and_query.children = ["new_child"]  # type: ignore
+
+    and_query.children = ["new_child", "another_child", "third_child"]  # type: ignore
+
+    # Test for NotQuery ---------------------------------------------
+    not_query = NotQuery(
+        ["ethics"],
+        search_field="abstract",
+    )
+    assert not_query.children[0].value == "ethics"
+
+    with pytest.raises(TypeError):
+        not_query.children = "not_a_list"  # type: ignore
+
+    with pytest.raises(TypeError):
+        not_query.children = ["valid", 123]  # type: ignore
+
+    with pytest.raises(ValueError):
+        not_query.children = ["new_child", "another_child", "third_child"]  # type: ignore
+
+    with pytest.raises(ValueError):
+        not_query.children = ["new_child"]  # type: ignore
+
+    # Test for NEARQuery ---------------------------------------------
+    near_query = NEARQuery(
+        "NEAR",
+        distance=5,
+        children=["ethics", "morality"],
+        search_field="abstract",
+    )
+    assert near_query.children[0].value == "ethics"
+    assert near_query.children[1].value == "morality"
+
+    with pytest.raises(TypeError):
+        near_query.children = "not_a_list"  # type: ignore
+
+    with pytest.raises(TypeError):
+        near_query.children = ["valid", 123]  # type: ignore
+
+    with pytest.raises(ValueError):
+        near_query.children = ["new_child"]  # type: ignore
+
+    with pytest.raises(ValueError):
+        near_query.children = ["new_child", "another_child", "third_child"]  # type: ignore
+
+    # Test for RangeQuery ---------------------------------------------
+    range_query = RangeQuery(
+        children=["2010", "2020"],
+        search_field="year-publication",
+    )
+    assert range_query.children[0].value == "2010"
+    assert range_query.children[1].value == "2020"
+
+    with pytest.raises(TypeError):
+        range_query.children = "not_a_list"  # type: ignore
+
+    with pytest.raises(TypeError):
+        range_query.children = ["valid", 123]  # type: ignore
+
+    with pytest.raises(ValueError):
+        range_query.children = ["new_child"]  # type: ignore
+
+    with pytest.raises(ValueError):
+        range_query.children = ["new_child", "another_child", "third_child"]  # type: ignore