[skip ci] Update case (#5661)

* update index case
Signed-off-by: Nzhenwu <zhenwu@milvus.io>

* add index cases
Signed-off-by: Nzw <zw@milvus.io>

* update index case
Signed-off-by: Nzw <zw@milvus.io>

* update utility cases
Signed-off-by: Nzw <zw@milvus.io>

* [skip ci] update index cases
Signed-off-by: Nzw <zw@milvus.io>
Co-authored-by: Nzhenwu <zhenwu@milvus.io>
Co-authored-by: Nzw <zw@milvus.io>

tests20/python_client/base/index_wrapper.py

@@ -10,41 +10,33 @@ from utils.api_request import api_request
 class ApiIndexWrapper:
     index = None
 
-    def index_init(self, collection, field_name, index_params, name="", check_res=None, check_params=None, **kwargs):
+    def init_index(self, collection, field_name, index_params, name="",check_task=None, check_items=None, **kwargs):
         """ In order to distinguish the same name of index """
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([Index, collection, field_name, index_params, name], **kwargs)
-        self.index = res if check is True else None
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection=collection, field_name=field_name,
+        res, is_succ = api_request([Index, collection, field_name, index_params, name], **kwargs)
+        self.index = res if is_succ is True else None
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection=collection, field_name=field_name,
                                        index_params=index_params, name=name, **kwargs).run()
         return res, check_result
 
-    def name(self, check_res=None, check_params=None):
+    def drop(self, check_task=None, check_items=None, **kwargs):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.index.name])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
+        res, is_succ = api_request([self.index.drop], **kwargs)
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, **kwargs).run()
         return res, check_result
 
-    def params(self, check_res=None, check_params=None):
-        func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.index.params])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
-        return res, check_result
+    @property
+    def name(self):
+        return self.index.name
 
-    def collection_name(self, check_res=None, check_params=None):
-        func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.index.collection_name])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
-        return res, check_result
+    @property
+    def params(self):
+        return self.index.params
 
-    def field_name(self, check_res=None, check_params=None):
-        func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.index.field_name])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
-        return res, check_result
+    @property
+    def collection_name(self):
+        return self.index.collection_name
 
-    def drop(self, check_res=None, check_params=None, **kwargs):
-        func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.index.drop], **kwargs)
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, **kwargs).run()
-        return res, check_result
+    @property
+    def field_name(self):
+        return self.index.field_name
\ No newline at end of file

tests20/python_client/base/utility_wrapper.py

@@ -12,49 +12,49 @@ class ApiUtilityWrapper:
 
     ut = utility
 
-    def loading_progress(self, collection_name, partition_names=[], using="default", check_res=None, check_params=None):
+    def loading_progress(self, collection_name, partition_names=[], using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.loading_progress, collection_name, partition_names, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name,
+        res, is_succ = api_request([self.ut.loading_progress, collection_name, partition_names, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name,
                                        partition_names=partition_names, using=using).run()
         return res, check_result
 
-    def wait_for_loading_complete(self, collection_name, partition_names=[], timeout=None, using="default", check_res=None, check_params=None):
+    def wait_for_loading_complete(self, collection_name, partition_names=[], timeout=None, using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.wait_for_loading_complete, collection_name, partition_names, timeout, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name,
+        res, is_succ = api_request([self.ut.wait_for_loading_complete, collection_name, partition_names, timeout, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name,
                                        partition_names=partition_names, timeout=timeout, using=using).run()
         return res, check_result
 
-    def index_building_progress(self, collection_name, index_name="", using="default", check_res=None, check_params=None):
+    def index_building_progress(self, collection_name, index_name="", using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.index_building_progress, collection_name, index_name, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name, index_name=index_name,
+        res, is_succ = api_request([self.ut.index_building_progress, collection_name, index_name, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name, index_name=index_name,
                                        using=using).run()
         return res, check_result
 
-    def wait_for_index_building_complete(self, collection_name, index_name="", timeout=None, using="default", check_res=None, check_params=None):
+    def wait_for_index_building_complete(self, collection_name, index_name="", timeout=None, using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.wait_for_loading_complete, collection_name, index_name, timeout, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name, index_name=index_name,
+        res, is_succ = api_request([self.ut.wait_for_loading_complete, collection_name, index_name, timeout, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name, index_name=index_name,
                                        timeout=timeout, using=using).run()
         return res, check_result
 
-    def has_collection(self, collection_name, using="default", check_res=None, check_params=None):
+    def has_collection(self, collection_name, using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.has_collection, collection_name, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name, using=using).run()
+        res, is_succ = api_request([self.ut.has_collection, collection_name, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name, using=using).run()
         return res, check_result
 
-    def has_partition(self, collection_name, partition_name, using="default", check_res=None, check_params=None):
+    def has_partition(self, collection_name, partition_name, using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.has_partition, collection_name, partition_name, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name,
+        res, is_succ = api_request([self.ut.has_partition, collection_name, partition_name, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name,
                                        partition_name=partition_name, using=using).run()
         return res, check_result
 
-    def list_collections(self, timeout=None, using="default", check_res=None, check_params=None):
+    def list_collections(self, timeout=None, using="default", check_task=None, check_items=None):
         func_name = sys._getframe().f_code.co_name
-        res, check = api_request([self.ut.list_collections, timeout, using])
-        check_result = ResponseChecker(res, func_name, check_res, check_params, check, timeout=timeout, using=using).run()
+        res, is_succ = api_request([self.ut.list_collections, timeout, using])
+        check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, timeout=timeout, using=using).run()
         return res, check_result

tests20/python_client/common/common_func.py

@@ -235,3 +235,16 @@ def modify_file(file_path_list, is_modify=False, input_content=""):
                     f.write(input_content)
                     f.close()
                 log.info("[modify_file] file(%s) modification is complete." % file_path_list)
+
+
+def index_to_dict(index):
+    return {
+        "collection_name": index.collection_name,
+        "field_name": index.field_name,
+        # "name": index.name,
+        "params": index.params
+    }
+
+
+def assert_equal_index(index_1, index_2):
+    return index_to_dict(index_1) == index_to_dict(index_2)
\ No newline at end of file

tests20/python_client/common/common_type.py

@@ -26,6 +26,7 @@ default_tag = "1970_01_01"
 row_count = "row_count"
 default_desc = ""
 default_collection_desc = "default collection"
+default_index_name = "default_index_name"
 default_binary_desc = "default binary collection"
 collection_desc = "collection"
 int_field_desc = "int64 type field"

tests20/python_client/testcases/test_index.py

 import copy
+import pdb
 import pytest
 from pymilvus_orm import FieldSchema
 
@@ -8,7 +9,7 @@ from base.collection_wrapper import ApiCollectionWrapper
 from utils.util_log import test_log as log
 from common import common_func as cf
 from common import common_type as ct
-from common.common_type import CaseLabel
+from common.common_type import CaseLabel, CheckTasks
 
 prefix = "index"
 default_schema = cf.gen_default_collection_schema()
@@ -50,7 +51,11 @@ class TestIndexParams(TestcaseBase):
     # TODO: construct invalid index params for all index types
     @pytest.fixture(
         scope="function",
-        params=ct.get_invalid_strs
+        params=[
+            {"metric_type": "L3", "index_type": "IVF_FLAT"},
+            {"metric_type": "L2", "index_type": "IVF_FLAT", "err_params": {"nlist": 10}},
+            {"metric_type": "L2", "index_type": "IVF_FLAT", "params": {"nlist": -1}},
+        ]
     )
     def get_invalid_index_params(self, request):
         yield request.param
@@ -58,11 +63,14 @@ class TestIndexParams(TestcaseBase):
     # TODO: construct valid index params for all index types
     @pytest.fixture(
         scope="function",
-        params=ct.get_invalid_strs
+        params=[
+            default_index_params,
+        ]
     )
     def get_valid_index_params(self, request):
         yield request.param
 
+    @pytest.mark.xfail(reason="issue #5646")
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_collection_None(self):
         """
@@ -72,9 +80,8 @@ class TestIndexParams(TestcaseBase):
         """
         self._connect()
         index_name = cf.gen_unique_str(prefix)
-        ex, _ = self.index_wrap.index_init(None, default_field_name, default_index_params, name=index_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        self.index_wrap.init_index(None, default_field_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
+                                           err_code=1, err_msg="Collection")
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_field_name_invalid(self, get_invalid_field_name):
@@ -83,14 +90,12 @@ class TestIndexParams(TestcaseBase):
         method: input field name
         expected: raise exception
         """
-        self._connect()
         f_name = get_invalid_field_name
         index_name = cf.gen_unique_str(prefix)
         c_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
-        ex, _ = self.index_wrap.index_init(collection, f_name, default_index_params, name=index_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        collection_w = self.init_collection_wrap(name=c_name)
+        self.index_wrap.init_index(collection_w.collection, f_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
+                                            check_items={"err_code": 1, "err_msg": "must be str"})
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_field_name_not_existed(self):
@@ -99,14 +104,12 @@ class TestIndexParams(TestcaseBase):
         method: input field name not created
         expected: raise exception
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         f_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
-        ex, _ = self.index_wrap.index_init(collection, f_name, default_index_params, name=index_name)
-        log.error(str(ex))
-        assert "exist" in str(ex)
+        collection_w = self.init_collection_wrap(name=c_name)
+        self.index_wrap.init_index(collection_w.collection, f_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
+                                           check_items={"err_code": 1, "err_msg": "CreateIndex failed"})
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_type_invalid(self, get_invalid_index_type):
@@ -115,15 +118,13 @@ class TestIndexParams(TestcaseBase):
         method: input invalid index type
         expected: raise exception
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
+        collection_w = self.init_collection_wrap(name=c_name)
         index_params = copy.deepcopy(default_index_params)
         index_params["index_type"] = get_invalid_index_type
-        ex, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name, check_task=CheckTasks.err_res,
+                                        check_items={"err_code": 1, "err_msg": "must be str"})
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_type_not_supported(self):
@@ -132,16 +133,15 @@ class TestIndexParams(TestcaseBase):
         method: input unsupported index type
         expected: raise exception
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
+        collection_w = self.init_collection_wrap(name=c_name)
         index_params = copy.deepcopy(default_index_params)
         index_params["index_type"] = "IVFFFFFFF"
-        ex, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name, check_task=CheckTasks.err_res,
+                                        check_items={"err_code": 1, "err_msg": ""})
 
+    @pytest.mark.xfail(reason="issue #5653")
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_params_invalid(self, get_invalid_index_params):
         """
@@ -149,29 +149,26 @@ class TestIndexParams(TestcaseBase):
         method: input invalid index params
         expected: raise exception
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
+        collection_w = self.init_collection_wrap(name=c_name)
         index_params = get_invalid_index_params
-        ex, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name, check_task=CheckTasks.err_res,
+                                        check_items={"err_code": 1, "err_msg": ""})
 
+    # TODO: not supported
     @pytest.mark.tags(CaseLabel.L1)
-    def test_index_name_invalid(self, get_invalid_index_name):
+    def _test_index_name_invalid(self, get_invalid_index_name):
         """
         target: test index with error index name
         method: input invalid index name
         expected: raise exception
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = get_invalid_index_name
-        collection = self._collection(c_name)
-        ex, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        collection_w = self.init_collection_wrap(name=c_name)
+        self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
+                                        check_items={"err_code": 1, "err_msg": ""})
 
 
 class TestIndexBase(TestcaseBase):
@@ -184,13 +181,12 @@ class TestIndexBase(TestcaseBase):
         method: Index on empty collection
         expected: no exception raised
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
-        index, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
+        collection_w = self.init_collection_wrap(name=c_name)
+        index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
         # TODO: assert index
-        assert index == collection.indexes[0]
+        cf.assert_equal_index(index, collection_w.collection.indexes[0])
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_params(self, get_valid_index_params):
@@ -199,28 +195,28 @@ class TestIndexBase(TestcaseBase):
         method: input valid params
         expected: no exception raised
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
+        collection_w = self.init_collection_wrap(name=c_name)
         index_params = get_valid_index_params
-        index, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
+        index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name)
         # TODO: assert index
-        assert index == collection.indexes[0]
+        cf.assert_equal_index(index, collection_w.collection.indexes[0])
 
+    # TODO: not support
     @pytest.mark.tags(CaseLabel.L1)
-    def test_index_name_dup(self):
+    def _test_index_name_dup(self):
         """
         target: test index with duplicate index name
         method: create index with existed index name create by `collection.create_index`
         expected: no exception raised
         """
-        self._connect()
+        c_name = cf.gen_unique_str(prefix)
         index_name = ct.default_index_name
-        collection = self._collection()
-        self.collection_wrap.create_index(default_field_name, default_index_params, index_name=index_name)
-        ex, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
-        assert "dup" in str(ex)
+        collection_w = self.init_collection_wrap(name=c_name)
+        collection_w.collection.create_index(default_field_name, default_index_params, index_name=index_name)
+        self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
+                                        check_items={"err_code": 1, "err_msg": ""})
 
     # TODO: server not supported
     @pytest.mark.tags(CaseLabel.L1)
@@ -280,11 +276,10 @@ class TestIndexBase(TestcaseBase):
         method: create index with different indexes with multi threads
         expected: no exception raised
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = cf.gen_unique_str(prefix)
-        collection = self._collection(c_name)
-        ex, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
+        collection_w = self.init_collection_wrap(name=c_name)
+        ex, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
         assert "dup" in str(ex)
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -294,13 +289,13 @@ class TestIndexBase(TestcaseBase):
         method: create index by `index`, and then drop it
         expected: no exception raised
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         index_name = ct.default_index_name
-        collection = self._collection(c_name)
-        index, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
+        collection_w = self.init_collection_wrap(name=c_name)
+        index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
+        cf.assert_equal_index(index, collection_w.collection.indexes[0])
         self.index_wrap.drop()
-        assert len(collection.indexes) == 0
+        assert len(collection_w.collection.indexes) == 0
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_drop_repeatly(self):
@@ -309,19 +304,19 @@ class TestIndexBase(TestcaseBase):
         method: create index by `index`, and then drop it twice
         expected: exception raised
         """
-        self._connect()
-        c_name = cf.gen_unique_str(prefix)
+        c_name = cf.gen_unique_str(prefix)       
         index_name = ct.default_index_name
-        collection = self._collection(c_name)
-        index, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
-        _, _ = self.index_wrap.drop()
-        ex, _ = self.index_wrap.drop()
-        assert "error" in ex
+        collection_w = self.init_collection_wrap(name=c_name)
+        _, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
+        self.index_wrap.drop()
+        self.index_wrap.drop(check_task=CheckTasks.err_res,
+                                        check_items={"err_code": 1, "err_msg": "Index doesn't exist"})
 
 
 class TestIndexAdvanced(TestcaseBase):
     """ Test case of index interface """
 
+    @pytest.mark.xfail(reason="issue #5660")
     @pytest.mark.tags(CaseLabel.L2)
     def test_index_drop_multi_collections(self):
         """
@@ -329,18 +324,17 @@ class TestIndexAdvanced(TestcaseBase):
         method: create indexes by `index`, and then drop it, assert there is one index left
         expected: exception raised
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
         c_name_2 = cf.gen_unique_str(prefix)
         index_name = ct.default_index_name
-        collection = self._collection(c_name)
-        api_collection_2 = ApiCollectionWrapper()
-        api_index_2 = ApiIndexWrapper()
-        collection_2 = api_collection_2.init_collection(c_name_2)
-        self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
-        index_2, _ = api_index_2.index_init(collection_2, default_field_name, default_index_params, name=index_name)
+        cw = self.init_collection_wrap(name=c_name)
+        cw2 = self.init_collection_wrap(name=c_name_2)
+        iw_2 = ApiIndexWrapper()
+        self.index_wrap.init_index(cw.collection, default_field_name, default_index_params, name=index_name)
+        index_2, _ = iw_2.init_index(cw2.collection, default_field_name, default_index_params, name=index_name)
         self.index_wrap.drop()
-        assert index_2 in collection_2.indexes
+        assert cf.assert_equal_index(index_2, cw2.collection.indexes[0])
+        assert len(cw.collection.indexes) == 0
 
     @pytest.mark.tags(CaseLabel.L2)
     def _test_index_drop_during_inserting(self):

tests20/python_client/testcases/test_utility.py

 import copy
+import pdb
 import pytest
 from pymilvus_orm import FieldSchema
 from base.client_base import TestcaseBase
@@ -9,7 +10,7 @@ from base.utility_wrapper import ApiUtilityWrapper
 from utils.util_log import test_log as log
 from common import common_func as cf
 from common import common_type as ct
-from common.common_type import CaseLabel
+from common.common_type import CaseLabel, CheckTasks
 
 prefix = "utility"
 default_schema = cf.gen_default_collection_schema()
@@ -41,12 +42,8 @@ class TestUtilityParams(TestcaseBase):
         method: input invalid name
         expected: raise exception
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = get_invalid_collection_name
-        ex, _ = ut.has_collection(c_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        self.utility_wrap.has_collection(c_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "NoneType"})
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_has_partition_collection_name_invalid(self, get_invalid_collection_name):
@@ -55,13 +52,9 @@ class TestUtilityParams(TestcaseBase):
         method: input invalid name
         expected: raise exception
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = get_invalid_collection_name
         p_name = cf.gen_unique_str(prefix)
-        ex, _ = ut.has_partition(c_name, p_name)
-        log.error(str(ex))
-        assert "invalid" or "illegal" in str(ex)
+        self.utility_wrap.has_partition(c_name, p_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "NoneType"})
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_has_partition_name_invalid(self, get_invalid_partition_name):
@@ -162,11 +155,8 @@ class TestUtilityBase(TestcaseBase):
         method: input collection name created before
         expected: True
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
-        c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        res, _ = ut.has_collection(c_name)
+        cw = self.init_collection_wrap()
+        res, _ = self.utility_wrap.has_collection(cw.name)
         assert res is True
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -176,11 +166,9 @@ class TestUtilityBase(TestcaseBase):
         method: input random collection name
         expected: False
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
-        self._collection()
-        res, _ = ut.has_collection(c_name)
+        _ = self.init_collection_wrap()
+        res, _ = self.utility_wrap.has_collection(c_name)
         assert res is False
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -190,14 +178,12 @@ class TestUtilityBase(TestcaseBase):
         method: input random collection name
         expected: False
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        res, _ = ut.has_collection(c_name)
+        cw = self.init_collection_wrap(name=c_name)
+        res, _ = self.utility_wrap.has_collection(c_name)
         assert res is True
-        self.collection_wrap.drop()
-        res, _ = ut.has_collection(c_name)
+        cw.drop()
+        res, _ = self.utility_wrap.has_collection(c_name)
         assert res is False
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -207,14 +193,11 @@ class TestUtilityBase(TestcaseBase):
         method: input collection name and partition name created before
         expected: True
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
-        p_name = cf.gen_unique_str()
-        collection = self._collection(c_name)
-        api_p = ApiPartitionWrapper()
-        api_p.init_partition(collection, p_name)
-        res, _ = ut.has_partition(c_name, p_name)
+        p_name = cf.gen_unique_str(prefix)
+        cw = self.init_collection_wrap(name=c_name)
+        self.init_partition_wrap(cw, p_name)
+        res, _ = self.utility_wrap.has_partition(c_name, p_name)
         assert res is True
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -224,12 +207,10 @@ class TestUtilityBase(TestcaseBase):
         method: input collection name, and partition name not created before
         expected: True
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
         p_name = cf.gen_unique_str()
-        self._collection(c_name)
-        res, _ = ut.has_partition(c_name, p_name)
+        self.init_collection_wrap(name=c_name)
+        res, _ = self.utility_wrap.has_partition(c_name, p_name)
         assert res is False
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -239,19 +220,17 @@ class TestUtilityBase(TestcaseBase):
         method: input collection name, and partition name dropped
         expected: True
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
         p_name = cf.gen_unique_str()
-        collection = self._collection(c_name)
-        api_p = ApiPartitionWrapper()
-        api_p.init_partition(collection, p_name)
-        res, _ = ut.has_partition(c_name, p_name)
+        cw = self.init_collection_wrap(name=c_name)
+        pw = self.init_partition_wrap(cw, p_name)
+        res, _ = self.utility_wrap.has_partition(c_name, p_name)
         assert res is True
-        api_p.drop()
-        res, _ = ut.has_partition(c_name, p_name)
+        pw.drop()
+        res, _ = self.utility_wrap.has_partition(c_name, p_name)
         assert res is False
 
+    @pytest.mark.xfail(reason="issue #5667")
     @pytest.mark.tags(CaseLabel.L1)
     def test_list_collections(self):
         """
@@ -259,11 +238,9 @@ class TestUtilityBase(TestcaseBase):
         method: create collection, list_collections
         expected: in the result
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        res, _ = ut.list_collections()
+        self.init_collection_wrap(name=c_name)
+        res, _ = self.utility_wrap.list_collections()
         assert c_name in res
 
     # TODO: make sure all collections deleted
@@ -275,8 +252,7 @@ class TestUtilityBase(TestcaseBase):
         expected: length of the result equals to 0
         """
         self._connect()
-        ut = ApiUtilityWrapper()
-        res, _ = ut.list_collections()
+        res, _ = self.utility_wrap.list_collections()
         assert len(res) == 0
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -288,11 +264,9 @@ class TestUtilityBase(TestcaseBase):
         """
         self._connect()
         c_name = cf.gen_unique_str(prefix)
-        ut = ApiUtilityWrapper()
-        ex, _ = ut.index_building_progress(c_name)
-        log.error(str(ex))
-        assert "exist" in str(ex)
+        self.utility_wrap.index_building_progress(c_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "can't find collection"})
 
+    @pytest.mark.xfail(reason="issue #5673")
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_process_collection_empty(self):
         """
@@ -300,16 +274,15 @@ class TestUtilityBase(TestcaseBase):
         method: input empty collection
         expected: no exception raised
         """
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        ut = ApiUtilityWrapper()
-        res, _ = ut.index_building_progress(c_name)
-        assert "num_indexed_entities" in res
-        assert res["num_indexed_entities"] == 0
-        assert "num_total_entities" in res
-        assert res["num_total_entities"] == 0
-
+        self.init_collection_wrap(name=c_name)
+        res, _ = self.utility_wrap.index_building_progress(c_name)
+        assert "indexed_rows" in res
+        assert res["indexed_rows"] == 0
+        assert "total_rows" in res
+        assert res["total_rows"] == 0
+
+    @pytest.mark.xfail(reason="issue #5674")
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_process_collection_insert_no_index(self):
         """
@@ -318,40 +291,17 @@ class TestUtilityBase(TestcaseBase):
         expected: no exception raised
         """
         nb = 1
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
+        cw = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(nb)
-        self.collection_wrap.insert(data=data)
-        ut = ApiUtilityWrapper()
-        res, _ = ut.index_building_progress(c_name)
-        assert "num_indexed_entities" in res
-        assert res["num_indexed_entities"] == 0
-        assert "num_total_entities" in res
-        assert res["num_total_entities"] == nb
-
-    @pytest.mark.tags(CaseLabel.L1)
-    def test_index_process_collection_insert_index_not_enough(self):
-        """
-        target: test building_process
-        method: insert 1 entity, no index created
-        expected: no exception raised
-        """
-        nb = 1
-        self._connect()
-        c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        data = cf.gen_default_list_data(nb)
-        self.collection_wrap.insert(data=data)
-        self.collection_wrap.create_index(default_field_name, default_index_params)
-        ut = ApiUtilityWrapper()
-        ut.wait_for_index_building_complete(c_name)
-        res, _ = ut.index_building_progress(c_name)
-        assert "num_indexed_entities" in res
-        assert res["num_indexed_entities"] == 0
-        assert "num_total_entities" in res
-        assert res["num_total_entities"] == nb
-
+        cw.insert(data=data)
+        res, _ = self.utility_wrap.index_building_progress(c_name)
+        assert "indexed_rows" in res
+        assert res["indexed_rows"] == 0
+        assert "total_rows" in res
+        assert res["total_rows"] == nb
+
+    @pytest.mark.xfail(reason="issue #5674")
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_process_collection_index(self):
         """
@@ -360,19 +310,15 @@ class TestUtilityBase(TestcaseBase):
         expected: 1200 entity indexed
         """
         nb = 1200
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
+        cw = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(nb)
-        self.collection_wrap.insert(data=data)
-        self.collection_wrap.create_index(default_field_name, default_index_params)
-        ut = ApiUtilityWrapper()
-        ut.wait_for_index_building_complete(c_name)
-        res, _ = ut.index_building_progress(c_name)
-        assert "num_indexed_entities" in res
-        assert res["num_indexed_entities"] == nb
-        assert "num_total_entities" in res
-        assert res["num_total_entities"] == nb
+        cw.insert(data=data)
+        res, _ = self.utility_wrap.index_building_progress(c_name)
+        assert "indexed_rows" in res
+        assert res["indexed_rows"] == nb
+        assert "total_rows" in res
+        assert res["total_rows"] == nb
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_index_process_collection_indexing(self):
@@ -382,20 +328,18 @@ class TestUtilityBase(TestcaseBase):
         expected: 1200 entity indexed
         """
         nb = 1200
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
+        cw = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(nb)
-        self.collection_wrap.insert(data=data)
-        self.collection_wrap.create_index(default_field_name, default_index_params)
-        ut = ApiUtilityWrapper()
-        res, _ = ut.index_building_progress(c_name)
+        cw.insert(data=data)
+        cw.create_index(default_field_name, default_index_params)
+        res, _ = self.utility_wrap.index_building_progress(c_name)
         for _ in range(2):
-            assert "num_indexed_entities" in res
-            assert res["num_indexed_entities"] <= nb
-            assert res["num_indexed_entities"] >= 0
-            assert "num_total_entities" in res
-            assert res["num_total_entities"] == nb
+            assert "indexed_rows" in res
+            assert res["indexed_rows"] <= nb
+            assert res["indexed_rows"] >= 0
+            assert "total_rows" in res
+            assert res["total_rows"] == nb
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_wait_index_collection_not_existed(self):
@@ -406,10 +350,7 @@ class TestUtilityBase(TestcaseBase):
         """
         self._connect()
         c_name = cf.gen_unique_str(prefix)
-        ut = ApiUtilityWrapper()
-        ex, _ = ut.wait_for_index_building_complete(c_name)
-        log.error(str(ex))
-        assert "exist" in str(ex)
+        self.utility_wrap.wait_for_index_building_complete(c_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "can't find collection"})
 
     @pytest.mark.tags(CaseLabel.L1)
     def test_wait_index_collection_empty(self):
@@ -420,9 +361,8 @@ class TestUtilityBase(TestcaseBase):
         """
         self._connect()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        ut = ApiUtilityWrapper()
-        res, _ = ut.wait_for_index_building_complete(c_name)
+        self.init_collection_wrap(name=c_name)
+        res, _ = self.utility_wrap.wait_for_index_building_complete(c_name)
         assert res is None
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -433,17 +373,15 @@ class TestUtilityBase(TestcaseBase):
         expected: 1200 entity indexed
         """
         nb = 1200
-        self._connect()
         c_name = cf.gen_unique_str(prefix)
-        self._collection(c_name)
+        cw = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(nb)
-        self.collection_wrap.insert(data=data)
-        self.collection_wrap.create_index(default_field_name, default_index_params)
-        ut = ApiUtilityWrapper()
-        res, _ = ut.wait_for_index_building_complete(c_name)
+        cw.insert(data=data)
+        cw.create_index(default_field_name, default_index_params)
+        res, _ = self.utility_wrap.wait_for_index_building_complete(c_name)
         assert res is None
-        res, _ = ut.index_building_progress(c_name)
-        assert res["num_indexed_entities"] == nb
+        res, _ = self.utility_wrap.index_building_progress(c_name)
+        assert res["indexed_rows"] == nb
 
 
 class TestUtilityAdvanced(TestcaseBase):
@@ -456,15 +394,12 @@ class TestUtilityAdvanced(TestcaseBase):
         method: input collection name created before
         expected: True
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
         c_name_2 = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        api_c = ApiCollectionWrapper()
-        api_c.init_collection(c_name_2)
+        self.init_collection_wrap(name=c_name)
+        self.init_collection_wrap(name=c_name_2)
         for name in [c_name, c_name_2]:
-            res, _ = ut.has_collection(name)
+            res, _ = self.utility_wrap.has_collection(name)
             assert res is True
 
     @pytest.mark.tags(CaseLabel.L2)
@@ -474,13 +409,10 @@ class TestUtilityAdvanced(TestcaseBase):
         method: create collection, list_collections
         expected: in the result
         """
-        self._connect()
-        ut = ApiUtilityWrapper()
         c_name = cf.gen_unique_str(prefix)
         c_name_2 = cf.gen_unique_str(prefix)
-        self._collection(c_name)
-        api_c = ApiCollectionWrapper()
-        api_c.init_collection(c_name_2)
-        res, _ = ut.list_collections()
+        self.init_collection_wrap(name=c_name)
+        self.init_collection_wrap(name=c_name_2)
+        res, _ = self.utility_wrap.list_collections()
         for name in [c_name, c_name_2]:
             assert name in res

tests20/python_client/utils/api_request.py

+import traceback
 from utils.util_log import test_log as log
 
 
@@ -15,6 +16,7 @@ def api_request_catch():
                 log.debug("(api_res) Response : %s " % str(res))
                 return res, True
             except Exception as e:
+                log.error(traceback.format_exc())
                 log.error("[Milvus API Exception]%s: %s" % (str(func), str(e)))
                 return Error(e), False
         return inner_wrapper