Update collection case for error check (#5677)

* add schema wrapper
Signed-off-by: NThreadDao <yufen.zong@zilliz.com>

* update collection error check
Signed-off-by: NThreadDao <yufen.zong@zilliz.com>

* [skip ci] skip
Signed-off-by: NThreadDao <yufen.zong@zilliz.com>

tests20/python_client/base/client_base.py

@@ -7,6 +7,7 @@ from base.collection_wrapper import ApiCollectionWrapper
 from base.partition_wrapper import ApiPartitionWrapper
 from base.index_wrapper import ApiIndexWrapper
 from base.utility_wrapper import ApiUtilityWrapper
+from base.schema_wrapper import ApiCollectionSchemaWrapper, ApiFieldSchemaWrapper
 
 from config.test_info import test_info
 from utils.util_log import test_log as log
@@ -37,6 +38,8 @@ class Base:
     partition_wrap = None
     index_wrap = None
     utility_wrap = None
+    collection_schema_wrap = None
+    field_schema_wrap = None
 
     def setup_class(self):
         log.info("[setup_class] Start setup class...")
@@ -51,6 +54,8 @@ class Base:
         self.partition_wrap = ApiPartitionWrapper()
         self.index_wrap = ApiIndexWrapper()
         self.utility_wrap = ApiUtilityWrapper()
+        self.collection_schema_wrap = ApiCollectionSchemaWrapper()
+        self.field_schema_wrap = ApiFieldSchemaWrapper()
 
     def teardown(self):
         log.info(("*" * 35) + " teardown " + ("*" * 35))

tests20/python_client/base/schema_wrapper.py

+import sys
+
+sys.path.append("..")
+from check.func_check import ResponseChecker
+from utils.api_request import api_request
+from pymilvus_orm import CollectionSchema, FieldSchema
+
+
+class ApiCollectionSchemaWrapper:
+    collection_schema = None
+
+    def init_collection_schema(self, fields, description="", check_task=None, check_items=None, **kwargs):
+        """In order to distinguish the same name of CollectionSchema"""
+        func_name = sys._getframe().f_code.co_name
+        response, is_succ = api_request([CollectionSchema, fields, description], **kwargs)
+        self.collection_schema = response if is_succ else None
+        check_result = ResponseChecker(response, func_name, check_task, check_items, is_succ=is_succ, fields=fields,
+                                       description=description, **kwargs).run()
+        return response, check_result
+
+    @property
+    def primary_field(self):
+        return self.collection_schema.primary_field if self.collection_schema else None
+
+    @property
+    def fields(self):
+        return self.collection_schema.fields if self.collection_schema else None
+
+    @property
+    def description(self):
+        return self.collection_schema.description if self.collection_schema else None
+
+    @property
+    def auto_id(self):
+        return self.collection_schema.auto_id if self.collection_schema else None
+
+
+class ApiFieldSchemaWrapper:
+    field_schema = None
+
+    def init_field_schema(self, name, dtype, description="", check_task=None, check_items=None, **kwargs):
+        """In order to distinguish the same name of FieldSchema"""
+        func_name = sys._getframe().f_code.co_name
+        response, is_succ = api_request([FieldSchema, name, dtype, description], **kwargs)
+        self.field_schema = response if is_succ else None
+        check_result = ResponseChecker(response, func_name, check_task, check_items, is_succ, name=name, dtype=dtype,
+                                       description=description, **kwargs).run()
+        return response, check_result
+
+    @property
+    def description(self):
+        return self.field_schema.description if self.field_schema else None
+
+    @property
+    def params(self):
+        return self.field_schema.params if self.field_schema else None
+
+    @property
+    def dtype(self):
+        return self.field_schema.dtype if self.field_schema else None

tests20/python_client/check/func_check.py

 from utils.util_log import test_log as log
-from common.common_type import *
-from common.code_mapping import ErrorCode, ErrorMessage
+from common import common_type as ct
+from common.common_type import CheckTasks
+# from common.code_mapping import ErrorCode, ErrorMessage
 from pymilvus_orm import Collection, Partition
 from utils.api_request import Error
 
@@ -52,9 +53,8 @@ class ResponseChecker:
         assert actual is False
         assert len(error_dict) > 0
         if isinstance(res, Error):
-            # err_code = error_dict["err_code"]
-            # assert res.code == err_code or ErrorMessage[err_code] in res.message
-            assert res.code == error_dict["err_code"] or error_dict["err_msg"] in res.message
+            error_code = error_dict[ct.err_code]
+            assert res.code == error_code or error_dict[ct.err_msg] in res.message
         else:
             log.error("[CheckFunc] Response of API is not an error: %s" % str(res))
             assert False

tests20/python_client/common/common_func.py

@@ -6,13 +6,12 @@ import pandas as pd
 from sklearn import preprocessing
 
 from pymilvus_orm.types import DataType
-from pymilvus_orm.schema import CollectionSchema, FieldSchema
+from base.schema_wrapper import ApiCollectionSchemaWrapper, ApiFieldSchemaWrapper
 from common import common_type as ct
 from utils.util_log import test_log as log
 import threading
 import traceback
 
-
 """" Methods of processing data """
 l2 = lambda x, y: np.linalg.norm(np.array(x) - np.array(y))
 
@@ -27,43 +26,51 @@ def gen_str_by_length(length=8):
 
 
 def gen_int64_field(name=ct.default_int64_field_name, is_primary=False, description=ct.default_desc):
-    int64_field = FieldSchema(name=name, dtype=DataType.INT64, description=description, is_primary=is_primary)
+    int64_field, _ = ApiFieldSchemaWrapper().init_field_schema(name=name, dtype=DataType.INT64, description=description,
+                                                               is_primary=is_primary)
     return int64_field
 
 
 def gen_float_field(name=ct.default_float_field_name, is_primary=False, description=ct.default_desc):
-    float_field = FieldSchema(name=name, dtype=DataType.FLOAT, description=description, is_primary=is_primary)
+    float_field, _ = ApiFieldSchemaWrapper().init_field_schema(name=name, dtype=DataType.FLOAT, description=description,
+                                                               is_primary=is_primary)
     return float_field
 
 
 def gen_float_vec_field(name=ct.default_float_vec_field_name, is_primary=False, dim=ct.default_dim,
                         description=ct.default_desc):
-    float_vec_field = FieldSchema(name=name, dtype=DataType.FLOAT_VECTOR, description=description, dim=dim,
-                                  is_primary=is_primary)
+    float_vec_field, _ = ApiFieldSchemaWrapper().init_field_schema(name=name, dtype=DataType.FLOAT_VECTOR,
+                                                                   description=description, dim=dim,
+                                                                   is_primary=is_primary)
     return float_vec_field
 
 
 def gen_binary_vec_field(name=ct.default_binary_vec_field_name, is_primary=False, dim=ct.default_dim,
                          description=ct.default_desc):
-    binary_vec_field = FieldSchema(name=name, dtype=DataType.BINARY_VECTOR, description=description, dim=dim,
-                                   is_primary=is_primary)
+    binary_vec_field, _ = ApiFieldSchemaWrapper().init_field_schema(name=name, dtype=DataType.BINARY_VECTOR,
+                                                                    description=description, dim=dim,
+                                                                    is_primary=is_primary)
     return binary_vec_field
 
 
 def gen_default_collection_schema(description=ct.default_desc, primary_field=None):
     fields = [gen_int64_field(), gen_float_field(), gen_float_vec_field()]
-    schema = CollectionSchema(fields=fields, description=description, primary_field=primary_field)
+    schema, _ = ApiCollectionSchemaWrapper().init_collection_schema(fields=fields, description=description,
+                                                                    primary_field=primary_field)
+    log.error(schema)
     return schema
 
 
 def gen_collection_schema(fields, primary_field=None, description=ct.default_desc):
-    schema = CollectionSchema(fields=fields, primary_field=primary_field, description=description)
+    schema, _ = ApiCollectionSchemaWrapper().init_collection_schema(fields=fields, primary_field=primary_field,
+                                                                    description=description)
     return schema
 
 
 def gen_default_binary_collection_schema(description=ct.default_desc, primary_field=None):
     fields = [gen_int64_field(), gen_float_field(), gen_binary_vec_field()]
-    binary_schema = CollectionSchema(fields=fields, description=description, primary_field=primary_field)
+    binary_schema, _ = ApiCollectionSchemaWrapper().init_collection_schema(fields=fields, description=description,
+                                                                           primary_field=primary_field)
     return binary_schema
 
 
@@ -134,9 +141,9 @@ def gen_numpy_data(nb=ct.default_nb, dim=ct.default_dim):
 def gen_default_binary_list_data(nb=ct.default_nb, dim=ct.default_dim):
     int_values = [i for i in range(nb)]
     float_values = [np.float32(i) for i in range(nb)]
-    _, binary_vec_values = gen_binary_vectors(nb, dim)
+    binary_raw_values, binary_vec_values = gen_binary_vectors(nb, dim)
     data = [int_values, float_values, binary_vec_values]
-    return data
+    return data, binary_raw_values
 
 
 def gen_simple_index():
@@ -167,26 +174,11 @@ def gen_all_type_fields():
     fields = []
     for k, v in DataType.__members__.items():
         if v != DataType.UNKNOWN:
-            field = FieldSchema(name=k.lower(), dtype=v)
+            field, _ = ApiFieldSchemaWrapper().init_field_schema(name=k.lower(), dtype=v)
             fields.append(field)
     return fields
 
 
-def gen_invalid_dataframe():
-    vec = gen_vectors(3, 2)
-    dfs = [
-        # just columns df
-        pd.DataFrame(columns=[ct.default_int64_field_name, ct.default_float_vec_field_name]),
-        # no column just data df
-        pd.DataFrame({' ': vec}),
-        # datetime df
-        pd.DataFrame({"date": pd.date_range('20210101', periods=3)}),
-        # invalid column df
-        pd.DataFrame({'%$#': vec}),
-    ]
-    return dfs
-
-
 def jaccard(x, y):
     x = np.asarray(x, np.bool)
     y = np.asarray(y, np.bool)

tests20/python_client/common/common_type.py

@@ -34,7 +34,8 @@ float_vec_field_desc = "float vector type field"
 binary_vec_field_desc = "binary vector type field"
 
 Not_Exist = "Not_Exist"
-
+err_code = "err_code"
+err_msg = "err_msg"
 
 """" List of parameters used to pass """
 get_invalid_strs = [