Add test cases of ignore growing (#22896)

Signed-off-by: nico <cheng.yuan@zilliz.com>

tests/python_client/base/collection_wrapper.py

@@ -179,7 +179,7 @@ class ApiCollectionWrapper:
         timeout = TIMEOUT if timeout is None else timeout
 
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.collection.query, expr, output_fields, partition_names, timeout])
+        res, check = api_request([self.collection.query, expr, output_fields, partition_names, timeout], **kwargs)
         check_result = ResponseChecker(res, func_name, check_task, check_items, check,
                                        expression=expr, partition_names=partition_names,
                                        output_fields=output_fields,

tests/python_client/testcases/test_query.py

@@ -884,6 +884,52 @@ class TestQueryParams(TestcaseBase):
         collection_w.query(default_term_expr, partition_names=[partition_names],
                            check_task=CheckTasks.err_res, check_items=error)
 
+    @pytest.mark.tags(CaseLabel.L1)
+    def test_query_ignore_growing(self):
+        """
+        target: test query ignoring growing segment
+        method: 1. create a collection, insert data, create index and load
+                2. insert data again
+                3. query with param ignore_growing=True
+        expected: query successfully
+        """
+        # 1. create a collection
+        collection_w = self.init_collection_general(prefix, True)[0]
+
+        # 2. insert data again
+        data = cf.gen_default_dataframe_data(start=10000)
+        collection_w.insert(data)
+
+        # 3. query with param ignore_growing=True
+        res = collection_w.query('int64 >= 0', ignore_growing=True)[0]
+        assert len(res) == ct.default_nb
+        for ids in [res[i][default_int_field_name] for i in range(ct.default_nb)]:
+            assert ids < 10000
+
+    @pytest.mark.tags(CaseLabel.L2)
+    @pytest.mark.parametrize("ignore_growing", ct.get_invalid_strs[:8])
+    def test_query_invalid_ignore_growing_param(self, ignore_growing):
+        """
+        target: test query ignoring growing segment param invalid
+        method: 1. create a collection, insert data and load
+                2. insert data again
+                3. query with ignore_growing type invalid
+        expected: run as ignore_growing=False
+        """
+        if ignore_growing == 1:
+            pytest.skip("number is valid")
+        # 1. create a collection
+        collection_w = self.init_collection_general(prefix, True)[0]
+
+        # 2. insert data again
+        data = cf.gen_default_dataframe_data(start=10000)
+        collection_w.insert(data)
+
+        # 3. query with param ignore_growing invalid
+        error = {ct.err_code: 1, ct.err_msg: "parse search growing failed"}
+        collection_w.query('int64 >= 0', ignore_growing=ignore_growing,
+                           check_task=CheckTasks.err_res, check_items=error)
+
     @pytest.fixture(scope="function", params=[0, 10, 100])
     def offset(self, request):
         yield request.param

tests/python_client/testcases/test_search.py

@@ -834,6 +834,34 @@ class TestCollectionSearchInvalid(TestcaseBase):
                             check_items={"err_code": 1,
                                          "err_msg": f"Field {output_fields[-1]} not exist"})
 
+    @pytest.mark.tags(CaseLabel.L2)
+    @pytest.mark.parametrize("ignore_growing", ct.get_invalid_strs[:8])
+    def test_search_invalid_ignore_growing_param(self, ignore_growing):
+        """
+        target: test search ignoring growing segment
+        method: 1. create a collection, insert data, create index and load
+                2. insert data again
+                3. search with param ignore_growing invalid
+        expected: raise exception
+        """
+        if ignore_growing == 1:
+            pytest.skip("number is valid")
+        # 1. create a collection
+        collection_w = self.init_collection_general(prefix, True)[0]
+
+        # 2. insert data again
+        data = cf.gen_default_dataframe_data(start=10000)
+        collection_w.insert(data)
+
+        # 3. search with param ignore_growing=True
+        search_params = {"metric_type": "L2", "params": {"nprobe": 10}, "ignore_growing": ignore_growing}
+        vector = [[random.random() for _ in range(default_dim)] for _ in range(nq)]
+        collection_w.search(vector[:default_nq], default_search_field, search_params, default_limit,
+                            default_search_exp,
+                            check_task=CheckTasks.err_res,
+                            check_items={"err_code": 1,
+                                         "err_msg": "parse search growing failed"})
+
     @pytest.mark.tags(CaseLabel.L2)
     def test_search_param_invalid_travel_timestamp(self, get_invalid_travel_timestamp):
         """
@@ -2818,6 +2846,37 @@ class TestCollectionSearch(TestcaseBase):
                                          "limit": nb_old + nb_new,
                                          "_async": _async})
 
+    @pytest.mark.tags(CaseLabel.L1)
+    def test_search_ignore_growing(self, nq, dim, _async):
+        """
+        target: test search ignoring growing segment
+        method: 1. create a collection, insert data, create index and load
+                2. insert data again
+                3. search with param ignore_growing=True
+        expected: searched successfully
+        """
+        # 1. create a collection
+        collection_w = self.init_collection_general(prefix, True, dim=dim)[0]
+
+        # 2. insert data again
+        data = cf.gen_default_dataframe_data(dim=dim, start=10000)
+        collection_w.insert(data)
+
+        # 3. search with param ignore_growing=True
+        search_params = {"metric_type": "L2", "params": {"nprobe": 10}, "ignore_growing": True}
+        vector = [[random.random() for _ in range(dim)] for _ in range(nq)]
+        res = collection_w.search(vector[:nq], default_search_field, search_params, default_limit,
+                                  default_search_exp, _async=_async,
+                                  check_task=CheckTasks.check_search_results,
+                                  check_items={"nq": nq,
+                                               "limit": default_limit,
+                                               "_async": _async})[0]
+        if _async:
+            res.done()
+            res = res.result()
+        for ids in res[0].ids:
+            assert ids < 10000
+
     @pytest.mark.tags(CaseLabel.L1)
     @pytest.mark.parametrize("name", ["_co11ection", "co11_ection"])
     @pytest.mark.parametrize("index_name", ["_1ndeX", "In_0"])