Add partition case

tests/milvus_python_test/pytest.ini

@@ -4,6 +4,6 @@ log_format = [%(asctime)s-%(levelname)s-%(name)s]: %(message)s (%(filename)s:%(l
 log_cli = true
 log_level = 20
 
-timeout = 300
+timeout = 600
 
 level = 1
\ No newline at end of file

tests/milvus_python_test/requirements.txt

@@ -22,4 +22,4 @@ wcwidth==0.1.7
 wrapt==1.11.1
 zipp==0.5.1
 scikit-learn>=0.19.1
-pymilvus-test>=0.2.0
\ No newline at end of file
+pymilvus-test>=0.2.0

tests/milvus_python_test/requirements_no_pymilvus.txt

@@ -17,7 +17,6 @@ allure-pytest==2.7.0
 pytest-print==0.1.2
 pytest-level==0.1.1
 six==1.12.0
-thrift==0.11.0
 typed-ast==1.3.5
 wcwidth==0.1.7
 wrapt==1.11.1

tests/milvus_python_test/test_add_vectors.py

@@ -15,7 +15,7 @@ table_id = "test_add"
 ADD_TIMEOUT = 60
 nprobe = 1
 epsilon = 0.0001
-
+tag = "1970-01-01"
 
 class TestAddBase:
     """
@@ -186,6 +186,7 @@ class TestAddBase:
         expected: status ok
         '''
         index_param = get_simple_index_params
+        logging.getLogger().info(index_param)
         vector = gen_single_vector(dim)
         status, ids = connect.add_vectors(table, vector)
         status = connect.create_index(table, index_param)
@@ -439,6 +440,80 @@ class TestAddBase:
         assert status.OK()
         assert len(ids) == nq
 
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_tag(self, connect, table):
+        '''
+        target: test add vectors in table created before
+        method: create table and add vectors in it, with the partition_tag param
+        expected: the table row count equals to nq
+        '''
+        nq = 5
+        partition_name = gen_unique_str()
+        vectors = gen_vectors(nq, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        status, ids = connect.add_vectors(table, vectors, partition_tag=tag)
+        assert status.OK()
+        assert len(ids) == nq
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_tag_A(self, connect, table):
+        '''
+        target: test add vectors in table created before
+        method: create partition and add vectors in it
+        expected: the table row count equals to nq
+        '''
+        nq = 5
+        partition_name = gen_unique_str()
+        vectors = gen_vectors(nq, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        status, ids = connect.add_vectors(partition_name, vectors)
+        assert status.OK()
+        assert len(ids) == nq
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_tag_not_existed(self, connect, table):
+        '''
+        target: test add vectors in table created before
+        method: create table and add vectors in it, with the not existed partition_tag param
+        expected: status not ok
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        status, ids = connect.add_vectors(table, vectors, partition_tag=tag)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_tag_not_existed_A(self, connect, table):
+        '''
+        target: test add vectors in table created before
+        method: create partition, add vectors with the not existed partition_tag param
+        expected: status not ok
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        new_tag = "new_tag"
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status, ids = connect.add_vectors(table, vectors, partition_tag=new_tag)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_tag_existed(self, connect, table):
+        '''
+        target: test add vectors in table created before
+        method: create table and add vectors in it repeatly, with the partition_tag param
+        expected: the table row count equals to nq
+        '''
+        nq = 5
+        partition_name = gen_unique_str()
+        vectors = gen_vectors(nq, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        status, ids = connect.add_vectors(table, vectors, partition_tag=tag)
+        for i in range(5):
+            status, ids = connect.add_vectors(table, vectors, partition_tag=tag)
+            assert status.OK()
+            assert len(ids) == nq
+
     @pytest.mark.level(2)
     def test_add_vectors_without_connect(self, dis_connect, table):
         '''
@@ -1198,7 +1273,8 @@ class TestAddAdvance:
         assert len(ids) == nb
         assert status.OK()
 
-class TestAddTableNameInvalid(object):
+
+class TestNameInvalid(object):
     """
     Test adding vectors with invalid table names
     """
@@ -1209,13 +1285,27 @@ class TestAddTableNameInvalid(object):
     def get_table_name(self, request):
         yield request.param
 
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_tag_name(self, request):
+        yield request.param
+
     @pytest.mark.level(2)
-    def test_add_vectors_with_invalid_tablename(self, connect, get_table_name):
+    def test_add_vectors_with_invalid_table_name(self, connect, get_table_name):
         table_name = get_table_name
         vectors = gen_vectors(1, dim)
         status, result = connect.add_vectors(table_name, vectors)
         assert not status.OK()
 
+    @pytest.mark.level(2)
+    def test_add_vectors_with_invalid_tag_name(self, connect, get_tag_name):
+        tag_name = get_tag_name
+        vectors = gen_vectors(1, dim)
+        status, result = connect.add_vectors(table_name, vectors, partition_tag=tag_name)
+        assert not status.OK()
+
 
 class TestAddTableVectorsInvalid(object):
     single_vector = gen_single_vector(dim)

tests/milvus_python_test/test_connect.py

@@ -149,15 +149,14 @@ class TestConnect:
             milvus.connect(uri=uri_value, timeout=1)
         assert not milvus.connected()
 
-    # TODO: enable
-    def _test_connect_with_multiprocess(self, args):
+    def test_connect_with_multiprocess(self, args):
         '''
         target: test uri connect with multiprocess
         method: set correct uri, test with multiprocessing connecting
         expected: all connection is connected        
         '''
         uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
-        process_num = 4
+        process_num = 10
         processes = []
 
         def connect(milvus):
@@ -248,7 +247,7 @@ class TestConnect:
         expected: connect raise an exception and connected is false
         '''
         milvus = Milvus()
-        uri_value = "tcp://%s:19540" % args["ip"]
+        uri_value = "tcp://%s:39540" % args["ip"]
         with pytest.raises(Exception) as e:
             milvus.connect(host=args["ip"], port="", uri=uri_value)
 
@@ -264,6 +263,7 @@ class TestConnect:
             milvus.connect(host="", port=args["port"], uri=uri_value, timeout=1)
         assert not milvus.connected()
 
+    # Disable, (issue: https://github.com/milvus-io/milvus/issues/288)
     def test_connect_param_priority_both_hostip_uri(self, args):
         '''
         target: both host_ip_port / uri are both given, and not null, use the uri params
@@ -273,8 +273,9 @@ class TestConnect:
         milvus = Milvus()
         uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
         with pytest.raises(Exception) as e:
-            milvus.connect(host=args["ip"], port=19540, uri=uri_value, timeout=1)
-        assert not milvus.connected()
+            res = milvus.connect(host=args["ip"], port=39540, uri=uri_value, timeout=1)
+            logging.getLogger().info(res)
+        # assert not milvus.connected()
 
     def _test_add_vector_and_disconnect_concurrently(self):
         '''

tests/milvus_python_test/test_index.py

@@ -20,6 +20,7 @@ vectors = sklearn.preprocessing.normalize(vectors, axis=1, norm='l2')
 vectors = vectors.tolist()
 BUILD_TIMEOUT = 60
 nprobe = 1
+tag = "1970-01-01"
 
 
 class TestIndexBase:
@@ -62,6 +63,21 @@ class TestIndexBase:
         status = connect.create_index(table, index_params)
         assert status.OK()
 
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index_partition(self, connect, table, get_index_params):
+        '''
+        target: test create index interface
+        method: create table, create partition, and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status = connect.create_partition(table, partition_name, tag)
+        status, ids = connect.add_vectors(table, vectors, partition_tag=tag)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+
     @pytest.mark.level(2)
     def test_create_index_without_connect(self, dis_connect, table):
         '''
@@ -555,6 +571,21 @@ class TestIndexIP:
         status = connect.create_index(ip_table, index_params)
         assert status.OK()
 
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index_partition(self, connect, ip_table, get_index_params):
+        '''
+        target: test create index interface
+        method: create table, create partition, and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status = connect.create_index(partition_name, index_params)
+        assert status.OK()
+
     @pytest.mark.level(2)
     def test_create_index_without_connect(self, dis_connect, ip_table):
         '''
@@ -583,9 +614,9 @@ class TestIndexIP:
         query_vecs = [vectors[0], vectors[1], vectors[2]]
         top_k = 5
         status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+        logging.getLogger().info(result)
         assert status.OK()
         assert len(result) == len(query_vecs)
-        # logging.getLogger().info(result)
 
     # TODO: enable
     @pytest.mark.timeout(BUILD_TIMEOUT)
@@ -743,13 +774,13 @@ class TestIndexIP:
     ******************************************************************
     """
 
-    def test_describe_index(self, connect, ip_table, get_index_params):
+    def test_describe_index(self, connect, ip_table, get_simple_index_params):
         '''
         target: test describe index interface
         method: create table and add vectors in it, create index, call describe index
         expected: return code 0, and index instructure
         '''
-        index_params = get_index_params
+        index_params = get_simple_index_params
         logging.getLogger().info(index_params)
         status, ids = connect.add_vectors(ip_table, vectors)
         status = connect.create_index(ip_table, index_params)
@@ -759,6 +790,80 @@ class TestIndexIP:
         assert result._table_name == ip_table
         assert result._index_type == index_params["index_type"]
 
+    def test_describe_index_partition(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test describe index interface
+        method: create table, create partition and add vectors in it, create index, call describe index
+        expected: return code 0, and index instructure
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status = connect.create_index(ip_table, index_params)
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == ip_table
+        assert result._index_type == index_params["index_type"]
+        status, result = connect.describe_index(partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == partition_name
+        assert result._index_type == index_params["index_type"]
+
+    def test_describe_index_partition_A(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test describe index interface
+        method: create table, create partition and add vectors in it, create index on partition, call describe index
+        expected: return code 0, and index instructure
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status = connect.create_index(partition_name, index_params)
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+        status, result = connect.describe_index(partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == partition_name
+        assert result._index_type == index_params["index_type"]
+
+    def test_describe_index_partition_B(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test describe index interface
+        method: create table, create partitions and add vectors in it, create index on partitions, call describe index
+        expected: return code 0, and index instructure
+        '''
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        new_tag = "new_tag"
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status = connect.create_partition(ip_table, new_partition_name, new_tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=new_tag)
+        status = connect.create_index(partition_name, index_params)
+        status = connect.create_index(new_partition_name, index_params)
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+        status, result = connect.describe_index(new_partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == new_partition_name
+        assert result._index_type == index_params["index_type"]
+
     def test_describe_and_drop_index_multi_tables(self, connect, get_simple_index_params):
         '''
         target: test create, describe and drop index interface with multiple tables of IP
@@ -849,6 +954,111 @@ class TestIndexIP:
         assert result._table_name == ip_table
         assert result._index_type == IndexType.FLAT
 
+    def test_drop_index_partition(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test drop index interface
+        method: create table, create partition and add vectors in it, create index on table, call drop table index
+        expected: return code 0, and default index param
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_simple_index_params
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        status = connect.drop_index(ip_table)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+
+    def test_drop_index_partition_A(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test drop index interface
+        method: create table, create partition and add vectors in it, create index on partition, call drop table index
+        expected: return code 0, and default index param
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_simple_index_params
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status = connect.create_index(partition_name, index_params)
+        assert status.OK()
+        status = connect.drop_index(ip_table)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+        status, result = connect.describe_index(partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == partition_name
+        assert result._index_type == IndexType.FLAT
+
+    def test_drop_index_partition_B(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test drop index interface
+        method: create table, create partition and add vectors in it, create index on partition, call drop partition index
+        expected: return code 0, and default index param
+        '''
+        partition_name = gen_unique_str()
+        index_params = get_simple_index_params
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status, ids = connect.add_vectors(ip_table, vectors, partition_tag=tag)
+        status = connect.create_index(partition_name, index_params)
+        assert status.OK()
+        status = connect.drop_index(partition_name)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+        status, result = connect.describe_index(partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == partition_name
+        assert result._index_type == IndexType.FLAT
+
+    def test_drop_index_partition_C(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test drop index interface
+        method: create table, create partitions and add vectors in it, create index on partitions, call drop partition index
+        expected: return code 0, and default index param
+        '''
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        new_tag = "new_tag"
+        index_params = get_simple_index_params
+        status = connect.create_partition(ip_table, partition_name, tag)
+        status = connect.create_partition(ip_table, new_partition_name, new_tag)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+        status = connect.drop_index(new_partition_name)
+        assert status.OK()
+        status, result = connect.describe_index(new_partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == new_partition_name
+        assert result._index_type == IndexType.FLAT
+        status, result = connect.describe_index(partition_name)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == partition_name
+        assert result._index_type == index_params["index_type"]
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == ip_table
+        assert result._index_type == index_params["index_type"]
+
     def test_drop_index_repeatly(self, connect, ip_table, get_simple_index_params):
         '''
         target: test drop index repeatly

tests/milvus_python_test/test_mix.py

@@ -25,9 +25,8 @@ index_params = {'index_type': IndexType.IVFLAT, 'nlist': 16384}
 
 class TestMixBase:
 
-    # TODO: enable
     def test_search_during_createIndex(self, args):
-        loops = 100000
+        loops = 10000
         table = gen_unique_str()
         query_vecs = [vectors[0], vectors[1]]
         uri = "tcp://%s:%s" % (args["ip"], args["port"])

tests/milvus_python_test/test_partition.py

+import time
+import random
+import pdb
+import threading
+import logging
+from multiprocessing import Pool, Process
+import pytest
+from milvus import Milvus, IndexType, MetricType
+from utils import *
+
+
+dim = 128
+index_file_size = 10
+table_id = "test_add"
+ADD_TIMEOUT = 60
+nprobe = 1
+epsilon = 0.0001
+tag = "1970-01-01"
+
+
+class TestCreateBase:
+
+    """
+    ******************************************************************
+      The following cases are used to test `create_partition` function 
+    ******************************************************************
+    """
+    def test_create_partition(self, connect, table):
+        '''
+        target: test create partition, check status returned
+        method: call function: create_partition
+        expected: status ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+
+    def test_create_partition_repeat(self, connect, table):
+        '''
+        target: test create partition, check status returned
+        method: call function: create_partition
+        expected: status ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(table, partition_name, tag)
+        assert not status.OK()
+
+    def test_create_partition_recursively(self, connect, table):
+        '''
+        target: test create partition, and create partition in parent partition, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        new_tag = "new_tag"
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(partition_name, new_partition_name, new_tag)
+        assert not status.OK()
+
+    def test_create_partition_table_not_existed(self, connect):
+        '''
+        target: test create partition, its owner table name not existed in db, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        table_name = gen_unique_str()
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table_name, partition_name, tag)
+        assert not status.OK()
+
+    def test_create_partition_partition_name_existed(self, connect, table):
+        '''
+        target: test create partition, and create the same partition again, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        tag_new = "tag_new"
+        status = connect.create_partition(table, partition_name, tag_new)
+        assert not status.OK()
+
+    def test_create_partition_partition_name_equals_table(self, connect, table):
+        '''
+        target: test create partition, the partition equals to table, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        status = connect.create_partition(table, table, tag)
+        assert not status.OK()
+
+    def test_create_partition_partition_name_None(self, connect, table):
+        '''
+        target: test create partition, partition name set None, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        partition_name = None
+        status = connect.create_partition(table, partition_name, tag)
+        assert not status.OK()
+
+    def test_create_partition_tag_name_None(self, connect, table):
+        '''
+        target: test create partition, tag name set None, check status returned
+        method: call function: create_partition
+        expected: status ok
+        '''
+        tag_name = None
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag_name)
+        assert not status.OK()
+
+    def test_create_different_partition_tag_name_existed(self, connect, table):
+        '''
+        target: test create partition, and create the same partition tag again, check status returned
+        method: call function: create_partition with the same tag name
+        expected: status not ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        new_partition_name = gen_unique_str()
+        status = connect.create_partition(table, new_partition_name, tag)
+        assert not status.OK()
+
+    def test_create_partition_add_vectors(self, connect, table):
+        '''
+        target: test create partition, and insert vectors, check status returned
+        method: call function: create_partition
+        expected: status ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.insert(table, vectors, ids)
+        assert status.OK()
+
+    def test_create_partition_insert_with_tag(self, connect, table):
+        '''
+        target: test create partition, and insert vectors, check status returned
+        method: call function: create_partition
+        expected: status ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.insert(table, vectors, ids, partition_tag=tag)
+        assert status.OK()
+
+    def test_create_partition_insert_with_tag_not_existed(self, connect, table):
+        '''
+        target: test create partition, and insert vectors, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        tag_new = "tag_new"
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.insert(table, vectors, ids, partition_tag=tag_new)
+        assert not status.OK()
+
+    def test_create_partition_insert_same_tags(self, connect, table):
+        '''
+        target: test create partition, and insert vectors, check status returned
+        method: call function: create_partition
+        expected: status ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.insert(table, vectors, ids, partition_tag=tag)
+        ids = [(i+100) for i in range(nq)]
+        status, ids = connect.insert(table, vectors, ids, partition_tag=tag)
+        assert status.OK()
+        time.sleep(1)
+        status, res = connect.get_table_row_count(partition_name)
+        assert res == nq * 2
+
+    def test_create_partition_insert_same_tags_two_tables(self, connect, table):
+        '''
+        target: test create two partitions, and insert vectors with the same tag to each table, check status returned
+        method: call function: create_partition
+        expected: status ok, table length is correct
+        '''
+        partition_name = gen_unique_str()
+        table_new = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        param = {'table_name': table_new,
+         'dimension': dim,
+         'index_file_size': index_file_size,
+         'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        status = connect.create_partition(table_new, new_partition_name, tag)
+        assert status.OK()
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.insert(table, vectors, ids, partition_tag=tag)
+        ids = [(i+100) for i in range(nq)]
+        status, ids = connect.insert(table_new, vectors, ids, partition_tag=tag)
+        assert status.OK()
+        time.sleep(1)
+        status, res = connect.get_table_row_count(new_partition_name)
+        assert res == nq
+
+
+class TestShowBase:
+
+    """
+    ******************************************************************
+      The following cases are used to test `show_partitions` function 
+    ******************************************************************
+    """
+    def test_show_partitions(self, connect, table):
+        '''
+        target: test show partitions, check status and partitions returned
+        method: create partition first, then call function: show_partitions
+        expected: status ok, partition correct
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status, res = connect.show_partitions(table)
+        assert status.OK()
+
+    def test_show_partitions_no_partition(self, connect, table):
+        '''
+        target: test show partitions with table name, check status and partitions returned
+        method: call function: show_partitions
+        expected: status ok, partitions correct
+        '''
+        partition_name = gen_unique_str()
+        status, res = connect.show_partitions(table)
+        assert status.OK()
+
+    def test_show_partitions_no_partition_recursive(self, connect, table):
+        '''
+        target: test show partitions with partition name, check status and partitions returned
+        method: call function: show_partitions
+        expected: status ok, no partitions
+        '''
+        partition_name = gen_unique_str()
+        status, res = connect.show_partitions(partition_name)
+        assert status.OK()
+        assert len(res) == 0
+
+    def test_show_multi_partitions(self, connect, table):
+        '''
+        target: test show partitions, check status and partitions returned
+        method: create partitions first, then call function: show_partitions
+        expected: status ok, partitions correct
+        '''
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(table, new_partition_name, tag)
+        status, res = connect.show_partitions(table)
+        assert status.OK()
+
+
+class TestDropBase:
+
+    """
+    ******************************************************************
+      The following cases are used to test `drop_partition` function 
+    ******************************************************************
+    """
+    def test_drop_partition(self, connect, table):
+        '''
+        target: test drop partition, check status and partition if existed
+        method: create partitions first, then call function: drop_partition
+        expected: status ok, no partitions in db
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.drop_partition(table, tag)
+        assert status.OK()
+        # check if the partition existed
+        status, res = connect.show_partitions(table)
+        assert partition_name not in res
+
+    def test_drop_partition_tag_not_existed(self, connect, table):
+        '''
+        target: test drop partition, but tag not existed
+        method: create partitions first, then call function: drop_partition
+        expected: status not ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        new_tag = "new_tag"
+        status = connect.drop_partition(table, new_tag)
+        assert not status.OK()
+
+    def test_drop_partition_tag_not_existed_A(self, connect, table):
+        '''
+        target: test drop partition, but table not existed
+        method: create partitions first, then call function: drop_partition
+        expected: status not ok
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        new_table = gen_unique_str()
+        status = connect.drop_partition(new_table, tag)
+        assert not status.OK()
+
+    def test_drop_partition_repeatedly(self, connect, table):
+        '''
+        target: test drop partition twice, check status and partition if existed
+        method: create partitions first, then call function: drop_partition
+        expected: status not ok, no partitions in db
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.drop_partition(table, tag)
+        status = connect.drop_partition(table, tag)
+        time.sleep(2)
+        assert not status.OK()
+        status, res = connect.show_partitions(table)
+        assert partition_name not in res
+
+    def test_drop_partition_create(self, connect, table):
+        '''
+        target: test drop partition, and create again, check status
+        method: create partitions first, then call function: drop_partition, create_partition
+        expected: status not ok, partition in db
+        '''
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.drop_partition(table, tag)
+        time.sleep(2)
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        status, res = connect.show_partitions(table)
+        assert partition_name == res[0].partition_name
+
+
+class TestNameInvalid(object):
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_partition_name(self, request):
+        yield request.param
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_tag_name(self, request):
+        yield request.param
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_table_name(self, request):
+        yield request.param
+
+    def test_create_partition_with_invalid_partition_name(self, connect, table, get_partition_name):
+        '''
+        target: test create partition, with invalid partition name, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        partition_name = get_partition_name
+        status = connect.create_partition(table, partition_name, tag)
+        assert not status.OK()
+
+    def test_create_partition_with_invalid_tag_name(self, connect, table):
+        '''
+        target: test create partition, with invalid partition name, check status returned
+        method: call function: create_partition
+        expected: status not ok
+        '''
+        tag_name = "  "
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag_name)
+        assert not status.OK()
+
+    def test_drop_partition_with_invalid_table_name(self, connect, table, get_table_name):
+        '''
+        target: test drop partition, with invalid table name, check status returned
+        method: call function: drop_partition
+        expected: status not ok
+        '''
+        table_name = get_table_name
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.drop_partition(table_name, tag)
+        assert not status.OK()
+
+    def test_drop_partition_with_invalid_tag_name(self, connect, table, get_tag_name):
+        '''
+        target: test drop partition, with invalid tag name, check status returned
+        method: call function: drop_partition
+        expected: status not ok
+        '''
+        tag_name = get_tag_name
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.drop_partition(table, tag_name)
+        assert not status.OK()
+
+    def test_show_partitions_with_invalid_table_name(self, connect, table, get_table_name):
+        '''
+        target: test show partitions, with invalid table name, check status returned
+        method: call function: show_partitions
+        expected: status not ok
+        '''
+        table_name = get_table_name
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status, res = connect.show_partitions(table_name)
+        assert not status.OK()
\ No newline at end of file

tests/milvus_python_test/test_search_vectors.py

@@ -16,8 +16,9 @@ add_interval_time = 2
 vectors = gen_vectors(100, dim)
 # vectors /= numpy.linalg.norm(vectors)
 # vectors = vectors.tolist()
-nrpobe = 1
+nprobe = 1
 epsilon = 0.001
+tag = "1970-01-01"
 
 
 class TestSearchBase:
@@ -49,6 +50,15 @@ class TestSearchBase:
                 pytest.skip("sq8h not support in open source")
         return request.param
 
+    @pytest.fixture(
+        scope="function",
+        params=gen_simple_index_params()
+    )
+    def get_simple_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
     """
     generate top-k params
     """
@@ -70,7 +80,7 @@ class TestSearchBase:
         query_vec = [vectors[0]]
         top_k = get_top_k
         nprobe = 1
-        status, result = connect.search_vectors(table, top_k, nrpobe, query_vec)
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec)
         if top_k <= 2048:
             assert status.OK()
             assert len(result[0]) == min(len(vectors), top_k)
@@ -85,7 +95,6 @@ class TestSearchBase:
         method: search with the given vectors, check the result
         expected: search status ok, and the length of the result is top_k
         '''
-        
         index_params = get_index_params
         logging.getLogger().info(index_params)
         vectors, ids = self.init_data(connect, table)
@@ -93,7 +102,7 @@ class TestSearchBase:
         query_vec = [vectors[0]]
         top_k = 10
         nprobe = 1
-        status, result = connect.search_vectors(table, top_k, nrpobe, query_vec)
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec)
         logging.getLogger().info(result)
         if top_k <= 1024:
             assert status.OK()
@@ -103,6 +112,160 @@ class TestSearchBase:
         else:
             assert not status.OK()
 
+    def test_search_l2_index_params_partition(self, connect, table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: add vectors into table, search with the given vectors, check the result
+        expected: search status ok, and the length of the result is top_k, search table with partition tag return empty
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        vectors, ids = self.init_data(connect, table)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec)
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert result[0][0].distance <= epsilon
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec, partition_tags=[tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result) == 0
+
+    def test_search_l2_index_params_partition_A(self, connect, table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search partition with the given vectors, check the result
+        expected: search status ok, and the length of the result is 0
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        vectors, ids = self.init_data(connect, table)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(partition_name, top_k, nprobe, query_vec, partition_tags=[tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result) == 0
+
+    def test_search_l2_index_params_partition_B(self, connect, table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        vectors, ids = self.init_data(connect, partition_name)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec)
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert result[0][0].distance <= epsilon
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec, partition_tags=[tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert result[0][0].distance <= epsilon
+        status, result = connect.search_vectors(partition_name, top_k, nprobe, query_vec, partition_tags=[tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result) == 0
+
+    def test_search_l2_index_params_partition_C(self, connect, table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors and tags (one of the tags not existed in table), check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        vectors, ids = self.init_data(connect, partition_name)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec, partition_tags=[tag, "new_tag"])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert result[0][0].distance <= epsilon
+
+    def test_search_l2_index_params_partition_D(self, connect, table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors and tag (tag name not existed in table), check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        vectors, ids = self.init_data(connect, partition_name)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec, partition_tags=["new_tag"])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result) == 0
+
+    def test_search_l2_index_params_partition_E(self, connect, table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search table with the given vectors and tags, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        new_tag = "new_tag"
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(table, new_partition_name, new_tag)
+        vectors, ids = self.init_data(connect, partition_name)
+        new_vectors, new_ids = self.init_data(connect, new_partition_name, nb=1000)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0], new_vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec, partition_tags=[tag, new_tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert check_result(result[1], new_ids[0])
+        assert result[0][0].distance <= epsilon
+        assert result[1][0].distance <= epsilon
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec, partition_tags=[new_tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[1], new_ids[0])
+        assert result[1][0].distance <= epsilon
+
     def test_search_ip_index_params(self, connect, ip_table, get_index_params):
         '''
         target: test basic search fuction, all the search params is corrent, test all index params, and build
@@ -117,7 +280,7 @@ class TestSearchBase:
         query_vec = [vectors[0]]
         top_k = 10
         nprobe = 1
-        status, result = connect.search_vectors(ip_table, top_k, nrpobe, query_vec)
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vec)
         logging.getLogger().info(result)
 
         if top_k <= 1024:
@@ -128,6 +291,59 @@ class TestSearchBase:
         else:
             assert not status.OK()
 
+    def test_search_ip_index_params_partition(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(ip_table, partition_name, tag)
+        vectors, ids = self.init_data(connect, ip_table)
+        status = connect.create_index(ip_table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vec)
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert abs(result[0][0].distance - numpy.inner(numpy.array(query_vec[0]), numpy.array(query_vec[0]))) <= gen_inaccuracy(result[0][0].distance)
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vec, partition_tags=[tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result) == 0
+
+    def test_search_ip_index_params_partition_A(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors and tag, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        index_params = get_simple_index_params
+        logging.getLogger().info(index_params)
+        partition_name = gen_unique_str()
+        status = connect.create_partition(ip_table, partition_name, tag)
+        vectors, ids = self.init_data(connect, partition_name)
+        status = connect.create_index(ip_table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vec, partition_tags=[tag])
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+        assert abs(result[0][0].distance - numpy.inner(numpy.array(query_vec[0]), numpy.array(query_vec[0]))) <= gen_inaccuracy(result[0][0].distance)
+        status, result = connect.search_vectors(partition_name, top_k, nprobe, query_vec)
+        logging.getLogger().info(result)
+        assert status.OK()
+        assert len(result[0]) == min(len(vectors), top_k)
+        assert check_result(result[0], ids[0])
+
     @pytest.mark.level(2)
     def test_search_vectors_without_connect(self, dis_connect, table):
         '''
@@ -518,6 +734,14 @@ class TestSearchParamsInvalid(object):
         status, result = connect.search_vectors(table_name, top_k, nprobe, query_vecs)
         assert not status.OK()
 
+    @pytest.mark.level(1)
+    def test_search_with_invalid_tag_format(self, connect, table):
+        top_k = 1
+        nprobe = 1 
+        query_vecs = gen_vectors(1, dim)
+        with pytest.raises(Exception) as e:
+            status, result = connect.search_vectors(table_name, top_k, nprobe, query_vecs, partition_tags="tag")
+
     """
     Test search table with invalid top-k
     """
@@ -574,7 +798,7 @@ class TestSearchParamsInvalid(object):
         yield request.param
 
     @pytest.mark.level(1)
-    def test_search_with_invalid_nrpobe(self, connect, table, get_nprobes):
+    def test_search_with_invalid_nprobe(self, connect, table, get_nprobes):
         '''
         target: test search fuction, with the wrong top_k
         method: search with top_k
@@ -592,7 +816,7 @@ class TestSearchParamsInvalid(object):
                 status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
 
     @pytest.mark.level(2)
-    def test_search_with_invalid_nrpobe_ip(self, connect, ip_table, get_nprobes):
+    def test_search_with_invalid_nprobe_ip(self, connect, ip_table, get_nprobes):
         '''
         target: test search fuction, with the wrong top_k
         method: search with top_k

tests/milvus_python_test/test_table.py

@@ -297,7 +297,7 @@ class TestTable:
         '''
         table_name = gen_unique_str("test_table")
         status = connect.delete_table(table_name)
-        assert not status.code==0
+        assert not status.OK()
 
     def test_delete_table_repeatedly(self, connect):
         '''

tests/milvus_python_test/test_table_count.py

@@ -13,8 +13,8 @@ from milvus import IndexType, MetricType
 
 dim = 128
 index_file_size = 10
-add_time_interval = 5
-
+add_time_interval = 3
+tag = "1970-01-01"
 
 class TestTableCount:
     """
@@ -58,6 +58,90 @@ class TestTableCount:
         status, res = connect.get_table_row_count(table)
         assert res == nb
 
+    def test_table_rows_count_partition(self, connect, table, add_vectors_nb):
+        '''
+        target: test table rows_count is correct or not
+        method: create table, create partition and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nb = add_vectors_nb
+        partition_name = gen_unique_str()
+        vectors = gen_vectors(nb, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        assert status.OK()
+        res = connect.add_vectors(table_name=table, records=vectors, partition_tag=tag)
+        time.sleep(add_time_interval)
+        status, res = connect.get_table_row_count(table)
+        assert res == nb
+
+    def test_table_rows_count_multi_partitions_A(self, connect, table, add_vectors_nb):
+        '''
+        target: test table rows_count is correct or not
+        method: create table, create partitions and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        new_tag = "new_tag"
+        nb = add_vectors_nb
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        vectors = gen_vectors(nb, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(table, new_partition_name, new_tag)
+        assert status.OK()
+        res = connect.add_vectors(table_name=table, records=vectors)
+        time.sleep(add_time_interval)
+        status, res = connect.get_table_row_count(table)
+        assert res == nb
+
+    def test_table_rows_count_multi_partitions_B(self, connect, table, add_vectors_nb):
+        '''
+        target: test table rows_count is correct or not
+        method: create table, create partitions and add vectors in one of the partitions,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        new_tag = "new_tag"
+        nb = add_vectors_nb
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        vectors = gen_vectors(nb, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(table, new_partition_name, new_tag)
+        assert status.OK()
+        res = connect.add_vectors(table_name=table, records=vectors, partition_tag=tag)
+        time.sleep(add_time_interval)
+        status, res = connect.get_table_row_count(partition_name)
+        assert res == nb
+        status, res = connect.get_table_row_count(new_partition_name)
+        assert res == 0
+
+    def test_table_rows_count_multi_partitions_C(self, connect, table, add_vectors_nb):
+        '''
+        target: test table rows_count is correct or not
+        method: create table, create partitions and add vectors in one of the partitions,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the table count is equal to the length of vectors
+        '''
+        new_tag = "new_tag"
+        nb = add_vectors_nb
+        partition_name = gen_unique_str()
+        new_partition_name = gen_unique_str()
+        vectors = gen_vectors(nb, dim)
+        status = connect.create_partition(table, partition_name, tag)
+        status = connect.create_partition(table, new_partition_name, new_tag)
+        assert status.OK()
+        res = connect.add_vectors(table_name=table, records=vectors, partition_tag=tag)
+        res = connect.add_vectors(table_name=table, records=vectors, partition_tag=new_tag)
+        time.sleep(add_time_interval)
+        status, res = connect.get_table_row_count(partition_name)
+        assert res == nb
+        status, res = connect.get_table_row_count(new_partition_name)
+        assert res == nb
+        status, res = connect.get_table_row_count(table)
+        assert res == nb * 2
+
     def test_table_rows_count_after_index_created(self, connect, table, get_simple_index_params):
         '''
         target: test get_table_row_count, after index have been created