Skip to content

Commit e83de85

Browse files
matrixjimatrixji
committed
fix: fix ShowPartitions error, milvus-io#246 
1 parent 9daf8fc commit e83de85

8 files changed

+161
-189
lines changed

‎src/impl/MilvusClientImpl.cpp

+5-1
Original file line numberDiff line numberDiff line change
@@ -423,8 +423,12 @@ MilvusClientImpl::ShowPartitions(const std::string& collection_name, const std::
423423
partitions_info.reserve(count);
424424
}
425425
for (int i = 0; i < count; ++i) {
426+
auto inmemory_percentage = 0;
427+
if (response.inmemory_percentages_size() > i) {
428+
inmemory_percentage = response.inmemory_percentages(i);
429+
}
426430
partitions_info.emplace_back(response.partition_names(i), response.partitionids(i),
427-
response.created_timestamps(i), response.inmemory_percentages(i));
431+
response.created_timestamps(i), inmemory_percentage);
428432
}
429433
};
430434

‎test/st/MilvusServerTest.h

+114-31
Original file line numberDiff line numberDiff line change
@@ -29,36 +29,123 @@
2929
namespace milvus {
3030
namespace test {
3131

32-
inline void
33-
waitMilvusServerReady(const PythonMilvusServer& server) {
34-
int max_retry = 60, retry = 0;
35-
bool has;
36-
37-
auto client = milvus::MilvusClient::Create();
38-
auto param = server.TestClientParam();
39-
client->Connect(*param);
40-
auto status = client->HasCollection("no_such", has);
41-
42-
while (!status.IsOk() && retry++ < max_retry) {
43-
std::this_thread::sleep_for(std::chrono::seconds{5});
44-
client = milvus::MilvusClient::Create();
45-
client->Connect(*param);
46-
status = client->HasCollection("no_such", has);
47-
std::cout << "Wait milvus start done, try: " << retry << ", status: " << status.Message() << std::endl;
48-
}
49-
std::cout << "Wait milvus start done, status: " << status.Message() << std::endl;
50-
}
51-
52-
class MilvusServerTest : public ::testing::Test {
53-
protected:
32+
class MilvusServerClientPair {
33+
private:
5434
PythonMilvusServer server_{};
5535
std::shared_ptr<milvus::MilvusClient> client_{nullptr};
5636

37+
public:
38+
std::string collection_name{"Foo"};
39+
std::string partition_name{"Bar"};
40+
5741
void
58-
SetUp() override {
42+
startServer() {
5943
server_.Start();
6044
client_ = milvus::MilvusClient::Create();
61-
waitMilvusServerReady(server_);
45+
waitMilvusServerReady();
46+
}
47+
48+
PythonMilvusServer&
49+
server() {
50+
return server_;
51+
}
52+
53+
milvus::MilvusClient&
54+
client() {
55+
return *client_;
56+
}
57+
58+
void
59+
waitMilvusServerReady() {
60+
int max_retry = 60, retry = 0;
61+
bool has;
62+
63+
auto client = milvus::MilvusClient::Create();
64+
auto param = server_.TestClientParam();
65+
client->Connect(*param);
66+
auto status = client->HasCollection("no_such", has);
67+
68+
while (!status.IsOk() && retry++ < max_retry) {
69+
std::this_thread::sleep_for(std::chrono::seconds{5});
70+
client = milvus::MilvusClient::Create();
71+
client->Connect(*param);
72+
status = client->HasCollection("no_such", has);
73+
std::cout << "Wait milvus start done, try: " << retry << ", status: " << status.Message() << std::endl;
74+
}
75+
std::cout << "Wait milvus start done, status: " << status.Message() << std::endl;
76+
}
77+
78+
void
79+
createBinaryCollectionAndPartitions() {
80+
milvus::CollectionSchema collection_schema(collection_name);
81+
collection_schema.AddField(milvus::FieldSchema("id", milvus::DataType::INT64, "id", true, true));
82+
collection_schema.AddField(milvus::FieldSchema("age", milvus::DataType::INT16, "age"));
83+
collection_schema.AddField(
84+
milvus::FieldSchema("face", milvus::DataType::BINARY_VECTOR, "face signature").WithDimension(32));
85+
86+
auto status = client_->CreateCollection(collection_schema);
87+
EXPECT_EQ(status.Message(), "OK");
88+
EXPECT_TRUE(status.IsOk());
89+
90+
status = client_->CreatePartition(collection_name, partition_name);
91+
EXPECT_EQ(status.Message(), "OK");
92+
EXPECT_TRUE(status.IsOk());
93+
}
94+
95+
void
96+
createCollectionAndPartitions(bool create_flat_index) {
97+
milvus::CollectionSchema collection_schema(collection_name);
98+
collection_schema.AddField(milvus::FieldSchema("id", milvus::DataType::INT64, "id", true, true));
99+
collection_schema.AddField(milvus::FieldSchema("age", milvus::DataType::INT16, "age"));
100+
collection_schema.AddField(milvus::FieldSchema("name", milvus::DataType::VARCHAR, "name").WithMaxLength(64));
101+
collection_schema.AddField(
102+
milvus::FieldSchema("face", milvus::DataType::FLOAT_VECTOR, "face signature").WithDimension(4));
103+
104+
auto status = client_->CreateCollection(collection_schema);
105+
EXPECT_EQ(status.Message(), "OK");
106+
EXPECT_TRUE(status.IsOk());
107+
108+
if (create_flat_index) {
109+
milvus::IndexDesc index_desc("face", "", milvus::IndexType::FLAT, milvus::MetricType::L2, 0);
110+
status = client_->CreateIndex(collection_name, index_desc);
111+
EXPECT_EQ(status.Message(), "OK");
112+
EXPECT_TRUE(status.IsOk());
113+
}
114+
115+
status = client_->CreatePartition(collection_name, partition_name);
116+
EXPECT_EQ(status.Message(), "OK");
117+
EXPECT_TRUE(status.IsOk());
118+
}
119+
120+
milvus::DmlResults
121+
insertRecords(const std::vector<milvus::FieldDataPtr>& fields) {
122+
milvus::DmlResults dml_results;
123+
auto status = client_->Insert(collection_name, partition_name, fields, dml_results);
124+
EXPECT_EQ(status.Message(), "OK");
125+
EXPECT_TRUE(status.IsOk());
126+
EXPECT_EQ(dml_results.IdArray().IntIDArray().size(), fields.front()->Count());
127+
return dml_results;
128+
}
129+
130+
void
131+
loadCollection() {
132+
auto status = client_->LoadCollection(collection_name);
133+
EXPECT_EQ(status.Message(), "OK");
134+
EXPECT_TRUE(status.IsOk());
135+
}
136+
137+
void
138+
dropCollection() {
139+
auto status = client_->DropCollection(collection_name);
140+
EXPECT_TRUE(status.IsOk());
141+
}
142+
};
143+
144+
class MilvusServerTest : public ::testing::Test, public MilvusServerClientPair {
145+
protected:
146+
void
147+
SetUp() override {
148+
startServer();
62149
}
63150

64151
void
@@ -67,21 +154,17 @@ class MilvusServerTest : public ::testing::Test {
67154
};
68155

69156
template <typename T>
70-
class MilvusServerTestWithParam : public ::testing::TestWithParam<T> {
157+
class MilvusServerTestWithParam : public ::testing::TestWithParam<T>, public MilvusServerClientPair {
71158
protected:
72-
PythonMilvusServer server_{};
73-
std::shared_ptr<milvus::MilvusClient> client_{nullptr};
74-
75159
void
76160
SetUp() override {
77-
server_.Start();
78-
client_ = milvus::MilvusClient::Create();
79-
waitMilvusServerReady(server_);
161+
startServer();
80162
}
81163

82164
void
83165
TearDown() override {
84166
}
85167
};
168+
86169
} // namespace test
87170
} // namespace milvus

‎test/st/TestCollection.cpp

+14-9
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@ using MilvusServerTestCollection = MilvusServerTestWithParam<bool>;
2222

2323
TEST_P(MilvusServerTestCollection, CreateAndDeleteCollection) {
2424
auto using_string_primary_key = GetParam();
25-
milvus::ConnectParam connect_param{"127.0.0.1", server_.ListenPort()};
26-
client_->Connect(connect_param);
25+
milvus::ConnectParam connect_param{"127.0.0.1", server().ListenPort()};
26+
client().Connect(connect_param);
2727

2828
milvus::CollectionSchema collection_schema("Foo");
2929
if (using_string_primary_key) {
@@ -38,38 +38,43 @@ TEST_P(MilvusServerTestCollection, CreateAndDeleteCollection) {
3838
collection_schema.AddField(
3939
milvus::FieldSchema("face", milvus::DataType::FLOAT_VECTOR, "face signature").WithDimension(1024));
4040

41-
auto status = client_->CreateCollection(collection_schema);
41+
auto status = client().CreateCollection(collection_schema);
4242
EXPECT_EQ(status.Message(), "OK");
4343
EXPECT_TRUE(status.IsOk());
4444

4545
// create index needed after 2.2.0
4646
milvus::IndexDesc index_desc("face", "", milvus::IndexType::FLAT, milvus::MetricType::L2, 0);
47-
status = client_->CreateIndex("Foo", index_desc);
47+
status = client().CreateIndex("Foo", index_desc);
4848
EXPECT_TRUE(status.IsOk());
4949

5050
// test for https://github.com/milvus-io/milvus-sdk-cpp/issues/188
5151
std::vector<std::string> names;
5252
std::vector<milvus::CollectionInfo> collection_infos;
53-
status = client_->ShowCollections(names, collection_infos);
53+
status = client().ShowCollections(names, collection_infos);
5454
EXPECT_TRUE(status.IsOk());
5555
EXPECT_EQ(collection_infos.size(), 1);
5656
EXPECT_EQ(collection_infos.front().MemoryPercentage(), 0);
5757
EXPECT_EQ(collection_infos.front().Name(), "Foo");
5858

59+
// test for https://github.com/milvus-io/milvus-sdk-cpp/issues/246
60+
milvus::PartitionsInfo partitionsInfo{};
61+
status = client().ShowPartitions(collection_name, std::vector<std::string>{}, partitionsInfo);
62+
EXPECT_TRUE(status.IsOk());
63+
5964
names.emplace_back("Foo");
6065
collection_infos.clear();
61-
status = client_->LoadCollection("Foo");
66+
status = client().LoadCollection("Foo");
6267
EXPECT_TRUE(status.IsOk());
6368

64-
status = client_->ShowCollections(names, collection_infos);
69+
status = client().ShowCollections(names, collection_infos);
6570
EXPECT_TRUE(status.IsOk());
6671
EXPECT_EQ(collection_infos.size(), 1);
6772
EXPECT_EQ(collection_infos.front().MemoryPercentage(), 100);
6873

69-
status = client_->RenameCollection("Foo", "Bar");
74+
status = client().RenameCollection("Foo", "Bar");
7075
EXPECT_TRUE(status.IsOk());
7176

72-
status = client_->DropCollection("Bar");
77+
status = client().DropCollection("Bar");
7378
EXPECT_TRUE(status.IsOk());
7479
}
7580

‎test/st/TestConnectWithTls.cpp

+8-8
Original file line numberDiff line numberDiff line change
@@ -73,12 +73,12 @@ class MilvusServerTestWithTlsMode : public MilvusServerTest {
7373
std::array<char, 256> path{};
7474
getcwd(path.data(), path.size());
7575
std::string pwd = path.data();
76-
server_.SetTls(Mode, pwd + "/certs/server.crt", pwd + "/certs/server.key", pwd + "/certs/ca.crt");
76+
server().SetTls(Mode, pwd + "/certs/server.crt", pwd + "/certs/server.key", pwd + "/certs/ca.crt");
7777

7878
MilvusServerTest::SetUp();
7979

8080
ssl_client_ = milvus::MilvusClient::Create();
81-
auto param = server_.TestClientParam();
81+
auto param = server().TestClientParam();
8282
ssl_client_->Connect(*param);
8383
}
8484

@@ -95,25 +95,25 @@ class DISABLED_MilvusServerTestWithTlsMode2 : public MilvusServerTestWithTlsMode
9595

9696
TEST_F(MilvusServerTestWithTlsMode1, GenericTest) {
9797
bool has;
98-
auto status = ssl_client_->HasCollection("nosuchcollection", has);
98+
auto status = ssl_client_->HasCollection("no_such", has);
9999
EXPECT_TRUE(status.IsOk());
100-
status = client_->HasCollection("nosuchcollection", has);
100+
status = client().HasCollection("no_such", has);
101101
EXPECT_FALSE(status.IsOk());
102102
EXPECT_EQ(status.Code(), milvus::StatusCode::NOT_CONNECTED);
103103
}
104104

105105
TEST_F(DISABLED_MilvusServerTestWithTlsMode2, GenericTest) {
106106
bool has;
107-
auto status = ssl_client_->HasCollection("nosuchcollection", has);
107+
auto status = ssl_client_->HasCollection("no_such", has);
108108
EXPECT_TRUE(status.IsOk());
109-
status = client_->HasCollection("nosuchcollection", has);
109+
status = client().HasCollection("no_such", has);
110110
EXPECT_FALSE(status.IsOk());
111111
EXPECT_EQ(status.Code(), milvus::StatusCode::NOT_CONNECTED);
112112

113113
milvus::ConnectParam param{"127.0.0.1", 300};
114114
param.EnableTls();
115-
client_->Connect(param);
116-
status = client_->HasCollection("nosuchcollection", has);
115+
client().Connect(param);
116+
status = client().HasCollection("no_such", has);
117117
EXPECT_FALSE(status.IsOk());
118118
EXPECT_EQ(status.Code(), milvus::StatusCode::NOT_CONNECTED);
119119
}

‎test/st/TestConnectWithUser.cpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -30,10 +30,10 @@ class MilvusServerTestWithAuth : public MilvusServerTest {
3030

3131
void
3232
SetUp() override {
33-
server_.SetAuthorizationEnabled(true);
33+
server().SetAuthorizationEnabled(true);
3434
MilvusServerTest::SetUp();
3535
root_client_ = milvus::MilvusClient::Create();
36-
root_client_->Connect({"127.0.0.1", server_.ListenPort(), "root", "Milvus"});
36+
root_client_->Connect({"127.0.0.1", server().ListenPort(), "root", "Milvus"});
3737
}
3838

3939
void
@@ -46,8 +46,8 @@ TEST_F(MilvusServerTestWithAuth, GenericTest) {
4646
bool has;
4747
auto status = root_client_->HasCollection("nosuchcollection", has);
4848
EXPECT_TRUE(status.IsOk());
49-
// orig client with out user/pass
50-
status = client_->HasCollection("nosuchcollection", has);
49+
// orig client without user/pass
50+
status = client().HasCollection("nosuchcollection", has);
5151
EXPECT_FALSE(status.IsOk());
5252
EXPECT_EQ(status.Code(), milvus::StatusCode::NOT_CONNECTED);
5353
}

‎test/st/TestGeneric.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -24,11 +24,11 @@ using milvus::test::MilvusServerTest;
2424
class MilvusServerTestGeneric : public MilvusServerTest {};
2525

2626
TEST_F(MilvusServerTestGeneric, GetVersion) {
27-
milvus::ConnectParam connect_param{"127.0.0.1", server_.ListenPort()};
28-
client_->Connect(connect_param);
27+
milvus::ConnectParam connect_param{"127.0.0.1", server().ListenPort()};
28+
client().Connect(connect_param);
2929

3030
std::string version;
31-
auto status = client_->GetVersion(version);
31+
auto status = client().GetVersion(version);
3232
EXPECT_TRUE(status.IsOk());
3333
EXPECT_THAT(version, testing::StartsWith("v2."));
3434
}

0 commit comments

Comments
 (0)