diff --git a/tests20/python_client/base/collection_wrapper.py b/tests20/python_client/base/collection_wrapper.py index fe974bf971..3057746949 100644 --- a/tests20/python_client/base/collection_wrapper.py +++ b/tests20/python_client/base/collection_wrapper.py @@ -45,7 +45,7 @@ class ApiCollectionWrapper: def construct_from_dataframe(self, name, dataframe, check_task=None, check_items=None, **kwargs): func_name = sys._getframe().f_code.co_name res, is_succ = api_request([Collection.construct_from_dataframe, name, dataframe], **kwargs) - self.collection = res if is_succ else None + self.collection = res[0] if is_succ else None check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, name=name, dataframe=dataframe, **kwargs).run() return res, check_result diff --git a/tests20/python_client/check/func_check.py b/tests20/python_client/check/func_check.py index 340a0c6373..785ca65b33 100644 --- a/tests20/python_client/check/func_check.py +++ b/tests20/python_client/check/func_check.py @@ -101,12 +101,17 @@ class ResponseChecker: return True @staticmethod - def check_collection_property(collection, func_name, check_items): + def check_collection_property(res, func_name, check_items): exp_func_name = "init_collection" exp_func_name_2 = "construct_from_dataframe" if func_name != exp_func_name and func_name != exp_func_name_2: log.warning("The function name is {} rather than {}".format(func_name, exp_func_name)) - if not isinstance(collection, Collection): + if isinstance(res, Collection): + collection = res + elif isinstance(res, tuple): + collection = res[0] + log.debug(collection.schema) + else: raise Exception("The result to check isn't collection type object") if len(check_items) == 0: raise Exception("No expect values found in the check task") diff --git a/tests20/python_client/common/common_func.py b/tests20/python_client/common/common_func.py index ab1d56b335..dc1e890695 100644 --- a/tests20/python_client/common/common_func.py +++ b/tests20/python_client/common/common_func.py @@ -362,3 +362,13 @@ def insert_data(collection_w, nb=3000, is_binary=False, is_all_data_type=False): log.info("insert_data: inserted data into collection %s (num_entities: %s)" % (collection_w.name, nb)) return collection_w, vectors, binary_raw_vectors + + +def _check_primary_keys(primary_keys, nb): + if primary_keys is None: + raise Exception("The primary_keys is None") + assert len(primary_keys) == nb + for i in range(nb - 1): + if primary_keys[i] >= primary_keys[i + 1]: + return False + return True diff --git a/tests20/python_client/testcases/test_collection.py b/tests20/python_client/testcases/test_collection.py index 1c1cc1608a..9f3d805de2 100644 --- a/tests20/python_client/testcases/test_collection.py +++ b/tests20/python_client/testcases/test_collection.py @@ -100,7 +100,6 @@ class TestCollectionParams(TestcaseBase): check_items=error) @pytest.mark.tags(CaseLabel.L0) - @pytest.mark.xfail(reason="issue #5947") def test_collection_dup_name(self): """ target: test collection with dup name @@ -118,7 +117,6 @@ class TestCollectionParams(TestcaseBase): assert collection_w.name, _ in self.utility_wrap.list_collections()[0] @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="issue #5947") def test_collection_dup_name_with_desc(self): """ target: test collection with dup name @@ -218,7 +216,6 @@ class TestCollectionParams(TestcaseBase): assert collection_w.name == c_name @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5947") def test_collection_dup_name_same_schema(self): """ target: test collection with dup name and same schema @@ -360,7 +357,6 @@ class TestCollectionParams(TestcaseBase): self.collection_wrap.init_collection(c_name, schema=schema, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L0) - @pytest.mark.xfail(reason="#5918") def test_collection_empty_fields(self): """ target: test collection with empty fields @@ -368,10 +364,9 @@ class TestCollectionParams(TestcaseBase): expected: exception """ self._connect() - c_name = cf.gen_unique_str(prefix) - schema = cf.gen_collection_schema(fields=[], primary_field=ct.default_int64_field_name) - error = {ct.err_code: 0, ct.err_msg: "The field of the schema cannot be empty"} - self.collection_wrap.init_collection(c_name, schema=schema, check_task=CheckTasks.err_res, check_items=error) + error = {ct.err_code: 0, ct.err_msg: "Must be have a primary key field"} + self.collection_schema_wrap.init_collection_schema(fields=[], primary_field=ct.default_int64_field_name, + check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) def test_collection_dup_field(self): @@ -486,7 +481,6 @@ class TestCollectionParams(TestcaseBase): check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5918") @pytest.mark.parametrize("primary_field", ["12-s", "12 s", "(mn)", "中文", "%$#", "a".join("a" for i in range(256))]) def test_collection_invalid_primary_field(self, primary_field): """ @@ -496,12 +490,11 @@ class TestCollectionParams(TestcaseBase): """ self._connect() fields = [cf.gen_int64_field(), cf.gen_float_vec_field()] - error = {ct.err_code: 0, ct.err_msg: "invalid primary field"} + error = {ct.err_code: 0, ct.err_msg: "Must be have a primary key field"} self.collection_schema_wrap.init_collection_schema(fields=fields, primary_field=primary_field, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5918") @pytest.mark.parametrize("primary_field", [[], 1, [1, "2", 3], (1,), {1: 1}, None]) def test_collection_non_string_primary_field(self, primary_field): """ @@ -511,12 +504,11 @@ class TestCollectionParams(TestcaseBase): """ self._connect() fields = [cf.gen_int64_field(), cf.gen_float_vec_field()] - error = {ct.err_code: 0, ct.err_msg: "invalid primary field"} + error = {ct.err_code: 0, ct.err_msg: "Must be have a primary key field"} self.collection_schema_wrap.init_collection_schema(fields, primary_field=primary_field, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5918") def test_collection_not_existed_primary_field(self): """ target: test collection with not exist primary field @@ -526,7 +518,7 @@ class TestCollectionParams(TestcaseBase): self._connect() fake_field = cf.gen_unique_str() fields = [cf.gen_int64_field(), cf.gen_float_vec_field()] - error = {ct.err_code: 0, ct.err_msg: "not existed field"} + error = {ct.err_code: 0, ct.err_msg: "Must be have a primary key field"} self.collection_schema_wrap.init_collection_schema(fields, primary_field=fake_field, check_task=CheckTasks.err_res, check_items=error) @@ -572,6 +564,7 @@ class TestCollectionParams(TestcaseBase): check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) + @pytest.mark.xfail(reason="#6093") def test_collection_multi_primary_fields(self): """ target: test collection with multi primary @@ -581,9 +574,13 @@ class TestCollectionParams(TestcaseBase): self._connect() int_field_one = cf.gen_int64_field(is_primary=True) int_field_two = cf.gen_int64_field(name="int2", is_primary=True) - error = {ct.err_code: 0, ct.err_msg: "Primary key field can only be one"} - self.collection_schema_wrap.init_collection_schema(fields=[int_field_one, int_field_two], - check_task=CheckTasks.err_res, check_items=error) + # error = {ct.err_code: 0, ct.err_msg: "Primary key field can only be one"} + schema, _ = self.collection_schema_wrap.init_collection_schema(fields=[int_field_one, int_field_two, + cf.gen_float_vec_field()]) + # check_task=CheckTasks.err_res, check_items=error) + log.debug(schema) + collection_w, _ = self.collection_wrap.init_collection(name="c", schema=schema) + log.debug(collection_w.schema) @pytest.mark.tags(CaseLabel.L1) def test_collection_primary_inconsistent(self): @@ -616,7 +613,6 @@ class TestCollectionParams(TestcaseBase): check_items={exp_name: c_name, exp_schema: schema}) @pytest.mark.tags(CaseLabel.L0) - @pytest.mark.xfail(reason="#5918") @pytest.mark.parametrize("auto_id", [True, False]) def test_collection_auto_id_in_field_schema(self, auto_id): """ @@ -627,7 +623,6 @@ class TestCollectionParams(TestcaseBase): self._connect() c_name = cf.gen_unique_str(prefix) int_field = cf.gen_int64_field(is_primary=True, auto_id=auto_id) - log.debug(f'int_field auto_id: {int_field.auto_id}') vec_field = cf.gen_float_vec_field(name='vec') schema, _ = self.collection_schema_wrap.init_collection_schema([int_field, vec_field]) assert schema.auto_id == auto_id @@ -652,7 +647,6 @@ class TestCollectionParams(TestcaseBase): check_items={exp_name: c_name, exp_schema: schema}) @pytest.mark.tags(CaseLabel.L0) - @pytest.mark.xfail(reason="#5918") def test_collection_auto_id_non_primary_field(self): """ target: test collection set auto_id in non-primary field @@ -660,14 +654,11 @@ class TestCollectionParams(TestcaseBase): expected: raise exception """ self._connect() - int_field_one = cf.gen_int64_field(is_primary=True) - int_field_two = cf.gen_int64_field(auto_id=True) - fields = [int_field_one, int_field_two, cf.gen_float_vec_field()] error = {ct.err_code: 0, ct.err_msg: "auto_id can only be specified on the primary key field"} - self.collection_schema_wrap.init_collection_schema(fields, check_task=CheckTasks.err_res, check_items=error) + self.field_schema_wrap.init_field_schema(name=ct.default_int64_field_name, dtype=DataType.INT64, auto_id=True, + check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5918") def test_collection_auto_id_false_non_primary(self): """ target: test collection set auto_id in non-primary field @@ -682,7 +673,6 @@ class TestCollectionParams(TestcaseBase): assert not schema.auto_id @pytest.mark.tags(CaseLabel.L0) - @pytest.mark.xfail(reason="#5943") def test_collection_auto_id_inconsistent(self): """ target: test collection auto_id with both collection schema and field schema @@ -692,7 +682,8 @@ class TestCollectionParams(TestcaseBase): self._connect() int_field = cf.gen_int64_field(is_primary=True, auto_id=True) vec_field = cf.gen_float_vec_field(name='vec') - error = {ct.err_code: 0, ct.err_msg: "Primary key field can only be one"} + error = {ct.err_code: 0, ct.err_msg: "The auto_id of the collection is inconsistent with " + "the auto_id of the primary key field"} self.collection_schema_wrap.init_collection_schema([int_field, vec_field], auto_id=False, check_task=CheckTasks.err_res, check_items=error) @@ -724,7 +715,6 @@ class TestCollectionParams(TestcaseBase): auto_id=None, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5945") @pytest.mark.parametrize("auto_id", ct.get_invalid_strs) def test_collection_invalid_auto_id(self, auto_id): """ @@ -740,7 +730,6 @@ class TestCollectionParams(TestcaseBase): check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5933") def test_collection_multi_fields_auto_id(self): """ target: test collection auto_id with multi fields @@ -748,12 +737,10 @@ class TestCollectionParams(TestcaseBase): expected: todo raise exception """ self._connect() - int_field_one = cf.gen_int64_field(is_primary=True, auto_id=True) - int_field_two = cf.gen_int64_field(name="int", auto_id=True) - vec_field = cf.gen_float_vec_field(name='vec') error = {ct.err_code: 0, ct.err_msg: "auto_id can only be specified on the primary key field"} - self.collection_schema_wrap.init_collection_schema([int_field_one, int_field_two, vec_field], - check_task=CheckTasks.err_res, check_items=error) + cf.gen_int64_field(is_primary=True, auto_id=True) + self.field_schema_wrap.init_field_schema(name="int", dtype=DataType.INT64, auto_id=True, + check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L0) @pytest.mark.parametrize("dtype", [DataType.FLOAT_VECTOR, DataType.BINARY_VECTOR]) @@ -771,7 +758,7 @@ class TestCollectionParams(TestcaseBase): self.collection_wrap.init_collection(c_name, schema=schema, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail("5950") + @pytest.mark.xfail(reason="#5950") def test_collection_vector_invalid_dim(self, get_invalid_dim): """ target: test collection with invalid dimension @@ -918,7 +905,6 @@ class TestCollectionOperation(TestcaseBase): assert c_name, _ not in self.utility_wrap.list_collections() @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="issue #5947") def test_collection_dup_name_drop(self): """ target: test collection with dup name, and drop @@ -968,7 +954,6 @@ class TestCollectionDataframe(TestcaseBase): yield request.param @pytest.mark.tags(CaseLabel.L0) - @pytest.mark.xfail(reason="issue #5947") def test_construct_from_dataframe(self): """ target: test collection with dataframe data @@ -978,7 +963,7 @@ class TestCollectionDataframe(TestcaseBase): conn = self._connect() c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(ct.default_nb) - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, check_task=CheckTasks.check_collection_property, check_items={exp_name: c_name, exp_schema: default_schema}) conn.flush([c_name]) @@ -994,7 +979,7 @@ class TestCollectionDataframe(TestcaseBase): self._connect() c_name = cf.gen_unique_str(prefix) df, _ = cf.gen_default_binary_dataframe_data(nb=ct.default_nb) - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, check_task=CheckTasks.check_collection_property, check_items={exp_name: c_name, exp_schema: default_binary_schema}) assert self.collection_wrap.num_entities == ct.default_nb @@ -1022,7 +1007,7 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = pd.DataFrame(columns=[ct.default_int64_field_name, ct.default_float_vec_field_name]) error = {ct.err_code: 0, ct.err_msg: "Cannot infer schema from empty dataframe"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) @@ -1038,7 +1023,7 @@ class TestCollectionDataframe(TestcaseBase): mix_data = [(1, 2., [0.1, 0.2]), (2, 3., 4)] df = pd.DataFrame(data=mix_data, columns=list("ABC")) error = {ct.err_code: 0, ct.err_msg: "The data in the same column must be of the same type"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field='A', check_task=CheckTasks.err_res, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field='A', check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L0) @@ -1065,7 +1050,7 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = pd.DataFrame({"date": pd.date_range('20210101', periods=3), ct.default_int64_field_name: [1, 2, 3]}) error = {ct.err_code: 0, ct.err_msg: "Cannot infer schema from dataframe"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) @@ -1079,7 +1064,7 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = pd.DataFrame({'%$#': cf.gen_vectors(3, 2), ct.default_int64_field_name: [1, 2, 3]}) error = {ct.err_code: 1, ct.err_msg: "Invalid field name"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) @@ -1093,7 +1078,7 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(ct.default_nb) error = {ct.err_code: 0, ct.err_msg: "Schema must have a primary key field!"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=None, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=None, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) @@ -1107,11 +1092,11 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(ct.default_nb) error = {ct.err_code: 0, ct.err_msg: "Must be have a primary key field"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=c_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=c_name, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="issue #5945") + @pytest.mark.xfail(reason="issue #6077") def test_construct_with_none_auto_id(self): """ target: test construct with non-int64 as primary field @@ -1121,10 +1106,9 @@ class TestCollectionDataframe(TestcaseBase): self._connect() c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(ct.default_nb) - error = {ct.err_code: 0, ct.err_msg: "Must be have a primary key field"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, - auto_id=None) - log.debug(self.collection_wrap.schema) + error = {ct.err_code: 0, ct.err_msg: "Param auto_id must be bool type"} + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, + auto_id=None, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L0) def test_construct_auto_id_true_insert(self): @@ -1137,7 +1121,7 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(nb=100) error = {ct.err_code: 0, ct.err_msg: "Auto_id is True, but get the data of primary key field"} - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, auto_id=True, check_task=CheckTasks.err_res, check_items=error) @pytest.mark.tags(CaseLabel.L0) @@ -1152,11 +1136,11 @@ class TestCollectionDataframe(TestcaseBase): c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(ct.default_nb) df.drop(ct.default_int64_field_name, axis=1, inplace=True) - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + log.debug(df.head(3)) + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, auto_id=True) assert self.collection_wrap.num_entities == ct.default_nb - @pytest.mark.xfail(reason="#5970") @pytest.mark.tags(CaseLabel.L2) def test_construct_none_value_auto_id_true(self): """ @@ -1164,14 +1148,15 @@ class TestCollectionDataframe(TestcaseBase): method: df primary field with none value, auto_id=true expected: todo """ + self._connect() nb = 100 df = cf.gen_default_dataframe_data(nb) - log.debug(df.head(3)) df.iloc[:, 0] = numpy.NaN - log.debug(df.head(3)) - self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df, - priamry_field=ct.default_int64_field_name, auto_id=True) - log.debug(self.collection_wrap.num_entities) + res, _ = self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df, + primary_field=ct.default_int64_field_name, auto_id=True) + mutation_res = res[1] + assert cf._check_primary_keys(mutation_res.primary_keys, 100) + assert self.collection_wrap.num_entities == nb @pytest.mark.tags(CaseLabel.L0) def test_construct_auto_id_false(self): @@ -1183,7 +1168,7 @@ class TestCollectionDataframe(TestcaseBase): self._connect() c_name = cf.gen_unique_str(prefix) df = cf.gen_default_dataframe_data(ct.default_nb) - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, auto_id=False) assert not self.collection_wrap.schema.auto_id assert self.collection_wrap.num_entities == ct.default_nb @@ -1201,25 +1186,26 @@ class TestCollectionDataframe(TestcaseBase): df.iloc[:, 0] = numpy.NaN error = {ct.err_code: 0, ct.err_msg: "Primary key type must be DataType.INT64"} self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df, - priamry_field=ct.default_int64_field_name, auto_id=False, + primary_field=ct.default_int64_field_name, auto_id=False, check_task=CheckTasks.err_res, check_items=error) - @pytest.mark.xfail(reason="#5977") @pytest.mark.tags(CaseLabel.L1) def test_construct_auto_id_false_same_values(self): """ target: test construct with false auto_id and same value method: auto_id=False, primary field same values - expected: raise exception + expected: verify num entities """ self._connect() nb = 100 df = cf.gen_default_dataframe_data(nb) df.iloc[1:, 0] = 1 - # error = {ct.err_code: 0, ct.err_msg: "Primary key type must be DataType.INT64"} - self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df, - priamry_field=ct.default_int64_field_name, auto_id=False) - log.debug(self.collection_wrap.num_entities) + res, _ = self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df, + primary_field=ct.default_int64_field_name, auto_id=False) + collection_w = res[0] + assert collection_w.num_entities == nb + mutation_res = res[1] + assert mutation_res.primary_keys == df[ct.default_int64_field_name].values.tolist() @pytest.mark.tags(CaseLabel.L1) def test_construct_auto_id_false_negative_values(self): @@ -1234,11 +1220,10 @@ class TestCollectionDataframe(TestcaseBase): new_values = pd.Series(data=[i for i in range(0, -nb, -1)]) df[ct.default_int64_field_name] = new_values self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df, - priamry_field=ct.default_int64_field_name, auto_id=False) + primary_field=ct.default_int64_field_name, auto_id=False) assert self.collection_wrap.num_entities == nb @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5947") def test_construct_from_dataframe_dup_name(self): """ target: test collection with dup name and insert dataframe @@ -1247,11 +1232,11 @@ class TestCollectionDataframe(TestcaseBase): """ conn = self._connect() c_name = cf.gen_unique_str(prefix) - collection_w = self.init_collection_wrap(name=c_name, priamry_field=ct.default_int64_field_name, + collection_w = self.init_collection_wrap(name=c_name, primary_field=ct.default_int64_field_name, check_task=CheckTasks.check_collection_property, check_items={exp_name: c_name, exp_schema: default_schema}) df = cf.gen_default_dataframe_data(ct.default_nb) - self.collection_wrap.construct_from_dataframe(c_name, df, priamry_field=ct.default_int64_field_name, + self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name, check_task=CheckTasks.check_collection_property, check_items={exp_name: c_name, exp_schema: default_schema}) conn.flush([collection_w.name]) diff --git a/tests20/python_client/testcases/test_insert.py b/tests20/python_client/testcases/test_insert.py index ebebbb411b..74d1f2c731 100644 --- a/tests20/python_client/testcases/test_insert.py +++ b/tests20/python_client/testcases/test_insert.py @@ -3,7 +3,7 @@ import pandas as pd import pytest from base.client_base import TestcaseBase -from utils.util_log import test_log as log +# 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, CheckTasks @@ -17,16 +17,6 @@ default_schema = cf.gen_default_collection_schema() default_binary_schema = cf.gen_default_binary_collection_schema() -def _check_primary_keys(primary_keys, nb): - if primary_keys is None: - raise Exception("The primary_keys is None") - assert len(primary_keys) == nb - for i in range(nb - 1): - if primary_keys[i] >= primary_keys[i + 1]: - return False - return True - - class TestInsertParams(TestcaseBase): """ Test case of Insert interface """ @@ -148,7 +138,6 @@ class TestInsertParams(TestcaseBase): pass @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#5995") def test_insert_none(self): """ target: test insert None @@ -158,7 +147,6 @@ class TestInsertParams(TestcaseBase): c_name = cf.gen_unique_str(prefix) collection_w = self.init_collection_wrap(name=c_name) mutation_res, _ = collection_w.insert(data=None) - log.debug(f'mutation result: {mutation_res}') assert mutation_res.insert_count == 0 assert len(mutation_res.primary_keys) == 0 assert collection_w.is_empty @@ -491,11 +479,10 @@ class TestInsertOperation(TestcaseBase): df = cf.gen_default_dataframe_data(ct.default_nb) df.drop(ct.default_int64_field_name, axis=1, inplace=True) mutation_res, _ = collection_w.insert(data=df) - assert _check_primary_keys(mutation_res.primary_keys, ct.default_nb) + assert cf._check_primary_keys(mutation_res.primary_keys, ct.default_nb) assert collection_w.num_entities == ct.default_nb @pytest.mark.tags(CaseLabel.L1) - @pytest.mark.xfail(reason="#6007") def test_insert_twice_auto_id_true(self): """ target: test insert ids fields twice when auto_id=True @@ -510,10 +497,10 @@ class TestInsertOperation(TestcaseBase): df.drop(ct.default_int64_field_name, axis=1, inplace=True) mutation_res, _ = collection_w.insert(data=df) primary_keys = mutation_res.primary_keys - assert _check_primary_keys(primary_keys, nb) + assert cf._check_primary_keys(primary_keys, nb) mutation_res_1, _ = collection_w.insert(data=df) primary_keys.extend(mutation_res_1.primary_keys) - assert _check_primary_keys(primary_keys, nb*2) + assert cf._check_primary_keys(primary_keys, nb*2) assert collection_w.num_entities == nb*2 @pytest.mark.tags(CaseLabel.L0) @@ -529,7 +516,7 @@ class TestInsertOperation(TestcaseBase): data = cf.gen_default_list_data(nb=ct.default_nb) mutation_res, _ = collection_w.insert(data=data[1:]) # assert mutation_res.insert_count == ct.default_nb - assert _check_primary_keys(mutation_res.primary_keys, ct.default_nb) + assert cf._check_primary_keys(mutation_res.primary_keys, ct.default_nb) assert collection_w.num_entities == ct.default_nb @pytest.mark.tags(CaseLabel.L1) @@ -562,7 +549,6 @@ class TestInsertOperation(TestcaseBase): collection_w.insert(data=data, check_task=CheckTasks.err_res, check_items=error) assert collection_w.is_empty - @pytest.mark.xfail(reason="#5977") @pytest.mark.tags(CaseLabel.L1) def test_insert_auto_id_false_same_values(self): """ @@ -572,10 +558,12 @@ class TestInsertOperation(TestcaseBase): """ c_name = cf.gen_unique_str(prefix) collection_w = self.init_collection_wrap(name=c_name) - data = cf.gen_default_list_data(nb=100) - data[0] = [1 for i in range(100)] - # error = {ct.err_code: 0, ct.err_msg: "Primary key type must be DataType.INT64"} - collection_w.insert(data) + nb = 100 + data = cf.gen_default_list_data(nb=nb) + data[0] = [1 for i in range(nb)] + mutation_res, _ = collection_w.insert(data) + # assert mutation_res.insert_count == nb + assert mutation_res.primary_keys == data[0] @pytest.mark.tags(CaseLabel.L1) def test_insert_auto_id_false_negative_values(self):