SphinxIndexTest.cpp

Go to the documentation of this file.

#include <gtest/gtest.h>
#include <vector>
#include <assert.h>
#include <sstream>
#include <iomanip>
#include <fstream>

#include "EncodeDecodeBase64.hpp"
#include "SphinxIndexTest.hpp"
#include "SphinxSearchTest.hpp"
#include "SphinxManageTest.hpp"
#include "SphinxInputJsonMessage.hpp"
#include "SphinxOutputJsonMessage.hpp"
#include "SphinxDataSource.hpp"
#include "SphinxFunctionalObject.hpp"
#include "SphinxInputJsonMessageSearch.hpp"
#include "SphinxInputJsonMessageIndex.hpp"
#include "SphinxInputJsonMessageManage.hpp"
#include "SphinxPrintStatus.hpp"

namespace HCE
{
namespace sphinx
{
namespace tests
{
//-----------------------------------------------------------------------------
void SphinxIndexTest::testDataStorage(void)
{
  const std::string testOutFile = "./out.xml";

  std::stringstream inSchema, inDocument;
  inSchema << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<sphinx:docset xmlns:sphinx=\"http://sphinxsearch.com\">\n<sphinx:schema>\n<sphinx:field name=\"title\"/>\n<sphinx:field name=\"h\"/>\n</sphinx:schema>\n</sphinx:docset>";

  inDocument << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<sphinx:docset xmlns:sphinx=\"http://sphinxsearch.com\">\n<sphinx:document id=\"123\">\n"
    <<  "<title><![CDATA[[- Information interchange - Representation of dates and times. A discussion of ISO 8601 has been written by Markus Kuhn. ISO 8601 describes a large number of date/time formats. For example it defines Basic Format, without punctuation, and Extended Format, with punctuation, and it allows elements to be omitted. This profile defines a restricted range of formats, all of which are valid ISO 8601 dates and times. The aim is to simplify the use of ISO 8601 in World Wide Web-related standards, and to avoid the need for the developers and users of these standards to obtain copies of ISO 8601 itself.]]></title>\n"
    <<  "<h><![CDATA[[time, so this profile defines six levels. Standards that reference this profile should specify one or more of these granularities. If a given standard allows more than one granularity, it should specify the meaning of the dates and times with reduced precision, for example, the result of comparing two dates with different precisions. The formats are as follows. Exactly the components shown here must be present, with exactly this punctuation. Note that the \"T\" appears literally in the string, to indicate the beginning of the time element, as specified in ISO 8601. Year: YYYY (eg 1997) Year and month: YYYY-MM (eg 1997-07)]]></h>\n"
    <<  "</sphinx:document>\n</sphinx:docset>";

  SphinxDataSource dataSource(inSchema, inDocument);

  std::fstream outSource(testOutFile.c_str(), std::fstream::out | std::fstream::trunc);
  ASSERT_TRUE(outSource.is_open());

  outSource << dataSource;
  outSource.close();
  ASSERT_FALSE(dataSource.isError());
  ASSERT_TRUE(dataSource.getErrorMsg().empty());
  ASSERT_TRUE(remove((testOutFile).c_str())==0);
  printSuccess("Test create document storage");
}
//-----------------------------------------------------------------------------
std::string SphinxIndexTest::makeJson(unsigned int type)
{
  std::string json;

  if (type==0)
  {
    SphinxInputJsonMessageSearch msgSearch;
    msgSearch.setQueryString("(piece -war)");
    msgSearch.addQueryParameters("queryId", "777");
    msgSearch.addQueryParameters("JsonType", "7");
    msgSearch.serialize(json);
  }
  else if (type==1)
  {
    SphinxInputJsonMessageIndex msgIndex;
    msgIndex.setIndexName("branch_0001");
    msgIndex.setDocumentFile("");
    msgIndex.addParameters("n1", "1");
    msgIndex.addParameters("n2", "2");
    msgIndex.addParameters("n3", "3");
    msgIndex.serialize(json);
  }
  else if (type==2)
  {
    SphinxInputJsonMessageManage msgManage;
    msgManage.setCommandString("Add index");
    msgManage.setCommandOptionsString("--All --rotate");
    msgManage.serialize(json);
  }
  else
    std::cerr << "Unknown type of handler\n";

  return json;
}
//-----------------------------------------------------------------------------
void SphinxIndexTest::testInputJsonSearch(void)
{
  std::string json = makeJson(0);

  Poco::SharedPtr<SphinxInputJsonMessageSearch> msgSearch(new SphinxInputJsonMessageSearch());
  msgSearch->unserialize(json);
  ASSERT_FALSE(msgSearch->isError());

  std::stringstream str(json);
  str >> *msgSearch;
  std::stringstream out;
  out << *msgSearch;
  ASSERT_FALSE(msgSearch->isError());

//  std::cout << "json: " << json << std::endl;
//  std::cout << " out: " << out.str() << std::endl;

  ASSERT_TRUE(json==out.str());

  Poco::SharedPtr<SphinxInputJsonMessage> handler(new SphinxInputJsonMessage());
  handler->setData(json);

  json = "";
  handler->serialize(json);
  ASSERT_FALSE(handler->isError());
  handler->getData().clear();
  handler->unserialize(json);
  out.str("");
  out << *handler;
  ASSERT_FALSE(handler->isError());

//  std::cout << "json: " << json << std::endl;
//  std::cout << " out: " << out.str() << std::endl;

  ASSERT_TRUE(json==out.str());
  printSuccess("Test input json search");
}
//-----------------------------------------------------------------------------
void SphinxIndexTest::testInputJsonIndex(void)
{
  std::string json = makeJson(1);

  Poco::SharedPtr<SphinxInputJsonMessageIndex> msgIndex(new SphinxInputJsonMessageIndex());
  msgIndex->unserialize(json);

  std::stringstream str(json);
  str >> *msgIndex;
  ASSERT_FALSE(msgIndex->isError());
  std::stringstream out;
  out << *msgIndex;
  ASSERT_FALSE(msgIndex->isError());

//  std::cout << "json: " << json << std::endl;
//  std::cout << " out: " << out.str() << std::endl;

  ASSERT_TRUE(json==out.str());

  SphinxInputJsonMessage handler(SphinxInputJsonMessage::MessageType::mtIndex);
  handler.setData(json);

  json = "";
  handler.serialize(json);
  ASSERT_FALSE(handler.isError());
  handler.getData().clear();
  handler.unserialize(json);
  out.str("");
  out << handler;
  ASSERT_FALSE(handler.isError());

//  std::cout << "json: " << json << std::endl;
//  std::cout << " out: " << out.str() << std::endl;

  ASSERT_TRUE(json==out.str());
  printSuccess("Test input json index");
}
//-----------------------------------------------------------------------------
void SphinxIndexTest::testInputJsonManage(void)
{
  std::string json = makeJson(2);

  Poco::SharedPtr<SphinxInputJsonMessageManage> msgManage(new SphinxInputJsonMessageManage());
  msgManage->unserialize(json);

  std::stringstream str(json);
  str >> *msgManage;
  ASSERT_FALSE(msgManage->isError());
  std::stringstream out;
  out << *msgManage;
  ASSERT_FALSE(msgManage->isError());

//  std::cout << "json: " << json << std::endl;
//  std::cout << " out: " << out.str() << std::endl;

  ASSERT_TRUE(json==out.str());

  SphinxInputJsonMessage handler(SphinxInputJsonMessage::MessageType::mtManage);
  handler.setData(json);

  json = "";
  handler.serialize(json);
  ASSERT_FALSE(handler.isError());
  handler.getData().clear();
  handler.unserialize(json);
  out.str("");
  out << handler;
  ASSERT_FALSE(handler.isError());

//  std::cout << "json: " << json << std::endl;
//  std::cout << " out: " << out.str() << std::endl;

  ASSERT_TRUE(json==out.str());
  printSuccess("Test input json manage");
}
//-----------------------------------------------------------------------------
void SphinxIndexTest::testInputJsonMessage(void)
{
  testInputJsonSearch();
  testInputJsonIndex();
  testInputJsonManage();
}
//-----------------------------------------------------------------------------
void SphinxIndexTest::testIndexerProcess(SphinxFunctionalObject& fObj)
{
  const std::string schemaContent =
  "<?xml version=\"1.0\" encoding=\"utf-8\"?> \n\
  <sphinx:docset xmlns:sphinx=\"http://sphinxsearch.com\">\n\
  <sphinx:schema>\n\
  <sphinx:field name=\"bodyn\"/>\n\
  <sphinx:attr name=\"cdate\" type=\"timestamp\"/>\n\
  </sphinx:schema>\n\
  </sphinx:docset>\n";

  const std::string documentContents [2] =
  {"<sphinx:docset xmlns:sphinx=\"http://sphinxsearch.com\">\n\
  <sphinx:document id=\"1111\">\n\
  <bodyn>Some body for test...</bodyn>\n\
  <cdate>1232244134</cdate>\n\
  </sphinx:document>\n\
  \n\
  <sphinx:document id=\"2222\">\n\
  <bodyn>Next some body for test...</bodyn>\n\
  <cdate>1232567575</cdate>\n\
  </sphinx:document>\n\
  </sphinx:docset>\n",

  "<sphinx:docset xmlns:sphinx=\"http://sphinxsearch.com\">\n\
  <sphinx:document id=\"3333\">\n\
  <bodyn>Some body for test...</bodyn>\n\
  <cdate>1232244134</cdate>\n\
  </sphinx:document>\n\
  \n\
  <sphinx:document id=\"4444\">\n\
  <bodyn>Next some body for test...</bodyn>\n\
  <cdate>1232567575</cdate>\n\
  </sphinx:document>\n\
  </sphinx:docset>\n"};

  const std::string nodeName = "test_node";
  const std::string indexName = "i003";

  SphinxManageTest::testIndexCreate(fObj, indexName);
  SphinxManageTest::testIndexCheck(fObj, indexName, true);
  SphinxManageTest::testIndexStoreSchemaFile(fObj, indexName, schemaContent);

  const size_t jsonType = 16;
  for (size_t i=0;i<jsonType;++i)
  {
    std::string json;
    Poco::SharedPtr<SphinxInputJsonMessageIndex> msgIndex = new SphinxInputJsonMessageIndex();
    msgIndex->setIndexName(indexName);
    msgIndex->setDocumentFile(HCE::encodeBase64(documentContents[0]));
    msgIndex->addParameters("params", "111");
    msgIndex->serialize(json);

    SphinxInputJsonMessage handler(SphinxInputJsonMessage::MessageType::mtIndex);
    handler.setData(json);

    std::stringstream str;
    str << handler;

    std::string ret = fObj.Process(str.str());

    std::cout << "ret: '" << ret << "'\n";

    if (!fObj.getErrorMsg().empty())
      std::cout << "ErrorMsg: '" << fObj.getErrorMsg() << "'\n";

    if (fObj.getErrorCode())
       std::cout << "ErrorCode = " << fObj.getErrorCode() << std::endl;

    ASSERT_TRUE(fObj.getErrorMsg().empty());

    SphinxOutputJsonMessage ouputJsonMessage(ret);
    assert(!ouputJsonMessage.isError());
    assert(ouputJsonMessage.getErrorCode()==0);
    assert(ouputJsonMessage.getErrorMessage().empty());


    SphinxFunctionalObject fObject(nodeName, fObj.getHomeDir() , indexName, sphinx_search_const::searchdStart, sphinx_search_const::searchdStop);
    SphinxSearchTest::testSearcherProcess(fObject, "for", 4);
    ASSERT_FALSE(fObject.isError());
  }
  SphinxManageTest::testIndexRemove(fObj, indexName);
  printSuccess("Test Indexer Process");
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace tests
} // end namespace sphinx
} // end namespace HCE