void PelicanServerClientTest::test_getData()
{
Config config;
config.setFromString(
"<testconfig>"
" <server host=\"127.0.0.1\"/>"
"</testconfig>"
);
Config::TreeAddress address;
address << Config::NodeId("testconfig", "");
ConfigNode configNode = config.get(address);
TestStreamAdapter streamAdapter;
QString stream1("stream1");
QString version1("version1");
DataSpec req;
req.addStreamData(stream1);
{
// Use Case:
// data requirements are set, empty hash passed
// Expect: throw
QList<DataSpec> lreq;
lreq.append(req);
DataTypes dt;
dt.setAdapter(stream1,&streamAdapter);
dt.addData(lreq);
PelicanServerClient client(configNode, dt, 0);
QHash<QString, DataBlob*> dataHash;
CPPUNIT_ASSERT_THROW(client.getData(dataHash), QString );
}
{
// Use Case:
// Data Requirements do not match DataBlobs
// Expect:
// throw with a suitable message
// setup the test
QList<DataSpec> lreq;
lreq.append(req);
DataTypes dt;
dt.setAdapter(stream1,&streamAdapter);
dt.addData(lreq);
PelicanServerClient client(configNode, dt, 0);
QHash<QString, DataBlob*> dataHash;
DataBlob db("DataBlob");
dataHash.insert("pelican/data2", &db);
CPPUNIT_ASSERT_THROW(client.getData(dataHash), QString);
}
}
void PelicanServerClientTestMT::test_getData()
{
try{
// set up the test server
TestServiceAdapter serviceAdapter;
TestStreamAdapter streamAdapter;
TestServer server;
QString stream1("stream1");
QString service1("service1");
QString version1("version1");
QString version2("version2");
DataRequirements reqStream1;
reqStream1.addStreamData(stream1);
QByteArray data1("pelican/data1");
QByteArray data2("pelican/data2");
unsigned int port = server.port();
// common client configuration
Config config;
config.setFromString(
"",
"<testconfig>"
" <server host=\"127.0.0.1\"/>"
"</testconfig>"
);
Config::TreeAddress address;
address << Config::NodeId("server", "");
address << Config::NodeId("testconfig", "");
ConfigNode configNode = config.get(address);
{
// Use Case:
// request for Service Data only
// Expect :
// throw
DataChunk sd(service1, version1, data1 );
CPPUNIT_ASSERT_EQUAL( (long)data1.size(), (long)sd.size() );
// setup the test
DataRequirements req;
req.addServiceData(service1);
QList<DataRequirements> lreq;
lreq.append(req);
DataTypes dt;
dt.addData(lreq);
dt.setAdapter(service1, &serviceAdapter);
PelicanServerClient client(configNode, dt, 0);
client.setPort(port);
QHash<QString, DataBlob*> dataHash;
DataBlob db("DataBlob");
dataHash.insert(service1, &db);
CPPUNIT_ASSERT_THROW( client.getData(dataHash), QString );
}
{
// Use Case:
// Single Request for an existing stream dataset
// no service data
// Expect:
// return the required data stream
StreamData sd(stream1, version1, data1 );
CPPUNIT_ASSERT_EQUAL( (long)data1.size(), (long)sd.size() );
server.serveStreamData(sd);
// setup the test
QList<DataRequirements> lreq;
lreq.append(reqStream1);
DataTypes dt;
dt.addData(lreq);
dt.setAdapter(stream1, &streamAdapter);
PelicanServerClient client(configNode, dt, 0);
client.setPort(port);
QHash<QString, DataBlob*> dataHash;
TestDataBlob db;
dataHash.insert(stream1, &db);
client.getData(dataHash);
CPPUNIT_ASSERT_EQUAL(version1.toStdString(), db.version().toStdString() );
CPPUNIT_ASSERT_EQUAL( std::string(data1.data()), std::string(db.data()) );
}
{
// Use Case:
// Single Request for an existing stream dataset
// with existing service data
// Expect:
// return the required data stream
DataChunk servd(service1, version2, data2 );
server.serveServiceData(servd);
StreamData sd(stream1, version1, data1 );
CPPUNIT_ASSERT_EQUAL( (long)data1.size(), (long)sd.size() );
server.serveStreamData(sd);
// setup the test
DataRequirements req;
req.addServiceData(service1);
req.addStreamData(stream1);
QList<DataRequirements> lreq;
lreq.append(req);
DataTypes dt;
dt.addData(lreq);
dt.setAdapter(stream1, &streamAdapter);
dt.setAdapter(service1, &serviceAdapter);
PelicanServerClient client(configNode, dt, 0);
client.setPort(port);
QHash<QString, DataBlob*> dataHash;
TestDataBlob db;
TestDataBlob db_service;
dataHash.insert(stream1, &db);
dataHash.insert(service1, &db_service);
client.getData(dataHash);
CPPUNIT_ASSERT_EQUAL( version1.toStdString(), db.version().toStdString() );
CPPUNIT_ASSERT_EQUAL( version2.toStdString(), db_service.version().toStdString() );
CPPUNIT_ASSERT_EQUAL( std::string(data2.data()), std::string(db_service.data()) );
CPPUNIT_ASSERT_EQUAL( std::string(data1.data()), std::string(db.data()) );
}
}
catch(const QString& e)
{
std::cerr << "error: uncaught exception" << e.toStdString();
throw e;
}
}
void PelicanServerClientTest::test_response()
{
try {
TestServiceAdapter serviceAdapter;
TestStreamAdapter streamAdapter;
ConfigNode configNode;
configNode.setFromString(
"<testconfig>"
" <server host=\"127.0.0.1\"/>"
"</testconfig>"
);
QString stream1("stream1");
QString version1("v1");
QString service1("service1");
QString serviceVersion1("sv1");
DataSpec reqStream1;
reqStream1.addStreamData(stream1);
QByteArray data1("data1");
{
// Use Case
// receive a StreamData response (single stream, no service data)
boost::shared_ptr<ServerResponse> res( new StreamDataResponse );
static_cast<StreamDataResponse*>(res.get())->setStreamData( new StreamData(stream1,version1, data1.size()) );
// set up the adapters and client
QList<DataSpec> lreq;
lreq.append(reqStream1);
DataTypes dt;
dt.setAdapter(stream1,&streamAdapter);
dt.addData(lreq);
PelicanServerClient client(configNode, dt, 0);
// set up the memory for receiving data
TestDataBlob db;
QHash<QString, DataBlob*> dataHash;
dataHash.insert(stream1, &db);
SocketTester st;
QTcpSocket& sock = st.send(data1);
QHash<QString, DataBlob*> vhash = client._response( sock , res, dataHash );
CPPUNIT_ASSERT( vhash == dataHash );
CPPUNIT_ASSERT_EQUAL( version1.toStdString(), vhash[stream1]->version().toStdString() );
CPPUNIT_ASSERT_EQUAL( std::string( data1.data() ) , std::string( static_cast<TestDataBlob*>(vhash[stream1])->data() ) );
}
QByteArray data2("data2");
{
// Use Case
// ServiceData response - single service data
boost::shared_ptr<ServerResponse> res( new ServiceDataResponse );
static_cast<ServiceDataResponse*>(res.get())->addData( new DataChunk(service1,serviceVersion1, data2.size()) );
// set up the memory for receiving data
TestDataBlob db;
QHash<QString, DataBlob*> dataHash;
dataHash.insert(service1, &db);
// set up the adapters and client
DataSpec req;
req.addStreamData(service1);
QList<DataSpec> lreq;
lreq.append(req);
DataTypes dt;
dt.setAdapter(service1,&serviceAdapter);
dt.addData(lreq);
PelicanServerClient client(configNode, dt, 0);
SocketTester st;
QTcpSocket& sock = st.send(data2);
QHash<QString, DataBlob*> vhash = client._response( sock , res, dataHash );
CPPUNIT_ASSERT( vhash == dataHash );
CPPUNIT_ASSERT_EQUAL( serviceVersion1.toStdString(), vhash[service1]->version().toStdString() );
CPPUNIT_ASSERT_EQUAL( std::string( data2.data() ) , std::string( static_cast<TestDataBlob*>(vhash[service1])->data() ) );
}
QString service2("service2");
{
// Use Case
// ServiceData response - multiple service data
boost::shared_ptr<ServerResponse> res( new ServiceDataResponse );
static_cast<ServiceDataResponse*>(res.get())->addData( new DataChunk(service1,version1, data1.size()) );
static_cast<ServiceDataResponse*>(res.get())->addData( new DataChunk(service2,serviceVersion1, data2.size()) );
// set up the memory for receiving data
TestDataBlob db;
TestDataBlob db2;
QHash<QString, DataBlob*> dataHash;
dataHash.insert(service1, &db);
dataHash.insert(service2, &db2);
// set up the adapters and client
DataSpec req;
req.addStreamData(service1);
QList<DataSpec> lreq;
lreq.append(req);
DataTypes dt;
dt.setAdapter(service1,&serviceAdapter);
dt.setAdapter(service2,&serviceAdapter);
dt.addData(lreq);
PelicanServerClient client(configNode, dt, 0);
SocketTester st;
QTcpSocket& sock = st.send( data1 + data2 );
QHash<QString, DataBlob*> vhash = client._response( sock , res, dataHash );
CPPUNIT_ASSERT( vhash == dataHash );
CPPUNIT_ASSERT_EQUAL( version1.toStdString(), vhash[service1]->version().toStdString() );
CPPUNIT_ASSERT_EQUAL( serviceVersion1.toStdString(), vhash[service2]->version().toStdString() );
CPPUNIT_ASSERT_EQUAL( std::string( data1.data() ) , std::string( static_cast<TestDataBlob*>(vhash[service1])->data() ) );
CPPUNIT_ASSERT_EQUAL( std::string( data2.data() ) , std::string( static_cast<TestDataBlob*>(vhash[service2])->data() ) );
}
// {
// // Use Case
// // receive a StreamData response with associated service data (single stream, single service data)
// // no existing service data exists
// boost::shared_ptr<ServerResponse> res( new StreamDataResponse );
// StreamData* sd = new StreamData(stream1,version1, data1.size());
// sd->addAssociatedData(boost::shared_ptr<Data>(new Data(service1,serviceVersion1, data2.size()) ) );
// static_cast<StreamDataResponse*>(res.get())->setStreamData( sd );
//
// // set up the adapters and client
// DataSpec req;
// req.addStreamData(stream1);
// req.addServiceData(service1);
// QList<DataSpec> lreq;
// lreq.append(req);
// DataTypes dt;
// dt.setAdapter(stream1,&streamAdapter);
// dt.setAdapter(service1,&serviceAdapter);
// dt.addData(lreq);
// PelicanServerClient client(configNode, dt, 0);
//
// // set up the memory for receiving data
// TestDataBlob db;
// TestDataBlob db2;
// QHash<QString, DataBlob*> dataHash;
// dataHash.insert(stream1, &db);
// dataHash.insert(service1, &db2);
//
// SocketTester st;
// QTcpSocket& sock = st.send(data1);
// try {
// QHash<QString, DataBlob*> vhash = client._response( sock , res, dataHash );
// } catch (const QString& e) {
// CPPUNIT_FAIL(e.toStdString());
// }
// CPPUNIT_ASSERT( vhash == dataHash );
// CPPUNIT_ASSERT_EQUAL( version1.toStdString(), vhash[stream1]->version().toStdString() );
// CPPUNIT_ASSERT_EQUAL( serviceVersion1.toStdString(), vhash[service1]->version().toStdString() );
// CPPUNIT_ASSERT_EQUAL( std::string( data1.data() ) , std::string( static_cast<TestDataBlob*>( vhash[stream1])->data() ) );
// CPPUNIT_ASSERT_EQUAL( std::string( data2.data() ) , std::string( static_cast<TestDataBlob*>( vhash[service1])->data() ) );
// }
} catch ( const QString& e ) {
CPPUNIT_FAIL( e.toStdString() );
}
}
void FileDataClientTest::test_method()
{
try {
Config config;
config.setFromString(
"<testconfig>"
" <file name=\"testfile.xml\"/>"
"</testconfig>"
);
Config::TreeAddress address;
address << Config::NodeId("testconfig", "");
ConfigNode configNode = config.get(address);
/* No longer relevant
{
// Use Case:
// Empty data requirements
// Expect: throw with a suitable complaint
// setup the test
QList<DataSpec> lreq;
DataTypes dt;
dt.addData(lreq);
FileDataClient* client = 0;
CPPUNIT_ASSERT_THROW(client = new FileDataClient(configNode, dt, 0), QString);
delete client;
}
*/
TestStreamAdapter streamAdapter;
QString stream1("stream1");
QString version1("version1");
DataSpec req;
req.addStreamData(stream1);
{
// Use Case:
// data requirements are set, empty hash passed
// Expect: throw
QList<DataSpec> lreq;
lreq.append(req);
DataTypes dt;
dt.setAdapter(stream1,&streamAdapter);
dt.addData(lreq);
FileDataClient client(configNode, dt, 0);
QHash<QString, DataBlob*> dataHash;
CPPUNIT_ASSERT_THROW(client.getData(dataHash), QString );
}
{ // Use Case:
// Specifiy a single file and associate it with a Stream
// correct hash is passed
// Expect:
// Data in file to be streamed
DataTypes types;
types.setAdapter(stream1,&streamAdapter);
types.addData(req);
FileDataClient client(configNode, types, &config);
QHash<QString, DataBlob*> dataHash;
DataBlob db("DataBlob");
dataHash.insert(stream1, &db);
client.getData(dataHash);
}
}
catch( QString& e ) {
CPPUNIT_FAIL(e.toStdString());
}
}