milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[skip ci] Update case (#5661) 

* update index case

Signed-off-by: zhenwu <zhenwu@milvus.io>

* add index cases

Signed-off-by: zw <zw@milvus.io>

* update index case

Signed-off-by: zw <zw@milvus.io>

* update utility cases

Signed-off-by: zw <zw@milvus.io>

* [skip ci] update index cases

Signed-off-by: zw <zw@milvus.io>

Co-authored-by: zhenwu <zhenwu@milvus.io>
Co-authored-by: zw <zw@milvus.io>
pull/5688/head^2
del-zhenwu 2021-06-09 01:23:48 -05:00 committed by GitHub
parent 32d7b3f3e6
commit dac1925afc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 198 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
tests20/python_client/base/index_wrapper.py
View File

@ -10,41 +10,33 @@ from utils.api_request import api_request
class ApiIndexWrapper:
index = None
def index_init(self, collection, field_name, index_params, name="", check_res=None, check_params=None, **kwargs):
def init_index(self, collection, field_name, index_params, name="",check_task=None, check_items=None, **kwargs):
""" In order to distinguish the same name of index """
func_name = sys._getframe().f_code.co_name
res, check = api_request([Index, collection, field_name, index_params, name], **kwargs)
self.index = res if check is True else None
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection=collection, field_name=field_name,
res, is_succ = api_request([Index, collection, field_name, index_params, name], **kwargs)
self.index = res if is_succ is True else None
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection=collection, field_name=field_name,
index_params=index_params, name=name, **kwargs).run()
return res, check_result
def name(self, check_res=None, check_params=None):
def drop(self, check_task=None, check_items=None, **kwargs):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.index.name])
check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
res, is_succ = api_request([self.index.drop], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, **kwargs).run()
return res, check_result
def params(self, check_res=None, check_params=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.index.params])
check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
return res, check_result
@property
def name(self):
return self.index.name
def collection_name(self, check_res=None, check_params=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.index.collection_name])
check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
return res, check_result
@property
def params(self):
return self.index.params
def field_name(self, check_res=None, check_params=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.index.field_name])
check_result = ResponseChecker(res, func_name, check_res, check_params, check).run()
return res, check_result
@property
def collection_name(self):
return self.index.collection_name
def drop(self, check_res=None, check_params=None, **kwargs):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.index.drop], **kwargs)
check_result = ResponseChecker(res, func_name, check_res, check_params, check, **kwargs).run()
return res, check_result
@property
def field_name(self):
return self.index.field_name

42
tests20/python_client/base/utility_wrapper.py
View File

@ -12,49 +12,49 @@ class ApiUtilityWrapper:
ut = utility
def loading_progress(self, collection_name, partition_names=[], using="default", check_res=None, check_params=None):
def loading_progress(self, collection_name, partition_names=[], using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.loading_progress, collection_name, partition_names, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name,
res, is_succ = api_request([self.ut.loading_progress, collection_name, partition_names, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name,
partition_names=partition_names, using=using).run()
return res, check_result
def wait_for_loading_complete(self, collection_name, partition_names=[], timeout=None, using="default", check_res=None, check_params=None):
def wait_for_loading_complete(self, collection_name, partition_names=[], timeout=None, using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.wait_for_loading_complete, collection_name, partition_names, timeout, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name,
res, is_succ = api_request([self.ut.wait_for_loading_complete, collection_name, partition_names, timeout, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name,
partition_names=partition_names, timeout=timeout, using=using).run()
return res, check_result
def index_building_progress(self, collection_name, index_name="", using="default", check_res=None, check_params=None):
def index_building_progress(self, collection_name, index_name="", using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.index_building_progress, collection_name, index_name, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name, index_name=index_name,
res, is_succ = api_request([self.ut.index_building_progress, collection_name, index_name, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name, index_name=index_name,
using=using).run()
return res, check_result
def wait_for_index_building_complete(self, collection_name, index_name="", timeout=None, using="default", check_res=None, check_params=None):
def wait_for_index_building_complete(self, collection_name, index_name="", timeout=None, using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.wait_for_loading_complete, collection_name, index_name, timeout, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name, index_name=index_name,
res, is_succ = api_request([self.ut.wait_for_loading_complete, collection_name, index_name, timeout, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name, index_name=index_name,
timeout=timeout, using=using).run()
return res, check_result
def has_collection(self, collection_name, using="default", check_res=None, check_params=None):
def has_collection(self, collection_name, using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.has_collection, collection_name, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name, using=using).run()
res, is_succ = api_request([self.ut.has_collection, collection_name, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name, using=using).run()
return res, check_result
def has_partition(self, collection_name, partition_name, using="default", check_res=None, check_params=None):
def has_partition(self, collection_name, partition_name, using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.has_partition, collection_name, partition_name, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, collection_name=collection_name,
res, is_succ = api_request([self.ut.has_partition, collection_name, partition_name, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, collection_name=collection_name,
partition_name=partition_name, using=using).run()
return res, check_result
def list_collections(self, timeout=None, using="default", check_res=None, check_params=None):
def list_collections(self, timeout=None, using="default", check_task=None, check_items=None):
func_name = sys._getframe().f_code.co_name
res, check = api_request([self.ut.list_collections, timeout, using])
check_result = ResponseChecker(res, func_name, check_res, check_params, check, timeout=timeout, using=using).run()
res, is_succ = api_request([self.ut.list_collections, timeout, using])
check_result = ResponseChecker(res, func_name, check_task, check_items, is_succ, timeout=timeout, using=using).run()
return res, check_result

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

@ -235,3 +235,16 @@ def modify_file(file_path_list, is_modify=False, input_content=""):
f.write(input_content)
f.close()
log.info("[modify_file] file(%s) modification is complete." % file_path_list)
def index_to_dict(index):
return {
"collection_name": index.collection_name,
"field_name": index.field_name,
# "name": index.name,
"params": index.params
}
def assert_equal_index(index_1, index_2):
return index_to_dict(index_1) == index_to_dict(index_2)

1
tests20/python_client/common/common_type.py
View File

@ -26,6 +26,7 @@ default_tag = "1970_01_01"
row_count = "row_count"
default_desc = ""
default_collection_desc = "default collection"
default_index_name = "default_index_name"
default_binary_desc = "default binary collection"
collection_desc = "collection"
int_field_desc = "int64 type field"

140
tests20/python_client/testcases/test_index.py
View File

@ -1,4 +1,5 @@
import copy
import pdb
import pytest
from pymilvus_orm import FieldSchema
@ -8,7 +9,7 @@ from base.collection_wrapper import ApiCollectionWrapper
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
from common.common_type import CaseLabel, CheckTasks
prefix = "index"
default_schema = cf.gen_default_collection_schema()
@ -50,7 +51,11 @@ class TestIndexParams(TestcaseBase):
# TODO: construct invalid index params for all index types
@pytest.fixture(
scope="function",
params=ct.get_invalid_strs
params=[
{"metric_type": "L3", "index_type": "IVF_FLAT"},
{"metric_type": "L2", "index_type": "IVF_FLAT", "err_params": {"nlist": 10}},
{"metric_type": "L2", "index_type": "IVF_FLAT", "params": {"nlist": -1}},
]
)
def get_invalid_index_params(self, request):
yield request.param
@ -58,11 +63,14 @@ class TestIndexParams(TestcaseBase):
# TODO: construct valid index params for all index types
@pytest.fixture(
scope="function",
params=ct.get_invalid_strs
params=[
default_index_params,
]
)
def get_valid_index_params(self, request):
yield request.param
@pytest.mark.xfail(reason="issue #5646")
@pytest.mark.tags(CaseLabel.L1)
def test_index_collection_None(self):
"""
@ -72,9 +80,8 @@ class TestIndexParams(TestcaseBase):
"""
self._connect()
index_name = cf.gen_unique_str(prefix)
ex, _ = self.index_wrap.index_init(None, default_field_name, default_index_params, name=index_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
self.index_wrap.init_index(None, default_field_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
err_code=1, err_msg="Collection")
@pytest.mark.tags(CaseLabel.L1)
def test_index_field_name_invalid(self, get_invalid_field_name):
@ -83,14 +90,12 @@ class TestIndexParams(TestcaseBase):
method: input field name
expected: raise exception
"""
self._connect()
f_name = get_invalid_field_name
index_name = cf.gen_unique_str(prefix)
c_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
ex, _ = self.index_wrap.index_init(collection, f_name, default_index_params, name=index_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
collection_w = self.init_collection_wrap(name=c_name)
self.index_wrap.init_index(collection_w.collection, f_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": "must be str"})
@pytest.mark.tags(CaseLabel.L1)
def test_index_field_name_not_existed(self):
@ -99,14 +104,12 @@ class TestIndexParams(TestcaseBase):
method: input field name not created
expected: raise exception
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
f_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
ex, _ = self.index_wrap.index_init(collection, f_name, default_index_params, name=index_name)
log.error(str(ex))
assert "exist" in str(ex)
collection_w = self.init_collection_wrap(name=c_name)
self.index_wrap.init_index(collection_w.collection, f_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": "CreateIndex failed"})
@pytest.mark.tags(CaseLabel.L1)
def test_index_type_invalid(self, get_invalid_index_type):
@ -115,15 +118,13 @@ class TestIndexParams(TestcaseBase):
method: input invalid index type
expected: raise exception
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
collection_w = self.init_collection_wrap(name=c_name)
index_params = copy.deepcopy(default_index_params)
index_params["index_type"] = get_invalid_index_type
ex, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": "must be str"})
@pytest.mark.tags(CaseLabel.L1)
def test_index_type_not_supported(self):
@ -132,16 +133,15 @@ class TestIndexParams(TestcaseBase):
method: input unsupported index type
expected: raise exception
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
collection_w = self.init_collection_wrap(name=c_name)
index_params = copy.deepcopy(default_index_params)
index_params["index_type"] = "IVFFFFFFF"
ex, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": ""})
@pytest.mark.xfail(reason="issue #5653")
@pytest.mark.tags(CaseLabel.L1)
def test_index_params_invalid(self, get_invalid_index_params):
"""
@ -149,29 +149,26 @@ class TestIndexParams(TestcaseBase):
method: input invalid index params
expected: raise exception
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
collection_w = self.init_collection_wrap(name=c_name)
index_params = get_invalid_index_params
ex, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": ""})
# TODO: not supported
@pytest.mark.tags(CaseLabel.L1)
def test_index_name_invalid(self, get_invalid_index_name):
def _test_index_name_invalid(self, get_invalid_index_name):
"""
target: test index with error index name
method: input invalid index name
expected: raise exception
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = get_invalid_index_name
collection = self._collection(c_name)
ex, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
collection_w = self.init_collection_wrap(name=c_name)
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": ""})
class TestIndexBase(TestcaseBase):
@ -184,13 +181,12 @@ class TestIndexBase(TestcaseBase):
method: Index on empty collection
expected: no exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
index, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
collection_w = self.init_collection_wrap(name=c_name)
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
# TODO: assert index
assert index == collection.indexes[0]
cf.assert_equal_index(index, collection_w.collection.indexes[0])
@pytest.mark.tags(CaseLabel.L1)
def test_index_params(self, get_valid_index_params):
@ -199,28 +195,28 @@ class TestIndexBase(TestcaseBase):
method: input valid params
expected: no exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
collection_w = self.init_collection_wrap(name=c_name)
index_params = get_valid_index_params
index, _ = self.index_wrap.index_init(collection, default_field_name, index_params, name=index_name)
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, index_params, name=index_name)
# TODO: assert index
assert index == collection.indexes[0]
cf.assert_equal_index(index, collection_w.collection.indexes[0])
# TODO: not support
@pytest.mark.tags(CaseLabel.L1)
def test_index_name_dup(self):
def _test_index_name_dup(self):
"""
target: test index with duplicate index name
method: create index with existed index name create by `collection.create_index`
expected: no exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = ct.default_index_name
collection = self._collection()
self.collection_wrap.create_index(default_field_name, default_index_params, index_name=index_name)
ex, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
assert "dup" in str(ex)
collection_w = self.init_collection_wrap(name=c_name)
collection_w.collection.create_index(default_field_name, default_index_params, index_name=index_name)
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name, check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": ""})
# TODO: server not supported
@pytest.mark.tags(CaseLabel.L1)
@ -280,11 +276,10 @@ class TestIndexBase(TestcaseBase):
method: create index with different indexes with multi threads
expected: no exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = cf.gen_unique_str(prefix)
collection = self._collection(c_name)
ex, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
collection_w = self.init_collection_wrap(name=c_name)
ex, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
assert "dup" in str(ex)
@pytest.mark.tags(CaseLabel.L1)
@ -294,13 +289,13 @@ class TestIndexBase(TestcaseBase):
method: create index by `index`, and then drop it
expected: no exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
index_name = ct.default_index_name
collection = self._collection(c_name)
index, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
collection_w = self.init_collection_wrap(name=c_name)
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
cf.assert_equal_index(index, collection_w.collection.indexes[0])
self.index_wrap.drop()
assert len(collection.indexes) == 0
assert len(collection_w.collection.indexes) == 0
@pytest.mark.tags(CaseLabel.L1)
def test_index_drop_repeatly(self):
@ -309,19 +304,19 @@ class TestIndexBase(TestcaseBase):
method: create index by `index`, and then drop it twice
expected: exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
c_name = cf.gen_unique_str(prefix)
index_name = ct.default_index_name
collection = self._collection(c_name)
index, _ = self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
_, _ = self.index_wrap.drop()
ex, _ = self.index_wrap.drop()
assert "error" in ex
collection_w = self.init_collection_wrap(name=c_name)
_, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params, name=index_name)
self.index_wrap.drop()
self.index_wrap.drop(check_task=CheckTasks.err_res,
check_items={"err_code": 1, "err_msg": "Index doesn't exist"})
class TestIndexAdvanced(TestcaseBase):
""" Test case of index interface """
@pytest.mark.xfail(reason="issue #5660")
@pytest.mark.tags(CaseLabel.L2)
def test_index_drop_multi_collections(self):
"""
@ -329,18 +324,17 @@ class TestIndexAdvanced(TestcaseBase):
method: create indexes by `index`, and then drop it, assert there is one index left
expected: exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
c_name_2 = cf.gen_unique_str(prefix)
index_name = ct.default_index_name
collection = self._collection(c_name)
api_collection_2 = ApiCollectionWrapper()
api_index_2 = ApiIndexWrapper()
collection_2 = api_collection_2.init_collection(c_name_2)
self.index_wrap.index_init(collection, default_field_name, default_index_params, name=index_name)
index_2, _ = api_index_2.index_init(collection_2, default_field_name, default_index_params, name=index_name)
cw = self.init_collection_wrap(name=c_name)
cw2 = self.init_collection_wrap(name=c_name_2)
iw_2 = ApiIndexWrapper()
self.index_wrap.init_index(cw.collection, default_field_name, default_index_params, name=index_name)
index_2, _ = iw_2.init_index(cw2.collection, default_field_name, default_index_params, name=index_name)
self.index_wrap.drop()
assert index_2 in collection_2.indexes
assert cf.assert_equal_index(index_2, cw2.collection.indexes[0])
assert len(cw.collection.indexes) == 0
@pytest.mark.tags(CaseLabel.L2)
def _test_index_drop_during_inserting(self):

218
tests20/python_client/testcases/test_utility.py
View File

@ -1,4 +1,5 @@
import copy
import pdb
import pytest
from pymilvus_orm import FieldSchema
from base.client_base import TestcaseBase
@ -9,7 +10,7 @@ from base.utility_wrapper import ApiUtilityWrapper
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
from common.common_type import CaseLabel, CheckTasks
prefix = "utility"
default_schema = cf.gen_default_collection_schema()
@ -41,12 +42,8 @@ class TestUtilityParams(TestcaseBase):
method: input invalid name
expected: raise exception
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = get_invalid_collection_name
ex, _ = ut.has_collection(c_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
self.utility_wrap.has_collection(c_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "NoneType"})
@pytest.mark.tags(CaseLabel.L1)
def test_has_partition_collection_name_invalid(self, get_invalid_collection_name):
@ -55,13 +52,9 @@ class TestUtilityParams(TestcaseBase):
method: input invalid name
expected: raise exception
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = get_invalid_collection_name
p_name = cf.gen_unique_str(prefix)
ex, _ = ut.has_partition(c_name, p_name)
log.error(str(ex))
assert "invalid" or "illegal" in str(ex)
self.utility_wrap.has_partition(c_name, p_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "NoneType"})
@pytest.mark.tags(CaseLabel.L1)
def test_has_partition_name_invalid(self, get_invalid_partition_name):
@ -162,11 +155,8 @@ class TestUtilityBase(TestcaseBase):
method: input collection name created before
expected: True
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
res, _ = ut.has_collection(c_name)
cw = self.init_collection_wrap()
res, _ = self.utility_wrap.has_collection(cw.name)
assert res is True
@pytest.mark.tags(CaseLabel.L1)
@ -176,11 +166,9 @@ class TestUtilityBase(TestcaseBase):
method: input random collection name
expected: False
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
self._collection()
res, _ = ut.has_collection(c_name)
_ = self.init_collection_wrap()
res, _ = self.utility_wrap.has_collection(c_name)
assert res is False
@pytest.mark.tags(CaseLabel.L1)
@ -190,14 +178,12 @@ class TestUtilityBase(TestcaseBase):
method: input random collection name
expected: False
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
res, _ = ut.has_collection(c_name)
cw = self.init_collection_wrap(name=c_name)
res, _ = self.utility_wrap.has_collection(c_name)
assert res is True
self.collection_wrap.drop()
res, _ = ut.has_collection(c_name)
cw.drop()
res, _ = self.utility_wrap.has_collection(c_name)
assert res is False
@pytest.mark.tags(CaseLabel.L1)
@ -207,14 +193,11 @@ class TestUtilityBase(TestcaseBase):
method: input collection name and partition name created before
expected: True
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
p_name = cf.gen_unique_str()
collection = self._collection(c_name)
api_p = ApiPartitionWrapper()
api_p.init_partition(collection, p_name)
res, _ = ut.has_partition(c_name, p_name)
p_name = cf.gen_unique_str(prefix)
cw = self.init_collection_wrap(name=c_name)
self.init_partition_wrap(cw, p_name)
res, _ = self.utility_wrap.has_partition(c_name, p_name)
assert res is True
@pytest.mark.tags(CaseLabel.L1)
@ -224,12 +207,10 @@ class TestUtilityBase(TestcaseBase):
method: input collection name, and partition name not created before
expected: True
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
p_name = cf.gen_unique_str()
self._collection(c_name)
res, _ = ut.has_partition(c_name, p_name)
self.init_collection_wrap(name=c_name)
res, _ = self.utility_wrap.has_partition(c_name, p_name)
assert res is False
@pytest.mark.tags(CaseLabel.L1)
@ -239,19 +220,17 @@ class TestUtilityBase(TestcaseBase):
method: input collection name, and partition name dropped
expected: True
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
p_name = cf.gen_unique_str()
collection = self._collection(c_name)
api_p = ApiPartitionWrapper()
api_p.init_partition(collection, p_name)
res, _ = ut.has_partition(c_name, p_name)
cw = self.init_collection_wrap(name=c_name)
pw = self.init_partition_wrap(cw, p_name)
res, _ = self.utility_wrap.has_partition(c_name, p_name)
assert res is True
api_p.drop()
res, _ = ut.has_partition(c_name, p_name)
pw.drop()
res, _ = self.utility_wrap.has_partition(c_name, p_name)
assert res is False
@pytest.mark.xfail(reason="issue #5667")
@pytest.mark.tags(CaseLabel.L1)
def test_list_collections(self):
"""
@ -259,11 +238,9 @@ class TestUtilityBase(TestcaseBase):
method: create collection, list_collections
expected: in the result
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
res, _ = ut.list_collections()
self.init_collection_wrap(name=c_name)
res, _ = self.utility_wrap.list_collections()
assert c_name in res
# TODO: make sure all collections deleted
@ -275,8 +252,7 @@ class TestUtilityBase(TestcaseBase):
expected: length of the result equals to 0
"""
self._connect()
ut = ApiUtilityWrapper()
res, _ = ut.list_collections()
res, _ = self.utility_wrap.list_collections()
assert len(res) == 0
@pytest.mark.tags(CaseLabel.L1)
@ -288,11 +264,9 @@ class TestUtilityBase(TestcaseBase):
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
ut = ApiUtilityWrapper()
ex, _ = ut.index_building_progress(c_name)
log.error(str(ex))
assert "exist" in str(ex)
self.utility_wrap.index_building_progress(c_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "can't find collection"})
@pytest.mark.xfail(reason="issue #5673")
@pytest.mark.tags(CaseLabel.L1)
def test_index_process_collection_empty(self):
"""
@ -300,16 +274,15 @@ class TestUtilityBase(TestcaseBase):
method: input empty collection
expected: no exception raised
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
ut = ApiUtilityWrapper()
res, _ = ut.index_building_progress(c_name)
assert "num_indexed_entities" in res
assert res["num_indexed_entities"] == 0
assert "num_total_entities" in res
assert res["num_total_entities"] == 0
self.init_collection_wrap(name=c_name)
res, _ = self.utility_wrap.index_building_progress(c_name)
assert "indexed_rows" in res
assert res["indexed_rows"] == 0
assert "total_rows" in res
assert res["total_rows"] == 0
@pytest.mark.xfail(reason="issue #5674")
@pytest.mark.tags(CaseLabel.L1)
def test_index_process_collection_insert_no_index(self):
"""
@ -318,40 +291,17 @@ class TestUtilityBase(TestcaseBase):
expected: no exception raised
"""
nb = 1
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
cw = self.init_collection_wrap(name=c_name)
data = cf.gen_default_list_data(nb)
self.collection_wrap.insert(data=data)
ut = ApiUtilityWrapper()
res, _ = ut.index_building_progress(c_name)
assert "num_indexed_entities" in res
assert res["num_indexed_entities"] == 0
assert "num_total_entities" in res
assert res["num_total_entities"] == nb
@pytest.mark.tags(CaseLabel.L1)
def test_index_process_collection_insert_index_not_enough(self):
"""
target: test building_process
method: insert 1 entity, no index created
expected: no exception raised
"""
nb = 1
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
data = cf.gen_default_list_data(nb)
self.collection_wrap.insert(data=data)
self.collection_wrap.create_index(default_field_name, default_index_params)
ut = ApiUtilityWrapper()
ut.wait_for_index_building_complete(c_name)
res, _ = ut.index_building_progress(c_name)
assert "num_indexed_entities" in res
assert res["num_indexed_entities"] == 0
assert "num_total_entities" in res
assert res["num_total_entities"] == nb
cw.insert(data=data)
res, _ = self.utility_wrap.index_building_progress(c_name)
assert "indexed_rows" in res
assert res["indexed_rows"] == 0
assert "total_rows" in res
assert res["total_rows"] == nb
@pytest.mark.xfail(reason="issue #5674")
@pytest.mark.tags(CaseLabel.L1)
def test_index_process_collection_index(self):
"""
@ -360,19 +310,15 @@ class TestUtilityBase(TestcaseBase):
expected: 1200 entity indexed
"""
nb = 1200
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
cw = self.init_collection_wrap(name=c_name)
data = cf.gen_default_list_data(nb)
self.collection_wrap.insert(data=data)
self.collection_wrap.create_index(default_field_name, default_index_params)
ut = ApiUtilityWrapper()
ut.wait_for_index_building_complete(c_name)
res, _ = ut.index_building_progress(c_name)
assert "num_indexed_entities" in res
assert res["num_indexed_entities"] == nb
assert "num_total_entities" in res
assert res["num_total_entities"] == nb
cw.insert(data=data)
res, _ = self.utility_wrap.index_building_progress(c_name)
assert "indexed_rows" in res
assert res["indexed_rows"] == nb
assert "total_rows" in res
assert res["total_rows"] == nb
@pytest.mark.tags(CaseLabel.L1)
def test_index_process_collection_indexing(self):
@ -382,20 +328,18 @@ class TestUtilityBase(TestcaseBase):
expected: 1200 entity indexed
"""
nb = 1200
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
cw = self.init_collection_wrap(name=c_name)
data = cf.gen_default_list_data(nb)
self.collection_wrap.insert(data=data)
self.collection_wrap.create_index(default_field_name, default_index_params)
ut = ApiUtilityWrapper()
res, _ = ut.index_building_progress(c_name)
cw.insert(data=data)
cw.create_index(default_field_name, default_index_params)
res, _ = self.utility_wrap.index_building_progress(c_name)
for _ in range(2):
assert "num_indexed_entities" in res
assert res["num_indexed_entities"] <= nb
assert res["num_indexed_entities"] >= 0
assert "num_total_entities" in res
assert res["num_total_entities"] == nb
assert "indexed_rows" in res
assert res["indexed_rows"] <= nb
assert res["indexed_rows"] >= 0
assert "total_rows" in res
assert res["total_rows"] == nb
@pytest.mark.tags(CaseLabel.L1)
def test_wait_index_collection_not_existed(self):
@ -406,10 +350,7 @@ class TestUtilityBase(TestcaseBase):
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
ut = ApiUtilityWrapper()
ex, _ = ut.wait_for_index_building_complete(c_name)
log.error(str(ex))
assert "exist" in str(ex)
self.utility_wrap.wait_for_index_building_complete(c_name, check_task=CheckTasks.err_res, check_items={"err_code": 1, "err_msg": "can't find collection"})
@pytest.mark.tags(CaseLabel.L1)
def test_wait_index_collection_empty(self):
@ -420,9 +361,8 @@ class TestUtilityBase(TestcaseBase):
"""
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
ut = ApiUtilityWrapper()
res, _ = ut.wait_for_index_building_complete(c_name)
self.init_collection_wrap(name=c_name)
res, _ = self.utility_wrap.wait_for_index_building_complete(c_name)
assert res is None
@pytest.mark.tags(CaseLabel.L1)
@ -433,17 +373,15 @@ class TestUtilityBase(TestcaseBase):
expected: 1200 entity indexed
"""
nb = 1200
self._connect()
c_name = cf.gen_unique_str(prefix)
self._collection(c_name)
cw = self.init_collection_wrap(name=c_name)
data = cf.gen_default_list_data(nb)
self.collection_wrap.insert(data=data)
self.collection_wrap.create_index(default_field_name, default_index_params)
ut = ApiUtilityWrapper()
res, _ = ut.wait_for_index_building_complete(c_name)
cw.insert(data=data)
cw.create_index(default_field_name, default_index_params)
res, _ = self.utility_wrap.wait_for_index_building_complete(c_name)
assert res is None
res, _ = ut.index_building_progress(c_name)
assert res["num_indexed_entities"] == nb
res, _ = self.utility_wrap.index_building_progress(c_name)
assert res["indexed_rows"] == nb
class TestUtilityAdvanced(TestcaseBase):
@ -456,15 +394,12 @@ class TestUtilityAdvanced(TestcaseBase):
method: input collection name created before
expected: True
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
c_name_2 = cf.gen_unique_str(prefix)
self._collection(c_name)
api_c = ApiCollectionWrapper()
api_c.init_collection(c_name_2)
self.init_collection_wrap(name=c_name)
self.init_collection_wrap(name=c_name_2)
for name in [c_name, c_name_2]:
res, _ = ut.has_collection(name)
res, _ = self.utility_wrap.has_collection(name)
assert res is True
@pytest.mark.tags(CaseLabel.L2)
@ -474,13 +409,10 @@ class TestUtilityAdvanced(TestcaseBase):
method: create collection, list_collections
expected: in the result
"""
self._connect()
ut = ApiUtilityWrapper()
c_name = cf.gen_unique_str(prefix)
c_name_2 = cf.gen_unique_str(prefix)
self._collection(c_name)
api_c = ApiCollectionWrapper()
api_c.init_collection(c_name_2)
res, _ = ut.list_collections()
self.init_collection_wrap(name=c_name)
self.init_collection_wrap(name=c_name_2)
res, _ = self.utility_wrap.list_collections()
for name in [c_name, c_name_2]:
assert name in res

2
tests20/python_client/utils/api_request.py
View File

@ -1,3 +1,4 @@
import traceback
from utils.util_log import test_log as log
@ -15,6 +16,7 @@ def api_request_catch():
log.debug("(api_res) Response : %s " % str(res))
return res, True
except Exception as e:
log.error(traceback.format_exc())
log.error("[Milvus API Exception]%s: %s" % (str(func), str(e)))
return Error(e), False
return inner_wrapper