From bc8fca80fa85c12b652add3f74985a4e3ae6f9ac Mon Sep 17 00:00:00 2001 From: NicoYuan1986 <109071306+NicoYuan1986@users.noreply.github.com> Date: Tue, 21 Mar 2023 19:06:00 +0800 Subject: [PATCH] Add test cases of ignore growing (#22896) Signed-off-by: nico --- .../python_client/base/collection_wrapper.py | 2 +- tests/python_client/testcases/test_query.py | 46 +++++++++++++++ tests/python_client/testcases/test_search.py | 59 +++++++++++++++++++ 3 files changed, 106 insertions(+), 1 deletion(-) diff --git a/tests/python_client/base/collection_wrapper.py b/tests/python_client/base/collection_wrapper.py index d029f96dd9..f6d869eb42 100644 --- a/tests/python_client/base/collection_wrapper.py +++ b/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, diff --git a/tests/python_client/testcases/test_query.py b/tests/python_client/testcases/test_query.py index b6ac9edc3a..67e7b1b26a 100644 --- a/tests/python_client/testcases/test_query.py +++ b/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 diff --git a/tests/python_client/testcases/test_search.py b/tests/python_client/testcases/test_search.py index e94b894e94..486dec36cd 100644 --- a/tests/python_client/testcases/test_search.py +++ b/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"])