mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-12-12 01:14:29 -05:00
341 lines
9.4 KiB
C++
341 lines
9.4 KiB
C++
/*******************************************************************************
|
|
* unittests/libretroshare/gxs/data_service/rsdataservice_test.cc *
|
|
* *
|
|
* Copyright (C) 2018, Retroshare team <retroshare.team@gmailcom> *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU Affero General Public License as *
|
|
* published by the Free Software Foundation, either version 3 of the *
|
|
* License, or (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Lesser General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Lesser General Public License *
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
|
|
* *
|
|
******************************************************************************/
|
|
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "libretroshare/serialiser/support.h"
|
|
#include "libretroshare/gxs/common/data_support.h"
|
|
#include "rsdataservice_test.h"
|
|
#include "gxs/rsgds.h"
|
|
#include "gxs/rsgxsutil.h"
|
|
#include "gxs/rsdataservice.h"
|
|
|
|
#define DATA_BASE_NAME "msg_grp_Store"
|
|
|
|
|
|
RsGeneralDataService* dStore = NULL;
|
|
|
|
void setUp();
|
|
void tearDown();
|
|
|
|
TEST(libretroshare_gxs, RsDataService)
|
|
{
|
|
|
|
std::cerr << "RsDataService Tests" << std::endl;
|
|
|
|
test_groupStoreAndRetrieve();
|
|
test_messageStoresAndRetrieve();
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
* All memory is disposed off, good for looking
|
|
* for memory leaks
|
|
*/
|
|
void test_groupStoreAndRetrieve(){
|
|
|
|
setUp();
|
|
|
|
int nGrp = rand()%32;
|
|
RsNxsGrpDataTemporaryList grps, grps_copy;
|
|
RsNxsGrp* grp;
|
|
RsGxsGrpMetaData* grpMeta;
|
|
|
|
for(int i = 0; i < nGrp; i++)
|
|
{
|
|
std::pair<RsNxsGrp*, RsGxsGrpMetaData*> p;
|
|
grp = new RsNxsGrp(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
|
|
grpMeta = new RsGxsGrpMetaData();
|
|
|
|
init_item(*grp);
|
|
init_item(grpMeta);
|
|
|
|
grpMeta->mGroupId = grp->grpId;
|
|
grp->metaData = grpMeta ;
|
|
|
|
grps.push_back(grp);
|
|
}
|
|
|
|
dStore->storeGroup(grps);
|
|
|
|
RsNxsGrpDataTemporaryMap gR;
|
|
RsGxsGrpMetaTemporaryMap grpMetaR;
|
|
|
|
dStore->retrieveNxsGrps(gR, false, false);
|
|
dStore->retrieveGxsGrpMetaData(grpMetaR);
|
|
|
|
bool grpMatch = true, grpMetaMatch = true;
|
|
|
|
for( std::list<RsNxsGrp*>::iterator mit = grps.begin(); mit != grps.end(); mit++)
|
|
{
|
|
const RsGxsGroupId grpId = (*mit)->metaData->mGroupId;
|
|
|
|
// check if it exists
|
|
if(gR.find(grpId) == gR.end()) {
|
|
grpMatch = false;
|
|
break;
|
|
}
|
|
|
|
RsNxsGrp *l = *mit;
|
|
RsNxsGrp *r = gR[grpId];
|
|
|
|
// assign transaction number
|
|
// to right to as tn is not stored
|
|
// in db
|
|
r->transactionNumber = l->transactionNumber;
|
|
|
|
// then do a comparison
|
|
if(!( *l == *r)) {
|
|
grpMatch = false;
|
|
break;
|
|
}
|
|
|
|
// now do a comparison of grp meta types
|
|
|
|
if(grpMetaR.find(grpId) == grpMetaR.end())
|
|
{
|
|
grpMetaMatch = false;
|
|
break;
|
|
}
|
|
|
|
RsGxsGrpMetaData *l_Meta = (*mit)->metaData,
|
|
*r_Meta = const_cast<RsGxsGrpMetaData*>(grpMetaR[grpId]);
|
|
|
|
// assign signSet and mGrpSize
|
|
// to right as these values are not stored in db
|
|
r_Meta->signSet = l_Meta->signSet;
|
|
r_Meta->mGrpSize = l_Meta->mGrpSize;
|
|
|
|
if(!(*l_Meta == *r_Meta))
|
|
{
|
|
grpMetaMatch = false;
|
|
break;
|
|
}
|
|
|
|
remove(grpId.toStdString().c_str());
|
|
}
|
|
|
|
grpMetaR.clear();
|
|
|
|
EXPECT_TRUE(grpMatch && grpMetaMatch);
|
|
tearDown();
|
|
}
|
|
|
|
/*!
|
|
* Test for both selective and
|
|
* bulk msg retrieval
|
|
*/
|
|
void test_messageStoresAndRetrieve()
|
|
{
|
|
setUp();
|
|
|
|
// first create a grpId
|
|
RsGxsGroupId grpId0, grpId1;
|
|
|
|
grpId0 = RsGxsGroupId::random();
|
|
grpId1 = RsGxsGroupId::random();
|
|
std::vector<RsGxsGroupId> grpV; // stores grpIds of all msgs stored and retrieved
|
|
grpV.push_back(grpId0);
|
|
grpV.push_back(grpId1);
|
|
|
|
RsNxsMsgDataTemporaryList msgs;
|
|
RsNxsMsg* msg = NULL;
|
|
RsGxsMsgMetaData* msgMeta = NULL;
|
|
int nMsgs = rand()%120;
|
|
GxsMsgReq req;
|
|
|
|
// These ones are not in auto-delete structures because the data is deleted as part of the RsNxsMsg struct in the msgs list.
|
|
std::map<RsGxsMessageId,RsNxsMsg*> VergrpId0 ;
|
|
std::map<RsGxsMessageId,RsNxsMsg*> VergrpId1 ;
|
|
|
|
std::map<RsGxsMessageId, RsGxsMsgMetaData*> VerMetagrpId0;
|
|
std::map<RsGxsMessageId, RsGxsMsgMetaData*> VerMetagrpId1;
|
|
|
|
for(int i=0; i<nMsgs; i++)
|
|
{
|
|
msg = new RsNxsMsg(RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
|
|
msgMeta = new RsGxsMsgMetaData();
|
|
init_item(*msg);
|
|
init_item(msgMeta);
|
|
|
|
msg->metaData = msgMeta ;
|
|
|
|
std::pair<RsNxsMsg*, RsGxsMsgMetaData*> p(msg, msgMeta);
|
|
int chosen = 0;
|
|
if(rand()%50 > 24){
|
|
chosen = 1;
|
|
|
|
}
|
|
|
|
const RsGxsGroupId& grpId = grpV[chosen];
|
|
|
|
if(chosen)
|
|
req[grpId].push_back(msg->msgId);
|
|
|
|
msgMeta->mMsgId = msg->msgId;
|
|
msgMeta->mGroupId = msg->grpId = grpId;
|
|
|
|
// store msgs in map to use for verification
|
|
std::pair<RsGxsMessageId, RsNxsMsg*> vP(msg->msgId, msg);
|
|
std::pair<RsGxsMessageId, RsGxsMsgMetaData*> vPmeta(msg->msgId, msgMeta);
|
|
|
|
if(!chosen)
|
|
{
|
|
VergrpId0.insert(vP);
|
|
VerMetagrpId0.insert(vPmeta);
|
|
}
|
|
else
|
|
{
|
|
VergrpId1.insert(vP);
|
|
VerMetagrpId0.insert(vPmeta);
|
|
}
|
|
|
|
|
|
msgs.push_back(msg);
|
|
}
|
|
|
|
req[grpV[0]] = std::vector<RsGxsMessageId>(); // assign empty list for other
|
|
|
|
dStore->storeMessage(msgs);
|
|
|
|
// now retrieve msgs for comparison
|
|
// first selective retrieval
|
|
|
|
t_RsGxsGenericDataTemporaryMapVector<RsNxsMsg> msgResult ; //GxsMsgResult msgResult;. The temporary version cleans up itself.
|
|
t_RsGxsGenericDataTemporaryMapVector<RsGxsMsgMetaData> msgMetaResult ;
|
|
|
|
dStore->retrieveNxsMsgs(req, msgResult, false);
|
|
dStore->retrieveGxsMsgMetaData(req, msgMetaResult);
|
|
|
|
// now look at result for grpId 1
|
|
std::vector<RsNxsMsg*>& result0 = msgResult[grpId0];
|
|
std::vector<RsNxsMsg*>& result1 = msgResult[grpId1];
|
|
std::vector<RsGxsMsgMetaData*>& resultMeta0 = msgMetaResult[grpId0];
|
|
//std::vector<RsGxsMsgMetaData*>& resultMeta1 = msgMetaResult[grpId1];
|
|
|
|
|
|
|
|
bool msgGrpId0_Match = true, msgGrpId1_Match = true;
|
|
bool msgMetaGrpId0_Match = true/*, msgMetaGrpId1_Match = true*/;
|
|
|
|
// MSG test, selective retrieval
|
|
for(std::vector<RsNxsMsg*>::size_type i = 0; i < result0.size(); i++)
|
|
{
|
|
RsNxsMsg* l = result0[i] ;
|
|
|
|
if(VergrpId0.find(l->msgId) == VergrpId0.end())
|
|
{
|
|
msgGrpId0_Match = false;
|
|
break;
|
|
}
|
|
|
|
RsNxsMsg* r = VergrpId0[l->msgId];
|
|
r->transactionNumber = l->transactionNumber;
|
|
|
|
if(!(*l == *r))
|
|
{
|
|
msgGrpId0_Match = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
EXPECT_TRUE(msgGrpId0_Match);
|
|
|
|
// META test
|
|
for(std::vector<RsGxsMsgMetaData*>::size_type i = 0; i < resultMeta0.size(); i++)
|
|
{
|
|
RsGxsMsgMetaData* l = resultMeta0[i] ;
|
|
|
|
if(VerMetagrpId0.find(l->mMsgId) == VerMetagrpId0.end())
|
|
{
|
|
msgMetaGrpId0_Match = false;
|
|
break;
|
|
}
|
|
|
|
RsGxsMsgMetaData* r = VerMetagrpId0[l->mMsgId];
|
|
|
|
if(!(*l == *r))
|
|
{
|
|
msgMetaGrpId0_Match = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
EXPECT_TRUE(msgMetaGrpId0_Match);
|
|
|
|
// MSG test, bulk retrieval
|
|
for(std::vector<RsNxsMsg*>::size_type i = 0; i < result1.size(); i++)
|
|
{
|
|
RsNxsMsg* l = result1[i] ;
|
|
|
|
if(VergrpId1.find(l->msgId) == VergrpId1.end())
|
|
{
|
|
msgGrpId1_Match = false;
|
|
break;
|
|
}
|
|
|
|
RsNxsMsg* r = VergrpId1[l->msgId];
|
|
|
|
r->transactionNumber = l->transactionNumber;
|
|
|
|
if(!(*l == *r))
|
|
{
|
|
msgGrpId1_Match = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
EXPECT_TRUE(msgGrpId1_Match);
|
|
|
|
//dStore->retrieveGxsMsgMetaData();
|
|
std::string msgFile = grpId0.toStdString() + "-msgs";
|
|
remove(msgFile.c_str());
|
|
msgFile = grpId1.toStdString() + "-msgs";
|
|
remove(msgFile.c_str());
|
|
tearDown();
|
|
}
|
|
|
|
|
|
|
|
void setUp(){
|
|
dStore = new RsDataService(".", DATA_BASE_NAME, RS_SERVICE_TYPE_PLUGIN_SIMPLE_FORUM);
|
|
}
|
|
|
|
void tearDown(){
|
|
|
|
dStore->resetDataStore(); // reset to clean up store files except db
|
|
delete dStore;
|
|
dStore = NULL;
|
|
int rc = remove(DATA_BASE_NAME);
|
|
|
|
if(rc == 0){
|
|
std::cerr << "Successful tear down" << std::endl;
|
|
}
|
|
else{
|
|
std::cerr << "Tear down failed" << std::endl;
|
|
perror("Error: ");
|
|
}
|
|
|
|
}
|
|
|
|
|