chore: import upstream snapshot with attribution

tests/python_client/deploy/testcases/test_action_after_reinstall.py

@@ -0,0 +1,202 @@
+import pytest
+import random
+from common import common_func as cf
+from common import common_type as ct
+from common.common_type import CaseLabel, CheckTasks
+from common.milvus_sys import MilvusSys
+from utils.util_pymilvus import *
+from deploy.base import TestDeployBase
+from deploy import common as dc
+from deploy.common import gen_index_param, gen_search_param
+
+default_nb = ct.default_nb
+default_nq = ct.default_nq
+default_dim = ct.default_dim
+default_limit = ct.default_limit
+default_search_field = ct.default_float_vec_field_name
+default_search_params = ct.default_search_params
+default_int64_field_name = ct.default_int64_field_name
+default_float_field_name = ct.default_float_field_name
+default_bool_field_name = ct.default_bool_field_name
+default_string_field_name = ct.default_string_field_name
+binary_field_name = default_binary_vec_field_name
+default_search_exp = "int64 >= 0"
+default_term_expr = f'{ct.default_int64_field_name} in [0, 1]'
+
+
+class TestActionBeforeReinstall(TestDeployBase):
+    """ Test case of action before reinstall """
+
+    def teardown_method(self, method):
+        log.info(("*" * 35) + " teardown " + ("*" * 35))
+        log.info("[teardown_method] Start teardown test case %s..." %
+                 method.__name__)
+        log.info("skip drop collection")
+
+    @pytest.mark.skip()
+    @pytest.mark.tags(CaseLabel.L3)
+    @pytest.mark.parametrize("index_type", dc.all_index_types)  # , "BIN_FLAT"
+    def test_task_1(self, index_type, data_size):
+        """
+        before reinstall: create collection and insert data, load and search
+        after reinstall: get collection, search, create index, load, and search
+        """
+        name = "task_1_" + index_type
+        insert_data = False
+        is_binary = True if "BIN" in index_type else False
+        is_flush = False
+        # init collection
+        collection_w = self.init_collection_general(insert_data=insert_data, is_binary=is_binary, nb=data_size,
+                                                    is_flush=is_flush, name=name)[0]
+        if is_binary:
+            _, vectors_to_search = cf.gen_binary_vectors(
+                default_nb, default_dim)
+            default_search_field = ct.default_binary_vec_field_name
+        else:
+            vectors_to_search = cf.gen_vectors(default_nb, default_dim)
+            default_search_field = ct.default_float_vec_field_name
+        search_params = gen_search_param(index_type)[0]
+
+        # search
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            check_task=CheckTasks.check_search_results,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        # query
+        output_fields = [ct.default_int64_field_name]
+        collection_w.query(default_term_expr, output_fields=output_fields,
+                           check_task=CheckTasks.check_query_not_empty)
+        # create index
+        default_index = gen_index_param(index_type)
+        collection_w.create_index(default_search_field, default_index)
+        # release and load after creating index
+        collection_w.release()
+        collection_w.load()
+        # search
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            check_task=CheckTasks.check_search_results,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        # query
+        output_fields = [ct.default_int64_field_name]
+        collection_w.query(default_term_expr, output_fields=output_fields,
+                           check_task=CheckTasks.check_query_not_empty)
+
+    @pytest.mark.tags(CaseLabel.L3)
+    @pytest.mark.parametrize("index_type", dc.all_index_types)  # , "BIN_FLAT"
+    def test_task_2(self, index_type, data_size):
+        """
+        before reinstall: create collection, insert data and create index,load and search
+        after reinstall: get collection, search, insert data, create index, load, and search
+        """
+        name = "task_2_" + index_type
+        is_binary = True if "BIN" in index_type else False
+        # init collection
+        collection_w = self.init_collection_general(insert_data=False, is_binary=is_binary, nb=data_size,
+                                                    is_flush=False, name=name, active_trace=True)[0]
+        vectors_to_search = cf.gen_vectors(default_nb, default_dim)
+        default_search_field = ct.default_float_vec_field_name
+        if is_binary:
+            _, vectors_to_search = cf.gen_binary_vectors(
+                default_nb, default_dim)
+            default_search_field = ct.default_binary_vec_field_name
+
+        search_params = gen_search_param(index_type)[0]
+        output_fields = [ct.default_int64_field_name]
+        # search
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            output_fields=output_fields,
+                            check_task=CheckTasks.check_search_results,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        # query
+        collection_w.query(default_term_expr, output_fields=output_fields,
+                           check_task=CheckTasks.check_query_not_empty)
+        # insert data
+        self.init_collection_general(insert_data=True, is_binary=is_binary, nb=data_size,
+                                     is_flush=False, name=name, active_trace=True)
+        # create index
+        default_index = gen_index_param(index_type)
+        collection_w.create_index(default_search_field, default_index)
+        # release and load after
+        collection_w.release()
+        collection_w.load()
+        # search
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            output_fields=output_fields,
+                            check_task=CheckTasks.check_search_results,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        # query
+        collection_w.query(default_term_expr, output_fields=output_fields,
+                           check_task=CheckTasks.check_query_not_empty)
+
+    @pytest.mark.tags(CaseLabel.L3)
+    @pytest.mark.parametrize("replica_number", [0, 1, 2])
+    @pytest.mark.parametrize("is_compacted", [True, False])
+    @pytest.mark.parametrize("is_deleted", [True, False])
+    @pytest.mark.parametrize("is_string_indexed", [True, False])
+    @pytest.mark.parametrize("is_vector_indexed", [True, False])  # , "BIN_FLAT"
+    @pytest.mark.parametrize("segment_status", ["only_growing", "sealed", "all"])  # , "BIN_FLAT"
+    # @pytest.mark.parametrize("is_empty", [True, False])  # , "BIN_FLAT" (keep one is enough)
+    @pytest.mark.parametrize("index_type", random.sample(dc.all_index_types, 3))  # , "BIN_FLAT"
+    def test_task_all(self, index_type, is_compacted,
+                      segment_status, is_vector_indexed, is_string_indexed, replica_number, is_deleted, data_size):
+        """
+        before reinstall: create collection and insert data, load and search
+        after reinstall: get collection, search, create index, load, and search
+        """
+        name = f"index_type_{index_type}_segment_status_{segment_status}_is_vector_indexed_{is_vector_indexed}_is_string_indexed_{is_string_indexed}_is_compacted_{is_compacted}_is_deleted_{is_deleted}_replica_number_{replica_number}_data_size_{data_size}"
+        ms = MilvusSys()
+        is_binary = True if "BIN" in index_type else False
+        # insert with small size data without flush to get growing segment
+        collection_w = self.init_collection_general(insert_data=True, is_binary=is_binary, nb=3000,
+                                                    is_flush=False, name=name)[0]
+        
+        # load for growing segment
+        if replica_number > 0:
+            collection_w.load(replica_number=replica_number)
+
+        delete_expr = f"{ct.default_int64_field_name} in [0,1,2,3,4,5,6,7,8,9]"
+        # delete data for growing segment
+        if is_deleted:
+            collection_w.delete(expr=delete_expr)
+        if segment_status == "only_growing":
+            pytest.skip("already get growing segment, skip testcase")
+        # insert with flush multiple times to generate multiple sealed segment
+        for i in range(5):
+            self.init_collection_general(insert_data=True, is_binary=is_binary, nb=data_size,
+                                         is_flush=False, name=name)
+        if is_binary:
+            default_index_field = ct.default_binary_vec_field_name
+        else:
+            default_index_field = ct.default_float_vec_field_name
+        if is_vector_indexed:
+            # create index
+            default_index_param = gen_index_param(index_type)
+            collection_w.create_index(default_index_field, default_index_param)
+        if is_string_indexed:
+            # create index
+            default_string_index_params = {}
+            collection_w.create_index(default_string_field_name, default_string_index_params)
+        # delete data for sealed segment
+        delete_expr = f"{ct.default_int64_field_name} in [10,11,12,13,14,15,16,17,18,19]"
+        if is_deleted:
+            collection_w.delete(expr=delete_expr)
+        if is_compacted:
+            collection_w.compact()
+        # reload after flush and create index
+        if replica_number > 0:
+            collection_w.release()
+            collection_w.load(replica_number=replica_number)
+        
+
+

tests/python_client/deploy/testcases/test_action_before_reinstall.py

@@ -0,0 +1,125 @@
+import pytest
+from common import common_func as cf
+from common import common_type as ct
+from common.common_type import CaseLabel, CheckTasks
+from utils.util_pymilvus import *
+from deploy.base import TestDeployBase
+from deploy import common as dc
+from deploy.common import gen_index_param, gen_search_param
+
+
+default_nb = ct.default_nb
+default_nq = ct.default_nq
+default_dim = ct.default_dim
+default_limit = ct.default_limit
+default_search_field = ct.default_float_vec_field_name
+default_search_params = ct.default_search_params
+default_int64_field_name = ct.default_int64_field_name
+default_float_field_name = ct.default_float_field_name
+default_bool_field_name = ct.default_bool_field_name
+default_string_field_name = ct.default_string_field_name
+binary_field_name = default_binary_vec_field_name
+default_search_exp = "int64 >= 0"
+default_term_expr = f'{ct.default_int64_field_name} in [0, 1]'
+
+class TestActionBeforeReinstall(TestDeployBase):
+	""" Test case of action before reinstall """
+	def teardown_method(self, method):
+		log.info(("*" * 35) + " teardown " + ("*" * 35))
+		log.info("[teardown_method] Start teardown test case %s..." % method.__name__)
+		log.info("skip drop collection")
+
+	@pytest.mark.skip()
+	@pytest.mark.tags(CaseLabel.L3)
+	@pytest.mark.parametrize("index_type", dc.all_index_types) #, "BIN_FLAT"
+	def test_task_1(self, index_type, data_size):
+		"""
+        before reinstall: create collection and insert data, load and search
+        after reinstall: get collection, load, search, create index, load, and search
+		"""
+		name = "task_1_" + index_type
+		insert_data = True
+		is_binary = True if "BIN" in index_type else False
+		is_flush = False
+		collection_w = self.init_collection_general(insert_data=insert_data, is_binary=is_binary, nb=data_size,
+											        is_flush=is_flush, name=name)[0]
+		collection_w.load()
+
+		if is_binary:
+			_, vectors_to_search = cf.gen_binary_vectors(default_nb, default_dim)
+			default_search_field = ct.default_binary_vec_field_name
+		else:
+			vectors_to_search = cf.gen_vectors(default_nb, default_dim)
+			default_search_field = ct.default_float_vec_field_name
+		search_params = gen_search_param(index_type)[0]
+		collection_w.search(vectors_to_search[:default_nq], default_search_field,
+							search_params, default_limit,
+							default_search_exp,
+							check_task=CheckTasks.check_search_results,
+							check_items={"nq": default_nq,
+										 "limit": default_limit})
+		output_fields = [ct.default_int64_field_name]
+		collection_w.query(default_term_expr, output_fields=output_fields,
+						   check_task=CheckTasks.check_query_not_empty)
+
+	@pytest.mark.tags(CaseLabel.L3)
+	@pytest.mark.parametrize("index_type", dc.all_index_types)  # , "BIN_FLAT"
+	def test_task_2(self, index_type, data_size):
+		"""
+        before reinstall: create collection, insert data and create index,load and search
+        after reinstall: get collection, load, search, insert data, create index, load, and search
+		"""
+		name = "task_2_" + index_type
+		insert_data = True
+		is_binary = True if "BIN" in index_type else False
+		is_flush = False
+		# create collection and insert data
+		collection_w = self.init_collection_general(insert_data=insert_data, is_binary=is_binary, nb=data_size,
+													is_flush=is_flush, name=name, active_trace=True)[0]
+		vectors_to_search = cf.gen_vectors(default_nb, default_dim)
+		default_search_field = ct.default_float_vec_field_name
+		if is_binary:
+			_, vectors_to_search = cf.gen_binary_vectors(default_nb, default_dim)
+			default_search_field = ct.default_binary_vec_field_name
+		# create index
+		default_index = gen_index_param(index_type)
+		collection_w.create_index(default_search_field, default_index)
+		# load
+		collection_w.load()
+		# search
+		search_params = gen_search_param(index_type)[0]
+		collection_w.search(vectors_to_search[:default_nq], default_search_field,
+							search_params, default_limit,
+							default_search_exp,
+							check_task=CheckTasks.check_search_results,
+							check_items={"nq": default_nq,
+										 "limit": default_limit})
+		# query
+		output_fields = [ct.default_int64_field_name]
+		collection_w.query(default_term_expr, output_fields=output_fields,
+						   check_task=CheckTasks.check_query_not_empty)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

tests/python_client/deploy/testcases/test_action_first_deployment.py

@@ -0,0 +1,220 @@
+import pytest
+import pymilvus
+from common import common_func as cf
+from common import common_type as ct
+from common.common_type import CaseLabel, CheckTasks
+from common.milvus_sys import MilvusSys
+from utils.util_pymilvus import *
+from deploy.base import TestDeployBase
+from deploy.common import gen_index_param, gen_search_param
+from utils.util_log import test_log as log
+
+pymilvus_version = pymilvus.__version__
+
+default_nb = ct.default_nb
+default_nq = ct.default_nq
+default_dim = ct.default_dim
+default_limit = ct.default_limit
+default_search_field = ct.default_float_vec_field_name
+default_search_params = ct.default_search_params
+default_int64_field_name = ct.default_int64_field_name
+default_float_field_name = ct.default_float_field_name
+default_bool_field_name = ct.default_bool_field_name
+default_string_field_name = ct.default_string_field_name
+binary_field_name = ct.default_binary_vec_field_name
+default_search_exp = "int64 >= 0"
+default_term_expr = f'{ct.default_int64_field_name} in [0, 1]'
+
+prefix = "deploy_test"
+
+TIMEOUT = 120
+
+
+class TestActionFirstDeployment(TestDeployBase):
+    """ Test case of action before reinstall """
+
+    def teardown_method(self, method):
+        log.info(("*" * 35) + " teardown " + ("*" * 35))
+        log.info("[teardown_method] Start teardown test case %s..." %
+                 method.__name__)
+        log.info("skip drop collection")
+
+    @pytest.mark.tags(CaseLabel.L3)
+    @pytest.mark.parametrize("replica_number", [0])
+    @pytest.mark.parametrize("index_type", ["HNSW", "BIN_IVF_FLAT"])
+    def test_task_all_empty(self, index_type, replica_number):
+        """
+        before reinstall: create collection
+        """
+        name = ""
+        for k, v in locals().items():
+            if k in ["self", "name"]:
+                continue
+            name += f"_{k}_{v}"
+        name = prefix + name + "_" + "empty"
+        is_binary = False
+        if "BIN" in name:
+            is_binary = True
+        collection_w = \
+            self.init_collection_general(insert_data=False, is_binary=is_binary, name=name, enable_dynamic_field=False,
+                                         with_json=False, is_index=False)[0]
+        if collection_w.has_index():
+            index_names = [index.index_name for index in collection_w.indexes]
+            for index_name in index_names:
+                collection_w.drop_index(index_name=index_name)
+
+    @pytest.mark.tags(CaseLabel.L3)
+    @pytest.mark.parametrize("replica_number", [0, 1, 2])
+    @pytest.mark.parametrize("is_compacted", ["is_compacted", "not_compacted"])
+    @pytest.mark.parametrize("is_deleted", ["is_deleted"])
+    @pytest.mark.parametrize("is_scalar_indexed", ["is_scalar_indexed", "not_scalar_indexed"])
+    @pytest.mark.parametrize("segment_status", ["only_growing", "all"])
+    @pytest.mark.parametrize("index_type", ["HNSW", "BIN_IVF_FLAT", "IVF_FLAT", "IVF_SQ8", "IVF_PQ"])
+    def test_task_all(self, index_type, is_compacted,
+                      segment_status, is_scalar_indexed, replica_number, is_deleted, data_size):
+        """
+        before reinstall: create collection and insert data, load and search
+        """
+        name = ""
+        for k, v in locals().items():
+            if k in ["self", "name"]:
+                continue
+            name += f"_{k}_{v}"
+        name = prefix + name
+        log.info(f"collection name: {name}")
+        self._connect()
+        ms = MilvusSys()
+        if len(ms.query_nodes) < replica_number:
+            # this step is to make sure this testcase can run on standalone mode
+            # or cluster mode which has only one querynode
+            pytest.skip("skip test, not enough nodes")
+
+        log.info(f"collection name: {name}, replica_number: {replica_number}, is_compacted: {is_compacted},"
+                 f"is_deleted: {is_deleted}, is_scalar_indexed: {is_scalar_indexed},"
+                 f"segment_status: {segment_status}, index_type: {index_type}")
+
+        is_binary = True if "BIN" in index_type else False
+
+        # params for search and query
+        if is_binary:
+            _, vectors_to_search = cf.gen_binary_vectors(
+                default_nb, default_dim)
+            default_search_field = ct.default_binary_vec_field_name
+        else:
+            vectors_to_search = cf.gen_vectors(default_nb, default_dim)
+            default_search_field = ct.default_float_vec_field_name
+        search_params = gen_search_param(index_type)[0]
+
+        # init collection and insert with small size data without flush to get growing segment
+        collection_w = self.init_collection_general(insert_data=True, is_binary=is_binary, nb=3000,
+                                                    is_flush=False, is_index=False, name=name,
+                                                    enable_dynamic_field=False,
+                                                    with_json=False)[0]
+        # params for creating index
+        if is_binary:
+            default_index_field = ct.default_binary_vec_field_name
+        else:
+            default_index_field = ct.default_float_vec_field_name
+
+        # create index for vector
+        default_index_param = gen_index_param(index_type)
+        collection_w.create_index(default_index_field, default_index_param)
+        # create index for scalar
+        if is_scalar_indexed == "is_scalar_indexed":
+            int_field_name = cf.get_int64_field_name(schema=collection_w.schema)
+            # create stl sort index for int field
+            collection_w.create_index(int_field_name, {"index_type": "STL_SORT"})
+
+            varchar_field_name = cf.get_varchar_field_name(schema=collection_w.schema)
+            # 50% chance to create trie index for varchar field
+            if random.randint(0, 1) == 1:
+                collection_w.create_index(varchar_field_name, {"index_type": "TRIE"})
+            scalar_field_names = cf.get_scalar_field_name_list(schema=collection_w.schema)
+            indexes = [index.to_dict() for index in collection_w.indexes]
+            indexed_fields = [index['field'] for index in indexes]
+            # create inverted index for other scalar field
+            for f in scalar_field_names:
+                if f in indexed_fields:
+                    continue
+                collection_w.create_index(f, {"index_type": "INVERTED"},)
+
+        # load for growing segment
+        if replica_number >= 1:
+            try:
+                collection_w.release()
+            except Exception as e:
+                log.error(
+                    f"release collection failed: {e} maybe the collection is not loaded")
+            collection_w.load(replica_number=replica_number, timeout=TIMEOUT)
+            self.utility_wrap.wait_for_loading_complete(name)
+
+        # delete data for growing segment
+        delete_expr = f"{ct.default_int64_field_name} in {[i for i in range(0, 10)]}"
+        if is_deleted == "is_deleted":
+            collection_w.delete(expr=delete_expr)
+
+        # search and query for growing segment
+        if replica_number >= 1:
+            collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                                search_params, default_limit,
+                                default_search_exp,
+                                check_task=CheckTasks.check_search_results,
+                                check_items={"nq": default_nq,
+                                             "limit": default_limit})
+            output_fields = [ct.default_int64_field_name]
+            collection_w.query(default_term_expr, output_fields=output_fields,
+                               check_task=CheckTasks.check_query_not_empty)
+
+        # skip subsequent operations when segment_status is set to only_growing
+        if segment_status == "only_growing":
+            pytest.skip(
+                "already get growing segment, skip subsequent operations")
+        # insert with flush multiple times to generate multiple sealed segment
+        for i in range(5):
+            self.init_collection_general(insert_data=True, is_binary=is_binary, nb=data_size,
+                                         is_flush=False, is_index=False, name=name, enable_dynamic_field=False,
+                                         with_json=False)
+            # at this step, all segment are sealed
+            if pymilvus_version >= "2.2.0":
+                collection_w.flush()
+            else:
+                collection_w.collection.num_entities
+        # delete data for sealed segment and before index
+        delete_expr = f"{ct.default_int64_field_name} in {[i for i in range(10, 20)]}"
+        if is_deleted == "is_deleted":
+            collection_w.delete(expr=delete_expr)
+
+        # delete data for sealed segment and after index
+        delete_expr = f"{ct.default_int64_field_name} in {[i for i in range(20, 30)]}"
+        if is_deleted == "is_deleted":
+            collection_w.delete(expr=delete_expr)
+        if is_compacted == "is_compacted":
+            collection_w.compact()
+        # get growing segment before reload
+        if segment_status == "all":
+            self.init_collection_general(insert_data=True, is_binary=is_binary, nb=3000,
+                                         is_flush=False, is_index=False, name=name, enable_dynamic_field=False,
+                                         with_json=False)
+        # reload after flush and creating index
+        if replica_number > 0:
+            collection_w.release()
+            collection_w.load(replica_number=replica_number, timeout=TIMEOUT)
+            self.utility_wrap.wait_for_loading_complete(name)
+
+        # insert data to get growing segment after reload
+        if segment_status == "all":
+            self.init_collection_general(insert_data=True, is_binary=is_binary, nb=3000,
+                                         is_flush=False, is_index=False, name=name, enable_dynamic_field=False,
+                                         with_json=False)
+
+        # search and query for sealed and growing segment
+        if replica_number > 0:
+            collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                                search_params, default_limit,
+                                default_search_exp,
+                                check_task=CheckTasks.check_search_results,
+                                check_items={"nq": default_nq,
+                                             "limit": default_limit})
+            output_fields = [ct.default_int64_field_name]
+            collection_w.query(default_term_expr, output_fields=output_fields,
+                               check_task=CheckTasks.check_query_not_empty)

tests/python_client/deploy/testcases/test_action_second_deployment.py

@@ -0,0 +1,231 @@
+import pytest
+import re
+import time
+import pymilvus
+from common import common_func as cf
+from common import common_type as ct
+from common.common_type import CaseLabel, CheckTasks
+from common.milvus_sys import MilvusSys
+from utils.util_pymilvus import *
+from deploy.base import TestDeployBase
+from deploy.common import gen_index_param, gen_search_param, get_deploy_test_collections
+from utils.util_log import test_log as log
+
+default_nb = ct.default_nb
+default_nq = ct.default_nq
+default_dim = ct.default_dim
+default_limit = ct.default_limit
+default_search_field = ct.default_float_vec_field_name
+default_search_params = ct.default_search_params
+default_int64_field_name = ct.default_int64_field_name
+default_float_field_name = ct.default_float_field_name
+default_bool_field_name = ct.default_bool_field_name
+default_string_field_name = ct.default_string_field_name
+binary_field_name = ct.default_binary_vec_field_name
+default_search_exp = "int64 >= 0"
+default_term_expr = f'{ct.default_int64_field_name} in [0, 1]'
+
+pymilvus_version = pymilvus.__version__
+
+
+class TestActionSecondDeployment(TestDeployBase):
+    """ Test case of action before reinstall """
+
+    @pytest.fixture(scope="function", params=get_deploy_test_collections())
+    def all_collection_name(self, request):
+        if request.param == [] or request.param == "":
+            pytest.skip("The collection name is invalid")
+        yield request.param
+
+    def teardown_method(self, method):
+        log.info(("*" * 35) + " teardown " + ("*" * 35))
+        log.info("[teardown_method] Start teardown test case %s..." %
+                 method.__name__)
+        log.info("show collection info")
+        log.info(f"collection {self.collection_w.name} has entities: {self.collection_w.num_entities}")
+
+        res, _ = self.utility_wrap.get_query_segment_info(self.collection_w.name)
+        log.info(f"The segment info of collection {self.collection_w.name} is {res}")
+
+        index_infos = [index.to_dict() for index in self.collection_w.indexes]
+        log.info(f"collection {self.collection_w.name} index infos {index_infos}")
+        log.info("skip drop collection")
+
+    def create_index(self, collection_w, default_index_field, default_index_param):
+
+        index_field_map = dict([(index.field_name, index.index_name) for index in collection_w.indexes])
+        index_infos = [index.to_dict() for index in collection_w.indexes]
+        log.info(f"index info: {index_infos}")
+        # log.info(f"{default_index_field:} {default_index_param:}")
+        if len(index_infos) > 0:
+            log.info(
+                f"current index param is {index_infos[0]['index_param']}, passed in param is {default_index_param}")
+            log.info(
+                f"current index name is {index_infos[0]['index_name']}, passed in param is {index_field_map.get(default_index_field)}")
+        collection_w.create_index(default_index_field, default_index_param,
+                                  index_name=index_field_map.get(default_index_field, gen_unique_str("test")))
+        collection_w.create_index(default_string_field_name, {},
+                                  index_name=index_field_map.get(default_string_field_name, gen_unique_str("test")))
+
+    @pytest.mark.tags(CaseLabel.L3)
+    def test_check(self, all_collection_name, data_size):
+        """
+        before reinstall: create collection
+        """
+        self._connect()
+        ms = MilvusSys()
+        name = all_collection_name
+        is_binary = False
+        if "BIN" in name:
+            is_binary = True
+        collection_w, _ = self.collection_wrap.init_collection(name=name)
+        self.collection_w = collection_w
+        schema = collection_w.schema
+        data_type = [field.dtype for field in schema.fields]
+        field_name = [field.name for field in schema.fields]
+        type_field_map = dict(zip(data_type, field_name))
+        if is_binary:
+            default_index_field = ct.default_binary_vec_field_name
+            vector_index_type = "BIN_IVF_FLAT"
+        else:
+            default_index_field = ct.default_float_vec_field_name
+            vector_index_type = "IVF_FLAT"
+
+        binary_vector_index_types = [index.params["index_type"] for index in collection_w.indexes if
+                                     index.field_name == type_field_map.get(100, "")]
+        float_vector_index_types = [index.params["index_type"] for index in collection_w.indexes if
+                                    index.field_name == type_field_map.get(101, "")]
+        index_field_map = dict([(index.field_name, index.index_name) for index in collection_w.indexes])
+        index_names = [index.index_name for index in collection_w.indexes]  # used to drop index
+        vector_index_types = binary_vector_index_types + float_vector_index_types
+        if len(vector_index_types) > 0:
+            vector_index_type = vector_index_types[0]
+        try:
+            t0 = time.time()
+            self.utility_wrap.wait_for_loading_complete(name)
+            log.info(f"wait for {name} loading complete cost {time.time() - t0}")
+        except Exception as e:
+            log.error(e)
+        # get replicas loaded
+        try:
+            replicas = collection_w.get_replicas(enable_traceback=False)
+            replicas_loaded = len(replicas.groups)
+        except Exception as e:
+            log.error(e)
+            replicas_loaded = 0
+
+        log.info(f"collection {name} has {replicas_loaded} replicas")
+        actual_replicas = re.search(r'replica_number_(.*?)_', name).group(1)
+        assert replicas_loaded == int(actual_replicas)
+        # params for search and query
+        if is_binary:
+            _, vectors_to_search = cf.gen_binary_vectors(
+                default_nb, default_dim)
+            default_search_field = ct.default_binary_vec_field_name
+        else:
+            vectors_to_search = cf.gen_vectors(default_nb, default_dim)
+            default_search_field = ct.default_float_vec_field_name
+        search_params = gen_search_param(vector_index_type)[0]
+
+        # load if not loaded
+        if replicas_loaded == 0:
+            # create index for vector if not exist before load
+            is_vector_indexed = False
+            index_infos = [index.to_dict() for index in collection_w.indexes]
+            for index_info in index_infos:
+                if "metric_type" in index_info.keys() or "metric_type" in index_info["index_param"]:
+                    is_vector_indexed = True
+                    break
+            if is_vector_indexed is False:
+                default_index_param = gen_index_param(vector_index_type)
+                self.create_index(collection_w, default_index_field, default_index_param)
+            collection_w.load()
+
+        # search and query
+        if "empty" in name:
+            # if the collection is empty, the search result should be empty, so no need to check
+            check_task = None
+        else:
+            check_task = CheckTasks.check_search_results
+
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            output_fields=[ct.default_int64_field_name],
+                            check_task=check_task,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        if "empty" in name:
+            check_task = None
+        else:
+            check_task = CheckTasks.check_query_not_empty
+        collection_w.query(default_term_expr, output_fields=[ct.default_int64_field_name],
+                           check_task=check_task)
+
+        # flush
+        if pymilvus_version >= "2.2.0":
+            collection_w.flush()
+        else:
+            collection_w.collection.num_entities
+
+        # search and query
+        if "empty" in name:
+            check_task = None
+        else:
+            check_task = CheckTasks.check_search_results
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            output_fields=[ct.default_int64_field_name],
+                            check_task=check_task,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        if "empty" in name:
+            check_task = None
+        else:
+            check_task = CheckTasks.check_query_not_empty
+        collection_w.query(default_term_expr, output_fields=[ct.default_int64_field_name],
+                           check_task=check_task)
+
+        # insert data and flush
+        for i in range(2):
+            self.insert_data_general(insert_data=True, is_binary=is_binary, nb=data_size,
+                                    is_flush=False, is_index=True, name=name,
+                                     enable_dynamic_field=False, with_json=False)
+        if pymilvus_version >= "2.2.0":
+            collection_w.flush()
+        else:
+            collection_w.collection.num_entities
+
+        # delete data
+        delete_expr = f"{ct.default_int64_field_name} in [0,1,2,3,4,5,6,7,8,9]"
+        collection_w.delete(expr=delete_expr)
+
+        # search and query
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            output_fields=[ct.default_int64_field_name],
+                            check_task=CheckTasks.check_search_results,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        collection_w.query(default_term_expr, output_fields=[ct.default_int64_field_name],
+                           check_task=CheckTasks.check_query_not_empty)
+
+        # release and reload with changed replicas
+        collection_w.release()
+        replica_number = 1
+        if replicas_loaded in [0, 1] and len(ms.query_nodes) >= 2:
+            replica_number = 2
+        collection_w.load(replica_number=replica_number)
+
+        # search and query
+        collection_w.search(vectors_to_search[:default_nq], default_search_field,
+                            search_params, default_limit,
+                            default_search_exp,
+                            output_fields=[ct.default_int64_field_name],
+                            check_task=CheckTasks.check_search_results,
+                            check_items={"nq": default_nq,
+                                         "limit": default_limit})
+        collection_w.query(default_term_expr, output_fields=[ct.default_int64_field_name],
+                           check_task=CheckTasks.check_query_not_empty)

tests/python_client/deploy/testcases/test_get_all_collections.py

@@ -0,0 +1,27 @@
+import json
+import pytest
+
+from base.client_base import TestcaseBase
+from deploy.common import get_deploy_test_collections
+from common.common_type import CaseLabel
+from utils.util_log import test_log as log
+
+
+class TestGetCollections(TestcaseBase):
+    """ Test case of getting all collections """
+
+    @pytest.mark.tags(CaseLabel.L3)
+    def test_get_collections_by_prefix(self,):
+        self._connect()
+        all_collections = self.utility_wrap.list_collections()[0]
+        all_collections = [c_name for c_name in all_collections if "deploy_test" in c_name]
+        log.info(f"find {len(all_collections)} collections:")
+        log.info(all_collections)
+        data = {
+            "all": all_collections,
+        }
+        with open("/tmp/ci_logs/deploy_test_all_collections.json", "w") as f:
+            f.write(json.dumps(data))
+        log.info(f"write {len(all_collections)} collections to /tmp/ci_logs/deploy_test_all_collections.json")
+        collections_in_json = get_deploy_test_collections()
+        assert len(all_collections) == len(collections_in_json)