TEST(ConsistentHashMapTest, TestGetRange) {
TestMap test_map;
typedef std::pair<string, Range<size_t>> node_range_type;
const string node1("node1");
test_map.insert(0, node1);
size_t range = numeric_limits<size_t>::max() / test_map.num_partitions();
vector<size_t> expected_parts;
for (unsigned int i = 0; i < test_map.num_partitions(); i++) {
expected_parts.push_back(range*i);
}
vector<size_t> actual_parts = test_map.get_partitions();
EXPECT_THAT(actual_parts, ContainerEq(expected_parts));
Range<size_t> range1(0, range - 1);
Range<size_t> range2(range, range*2 - 1);
Range<size_t> range3(range*2, range*3 - 1);
Range<size_t> range4(range*3, numeric_limits<size_t>::max());
node_range_type range1_node1 = std::make_pair(node1, range1);
node_range_type range2_node1 = std::make_pair(node1, range2);
node_range_type range3_node1 = std::make_pair(node1, range3);
node_range_type range4_node1 = std::make_pair(node1, range4);
node_range_type tmp;
EXPECT_TRUE(test_map.get_range(range/2, &tmp).ok());
EXPECT_EQ(range1_node1, tmp);
EXPECT_TRUE(test_map.get_range(range + range/2, &tmp).ok());
EXPECT_EQ(range2_node1, tmp);
EXPECT_TRUE(test_map.get_range(range*2 + range/2, &tmp).ok());
EXPECT_EQ(range3_node1, tmp);
EXPECT_TRUE(test_map.get_range(range*3 + range/2, &tmp).ok());
EXPECT_EQ(range4_node1, tmp);
}
TEST_F(ClientMetadataTest, TestSearchSuccess) {
start(4, 4);
create_index("/foo/bar", "dog");
create_directories("/foo/bar/zoo");
create_directories("/foo/bar/dogs");
create_directories("/foo/bar/cat");
for (int i = 0; i < 100; i++) {
ObjectId oid;
client_->create("/foo/bar/zoo/zoo" + to_string(i), 0644, 100, 100, &oid);
client_->create("/foo/bar/dogs/dog" + to_string(i), 0644, 100, 100, &oid);
client_->create("/foo/bar/cat/cat" + to_string(i), 0644, 100, 100, &oid);
}
vector<VSFSRpcClient::IndexUpdateRequest> requests;
for (int i = 0; i < 100; i++) {
requests.emplace_back(VSFSRpcClient::IndexUpdateRequest::INSERT,
"/foo/bar/dogs/dog" + to_string(i),
"dog",
to_string(i));
}
EXPECT_TRUE(client_->update(requests).ok());
vector<string> expected_files;
for (int i = 51; i < 100; i++) {
expected_files.push_back("/foo/bar/dogs/dog" + to_string(i));
}
ComplexQuery query;
query.parse("/foo?dog>50");
vector<string> actual_files;
EXPECT_TRUE(client_->search(query, &actual_files).ok());
sort(actual_files.begin(), actual_files.end());
EXPECT_THAT(actual_files, ContainerEq(expected_files));
}
TEST(ConsistentHashMapTest, TestGetValues) {
TestMap test_map;
vector<string> expected_nodes;
for (int i = 0; i < 10; ++i) {
string node_name = string("node") + to_string(i);
test_map.insert(i * 1000, node_name);
expected_nodes.push_back(node_name);
}
vector<string> actual_nodes = test_map.get_values();
EXPECT_THAT(actual_nodes, ContainerEq(expected_nodes));
}
TEST(ConsistentHashMapTest, TestGetPartitionOneNode) {
TestMap test_map;
const string node1("node1");
test_map.insert(0, node1);
vector<size_t> expected_parts;
size_t range = numeric_limits<size_t>::max() / test_map.num_partitions();
for (unsigned int i = 0; i < test_map.num_partitions(); i++) {
expected_parts.push_back(range*i);
}
vector<size_t> actual_parts = test_map.get_partitions();
EXPECT_THAT(actual_parts, ContainerEq(expected_parts));
}
TEST(ServerMapTest, TestGetChRingAsMap) {
ServerMap test_sm;
map<HashValueType, NodeInfo> expected_map;
for (int i = 0; i < 10; i++) {
NodeInfo node;
node.server_id = string("node") + to_string(i);
test_sm.add(i * 1000, node);
expected_map[i * 1000] = node;
}
auto actual_map = test_sm.get_ch_ring_as_map();
EXPECT_THAT(actual_map, ContainerEq(expected_map));
}
TEST_F(ClientMetadataTest, TestLocateIndicesForSearch) {
start(2, 1);
create_index("/foo/bar/test", "blue");
create_index("/foo/bar/test", "red");
create_index("/foo/bar/zoo", "blue");
ComplexQuery query;
query.parse("/foo/bar?blue>100");
vector<string> expected_indices = { "/foo/bar/test/.vsfs/blue",
"/foo/bar/zoo/.vsfs/blue" };
vector<string> actual_indices;
EXPECT_TRUE(client_->locate_index_for_search(query, &actual_indices).ok());
EXPECT_THAT(actual_indices, ContainerEq(expected_indices));
}
TEST_F(ClientMetadataTest, TestMakeDirs) {
start(4, 2);
create_directories("/test");
set<string> expected_files;
for (int i = 0; i < 100; i++) {
EXPECT_TRUE(client_->mkdir("/test/dir" + to_string(i),
0755, 100, 100).ok());
expected_files.insert("dir" + to_string(i));
}
vector<string> files;
EXPECT_TRUE(client_->readdir("/test", &files).ok());
set<string> actual_files(files.begin(), files.end());
EXPECT_THAT(actual_files, ContainerEq(expected_files));
}
TEST(HashIndexTest, TestInsertUint64) {
unique_ptr<HashIndexInterface> idx(new HashIndex<int>);
FileIdVector ids = {10, 11, 12};
for (auto id : ids) {
idx->insert(4, id);
}
FileIdVector actual_ids;
idx->search(4, &actual_ids);
sort(actual_ids.begin(), actual_ids.end());
EXPECT_THAT(actual_ids, ContainerEq(ids));
actual_ids.clear();
idx->search(5, &actual_ids);
EXPECT_EQ(0, actual_ids.size());
}
TEST(test_TestWithCorrectTransportAdapter, CorrectTransportAdapterBehavior)
{
Logger logger = log4cplus::Logger::getInstance(LOG4CPLUS_TEXT("TransportManagerTest"));
LOG4CPLUS_INFO_EXT(logger, "*************************** Starting test *****************************");
// All expectations must be sequenced
//InSequence dummy;
// Creating transport manager
TestTransportManager *pTm = new TestTransportManager();
// Preparing transport manage client
MockTransportManagerClient tmClient(*pTm);
// Expected device list
SDeviceInfo deviceInfo;
deviceInfo.mDeviceHandle = Data::DeviceHandle;
deviceInfo.mUniqueDeviceId = Data::UniqueDeviceId;
deviceInfo.mUserFriendlyName = Data::UserFriendlyName;
tDeviceList deviceList;
deviceList.push_back(deviceInfo);
EXPECT_CALL(tmClient, onDeviceListUpdated(ContainerEq(deviceList)))
.Times(1)
.WillOnce(Invoke(&tmClient, &MockTransportManagerClient::doDeviceListUpdated))
;
EXPECT_CALL(tmClient, onApplicationConnected(deviceInfo, Data::ConnectionHandle))
.Times(1)
;
EXPECT_CALL(tmClient, onFrameReceived(Data::ConnectionHandle, _, 212))
.Times(1)
.WillOnce(Invoke(&tmClient, &MockTransportManagerClient::doFrameReceived))
;
EXPECT_CALL(tmClient, onFrameSendCompleted(Data::ConnectionHandle, Data::UserData, SendStatusOK))
.Times(1)
.WillOnce(Invoke(&tmClient, &MockTransportManagerClient::doFrameSendCompleted))
;
EXPECT_CALL(tmClient, onApplicationDisconnected(deviceInfo, Data::ConnectionHandle))
.Times(1)
;
// Running test
pTm->addDataListener(&tmClient);
pTm->addDeviceListener(&tmClient);
LOG4CPLUS_INFO_EXT(logger, "*************************** Calling RUN *****************************");
pTm->run();
sleep(1);
LOG4CPLUS_INFO_EXT(logger, "*************************** Calling SCAN FOR DEVICES *****************************");
pTm->scanForNewDevices();
sleep(2);
LOG4CPLUS_INFO_EXT(logger, "*************************** Deleting TM and shutting down *****************************");
// Shutdown transport manager
delete pTm;
pTm = 0;
}
