test: refactor connection method to prioritize uri/token and add query limit

tests/python_client/base/client_base.py

@@ -65,12 +65,24 @@ def teardown_method(self, method):
         self._teardown_objects()
 
     def _teardown_objects(self):
+        # Prioritize uri and token for connection
+        if cf.param_info.param_uri:
+            uri = cf.param_info.param_uri
+        else:
+            uri = "http://" + cf.param_info.param_host + ":" + str(cf.param_info.param_port)
+
+        if cf.param_info.param_token:
+            token = cf.param_info.param_token
+        else:
+            token = f"{cf.param_info.param_user}:{cf.param_info.param_password}" if cf.param_info.param_user and cf.param_info.param_password else None
+
         try:
             """ Drop collection before disconnect """
             if not self.connection_wrap.has_connection(alias=DefaultConfig.DEFAULT_USING)[0]:
-                self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, host=cf.param_info.param_host,
-                                             port=cf.param_info.param_port, user=ct.default_user,
-                                             password=ct.default_password)
+                if token:
+                    self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, uri=uri, token=token)
+                else:
+                    self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, uri=uri)
 
             if self.collection_wrap.collection is not None:
                 if self.collection_wrap.collection.name.startswith("alias"):
@@ -106,9 +118,10 @@ def _teardown_objects(self):
         try:
             """ Drop roles before disconnect """
             if not self.connection_wrap.has_connection(alias=DefaultConfig.DEFAULT_USING)[0]:
-                self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, host=cf.param_info.param_host,
-                                             port=cf.param_info.param_port, user=ct.default_user,
-                                             password=ct.default_password)
+                if token:
+                    self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, uri=uri, token=token)
+                else:
+                    self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, uri=uri)
 
             role_list = self.utility_wrap.list_roles(False)[0]
             for role in role_list.groups:
@@ -145,30 +158,32 @@ def _connect(self, enable_milvus_client_api=False):
         if self.skip_connection:
             return None
 
+        # Prioritize uri and token for connection
+        if cf.param_info.param_uri:
+            uri = cf.param_info.param_uri
+        else:
+            uri = "http://" + cf.param_info.param_host + ":" + str(cf.param_info.param_port)
+
+        if cf.param_info.param_token:
+            token = cf.param_info.param_token
+        else:
+            token = f"{cf.param_info.param_user}:{cf.param_info.param_password}" if cf.param_info.param_user and cf.param_info.param_password else None
+
         if enable_milvus_client_api:
-            if cf.param_info.param_uri:
-                uri = cf.param_info.param_uri
-            else:
-                uri = "http://" + cf.param_info.param_host + ":" + str(cf.param_info.param_port)
-            self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING,uri=uri,token=cf.param_info.param_token)
-            res, is_succ = self.connection_wrap.MilvusClient(uri=uri,
-                                                             token=cf.param_info.param_token)
-            self.client = MilvusClient(uri=uri, token=cf.param_info.param_token)
+            self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING, uri=uri, token=token)
+            res, is_succ = self.connection_wrap.MilvusClient(uri=uri, token=token)
+            self.client = MilvusClient(uri=uri, token=token)
         else:
-            if cf.param_info.param_user and cf.param_info.param_password:
+            if token:
                 res, is_succ = self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING,
-                                                            host=cf.param_info.param_host,
-                                                            port=cf.param_info.param_port,
-                                                            user=cf.param_info.param_user,
-                                                            password=cf.param_info.param_password,
+                                                            uri=uri,
+                                                            token=token,
                                                             secure=cf.param_info.param_secure)
             else:
                 res, is_succ = self.connection_wrap.connect(alias=DefaultConfig.DEFAULT_USING,
-                                                            host=cf.param_info.param_host,
-                                                            port=cf.param_info.param_port)
+                                                            uri=uri)
 
-            uri = "http://" + cf.param_info.param_host + ":" + str(cf.param_info.param_port)
-            self.client = MilvusClient(uri=uri, token=cf.param_info.param_token)
+            self.client = MilvusClient(uri=uri, token=token)
         server_version = utility.get_server_version()
         log.info(f"server version: {server_version}")
         return res

tests/python_client/chaos/checker.py

@@ -355,7 +355,7 @@ def __init__(self, collection_name=None, partition_name=None, shards_num=2, dim=
         self.ms = MilvusSys()
         self.bucket_name = cf.param_info.param_bucket_name
 
-        # Initialize MilvusClient
+        # Initialize MilvusClient - prioritize uri and token
         if cf.param_info.param_uri:
             uri = cf.param_info.param_uri
         else:
@@ -371,10 +371,8 @@ def __init__(self, collection_name=None, partition_name=None, shards_num=2, dim=
         self.alias = cf.gen_unique_str("checker_alias_")
         connections.connect(
             alias=self.alias,
-            host=cf.param_info.param_host,
-            port=str(cf.param_info.param_port),
-            user=cf.param_info.param_user,
-            password=cf.param_info.param_password
+            uri=uri,
+            token=token
         )
         c_name = collection_name if collection_name is not None else cf.gen_unique_str(
             'Checker_')
@@ -905,7 +903,7 @@ def search(self):
                 data=self.data,
                 anns_field=self.anns_field_name,
                 search_params=self.search_param,
-                limit=1,
+                limit=5,
                 partition_names=self.p_names,
                 timeout=search_timeout
             )
@@ -963,7 +961,7 @@ def search(self):
                 data=self.data,
                 anns_field=self.anns_field_name,
                 search_params=self.search_param,
-                limit=1,
+                limit=5,
                 partition_names=self.p_names,
                 timeout=search_timeout
             )
@@ -1019,7 +1017,7 @@ def full_text_search(self):
                 data=cf.gen_vectors(5, self.dim, vector_data_type="TEXT_SPARSE_VECTOR"),
                 anns_field=bm25_anns_field,
                 search_params=constants.DEFAULT_BM25_SEARCH_PARAM,
-                limit=1,
+                limit=5,
                 partition_names=self.p_names,
                 timeout=search_timeout
             )
@@ -1863,7 +1861,7 @@ def __init__(self, collection_name=None, shards_num=2, replica_number=1, schema=
     @trace()
     def query(self):
         try:
-            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, timeout=query_timeout)
+            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, limit=5, timeout=query_timeout)
             return res, True
         except Exception as e:
             log.info(f"query error: {e}")
@@ -1898,7 +1896,7 @@ def __init__(self, collection_name=None, shards_num=2, replica_number=1, schema=
     @trace()
     def text_match(self):
         try:
-            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, timeout=query_timeout)
+            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, limit=5, timeout=query_timeout)
             return res, True
         except Exception as e:
             log.info(f"text_match error: {e}")
@@ -1938,7 +1936,7 @@ def __init__(self, collection_name=None, shards_num=2, replica_number=1, schema=
     @trace()
     def phrase_match(self):
         try:
-            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, timeout=query_timeout)
+            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, limit=5, timeout=query_timeout)
             return res, True
         except Exception as e:
             log.info(f"phrase_match error: {e}")
@@ -1991,7 +1989,7 @@ def get_term_expr(self):
     @trace()
     def json_query(self):
         try:
-            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, timeout=query_timeout)
+            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, limit=5, timeout=query_timeout)
             return res, True
         except Exception as e:
             log.info(f"json_query error: {e}")
@@ -2030,7 +2028,7 @@ def get_term_expr(self):
     @trace()
     def geo_query(self):
         try:
-            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, timeout=query_timeout)
+            res = self.milvus_client.query(collection_name=self.c_name, filter=self.term_expr, limit=5, timeout=query_timeout)
             return res, True
         except Exception as e:
             log.info(f"geo_query error: {e}")

tests/python_client/chaos/testcases/test_all_checker_operation.py

@@ -52,23 +52,36 @@ class TestBase:
 class TestOperations(TestBase):
 
     @pytest.fixture(scope="function", autouse=True)
-    def connection(self, host, port, user, password, milvus_ns, database_name):
-        if user and password:
-            # log.info(f"connect to {host}:{port} with user {user} and password {password}")
-            connections.connect('default', host=host, port=port, user=user, password=password)
+    def connection(self, host, port, user, password, uri, token, milvus_ns, database_name):
+        # Prioritize uri and token for connection
+        if uri:
+            actual_uri = uri
         else:
-            connections.connect('default', host=host, port=port)
+            actual_uri = f"http://{host}:{port}"
+
+        if token:
+            actual_token = token
+        else:
+            actual_token = f"{user}:{password}" if user and password else None
+
+        if actual_token:
+            connections.connect('default', uri=actual_uri, token=actual_token)
+        else:
+            connections.connect('default', uri=actual_uri)
+
         if connections.has_connection("default") is False:
             raise Exception("no connections")
         all_dbs = db.list_database()
         if database_name not in all_dbs:
             db.create_database(database_name)
         db.using_database(database_name)
-        log.info(f"connect to milvus {host}:{port}, db {database_name} successfully")
+        log.info(f"connect to milvus {actual_uri}, db {database_name} successfully")
         self.host = host
         self.port = port
         self.user = user
         self.password = password
+        self.uri = actual_uri
+        self.token = actual_token
         self.milvus_sys = MilvusSys(alias='default')
         self.milvus_ns = milvus_ns
         self.release_name = get_milvus_instance_name(self.milvus_ns, milvus_sys=self.milvus_sys)