admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2026-01-07 19:31:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Regress collection and insert cases (#6096)

Browse Source 
* regress collection and insert cases

Signed-off-by: ThreadDao <yufen.zong@zilliz.com>

* [skip ci] skip ci

Signed-off-by: ThreadDao <yufen.zong@zilliz.com>
This commit is contained in:
ThreadDao 2021-06-25 10:38:11 +08:00 committed by GitHub
parent 64d1fa2de2
commit fffdb34848
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 84 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests20/python_client/base/collection_wrapper.py
View File

@ -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

9
tests20/python_client/check/func_check.py
View File

@ -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")

10
tests20/python_client/common/common_func.py
View File

@ -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

125
tests20/python_client/testcases/test_collection.py
View File

@ -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])

34
tests20/python_client/testcases/test_insert.py
View File

@ -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):